@effect/platform 0.67.1 → 0.68.1

package/src/internal/httpClient.ts

@@ -1,6 +1,3 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import type * as Fiber from "effect/Fiber"
@@ -22,7 +19,6 @@ import type * as ClientRequest from "../HttpClientRequest.js"
 import type * as ClientResponse from "../HttpClientResponse.js"
 import * as TraceContext from "../HttpTraceContext.js"
 import * as UrlParams from "../UrlParams.js"
-import * as internalBody from "./httpBody.js"
 import * as internalRequest from "./httpClientRequest.js"
 import * as internalResponse from "./httpClientResponse.js"
 
@@ -32,7 +28,7 @@ export const TypeId: Client.TypeId = Symbol.for(
 ) as Client.TypeId
 
 /** @internal */
-export const tag = Context.GenericTag<Client.HttpClient.Service>("@effect/platform/HttpClient")
+export const tag = Context.GenericTag<Client.HttpClient>("@effect/platform/HttpClient")
 
 /** @internal */
 export const currentTracerDisabledWhen = globalValue(
@@ -79,43 +75,43 @@ const ClientProto = {
       _id: "@effect/platform/HttpClient"
     }
   },
-  get(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoBody) {
+  get(this: Client.HttpClient, url: string | URL, options?: ClientRequest.Options.NoBody) {
     return this.execute(internalRequest.get(url, options))
   },
-  head(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoBody) {
+  head(this: Client.HttpClient, url: string | URL, options?: ClientRequest.Options.NoBody) {
     return this.execute(internalRequest.head(url, options))
   },
-  post(this: Client.HttpClient.Service, url: string | URL, options: ClientRequest.Options.NoUrl) {
+  post(this: Client.HttpClient, url: string | URL, options: ClientRequest.Options.NoUrl) {
     return this.execute(internalRequest.post(url, options))
   },
-  put(this: Client.HttpClient.Service, url: string | URL, options: ClientRequest.Options.NoUrl) {
+  put(this: Client.HttpClient, url: string | URL, options: ClientRequest.Options.NoUrl) {
     return this.execute(internalRequest.put(url, options))
   },
-  patch(this: Client.HttpClient.Service, url: string | URL, options: ClientRequest.Options.NoUrl) {
+  patch(this: Client.HttpClient, url: string | URL, options: ClientRequest.Options.NoUrl) {
     return this.execute(internalRequest.patch(url, options))
   },
-  del(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoUrl) {
+  del(this: Client.HttpClient, url: string | URL, options?: ClientRequest.Options.NoUrl) {
     return this.execute(internalRequest.del(url, options))
   },
-  options(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoBody) {
+  options(this: Client.HttpClient, url: string | URL, options?: ClientRequest.Options.NoBody) {
     return this.execute(internalRequest.options(url, options))
   }
 }
 
-const isClient = (u: unknown): u is Client.HttpClient<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
+const isClient = (u: unknown): u is Client.HttpClient<unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
-interface HttpClientImpl<A, E, R> extends Client.HttpClient<A, E, R> {
+interface HttpClientImpl<E, R> extends Client.HttpClient<E, R> {
   readonly preprocess: Client.HttpClient.Preprocess<E, R>
-  readonly postprocess: Client.HttpClient.Postprocess<A, E, R>
+  readonly postprocess: Client.HttpClient.Postprocess<E, R>
 }
 
 /** @internal */
-export const make = <E2, R2, A, E, R>(
+export const makeWith = <E2, R2, E, R>(
   postprocess: (
     request: Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
   preprocess: Client.HttpClient.Preprocess<E2, R2>
-): Client.HttpClient<A, E, R> => {
+): Client.HttpClient<E, R> => {
   const self = Object.create(ClientProto)
   self.preprocess = preprocess
   self.postprocess = postprocess
@@ -126,15 +122,15 @@ export const make = <E2, R2, A, E, R>(
 }
 
 /** @internal */
-export const makeService = (
+export const make = (
   f: (
     request: ClientRequest.HttpClientRequest,
     url: URL,
     signal: AbortSignal,
     fiber: Fiber.RuntimeFiber<ClientResponse.HttpClientResponse, Error.HttpClientError>
   ) => Effect.Effect<ClientResponse.HttpClientResponse, Error.HttpClientError, Scope.Scope>
-): Client.HttpClient.Service =>
-  make((effect) =>
+): Client.HttpClient =>
+  makeWith((effect) =>
     Effect.flatMap(effect, (request) =>
       Effect.withFiberRuntime((fiber) => {
         const scope = Context.unsafeGet(fiber.getFiberRef(FiberRef.currentContext), Scope.Scope)
@@ -202,24 +198,43 @@ export const makeService = (
         )
       })), Effect.succeed as Client.HttpClient.Preprocess<never, never>)
 
+export const {
+  /** @internal */
+  del,
+  /** @internal */
+  execute,
+  /** @internal */
+  get,
+  /** @internal */
+  head,
+  /** @internal */
+  options,
+  /** @internal */
+  patch,
+  /** @internal */
+  post,
+  /** @internal */
+  put
+} = Effect.serviceFunctions(tag)
+
 /** @internal */
 export const transform = dual<
-  <A, E, R, A1, E1, R1>(
+  <E, R, E1, R1>(
     f: (
-      effect: Effect.Effect<A, E, R>,
+      effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
       request: ClientRequest.HttpClientRequest
-    ) => Effect.Effect<A1, E1, R1>
-  ) => (self: Client.HttpClient<A, E, R>) => Client.HttpClient<A1, E | E1, R | R1>,
-  <A, E, R, A1, E1, R1>(
-    self: Client.HttpClient<A, E, R>,
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ) => (self: Client.HttpClient<E, R>) => Client.HttpClient<E | E1, R | R1>,
+  <E, R, E1, R1>(
+    self: Client.HttpClient<E, R>,
     f: (
-      effect: Effect.Effect<A, E, R>,
+      effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
       request: ClientRequest.HttpClientRequest
-    ) => Effect.Effect<A1, E1, R1>
-  ) => Client.HttpClient<A1, E | E1, R | R1>
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ) => Client.HttpClient<E | E1, R | R1>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make(
+  const client = self as HttpClientImpl<any, any>
+  return makeWith(
     Effect.flatMap((request) => f(client.postprocess(Effect.succeed(request)), request)),
     client.preprocess
   )
@@ -230,70 +245,68 @@ export const filterStatus = dual<
   (
     f: (status: number) => boolean
   ) => <E, R>(
-    self: Client.HttpClient.WithResponse<E, R>
-  ) => Client.HttpClient.WithResponse<E | Error.ResponseError, R>,
+    self: Client.HttpClient<E, R>
+  ) => Client.HttpClient<E | Error.ResponseError, R>,
   <E, R>(
-    self: Client.HttpClient.WithResponse<E, R>,
+    self: Client.HttpClient<E, R>,
     f: (status: number) => boolean
-  ) => Client.HttpClient.WithResponse<E | Error.ResponseError, R>
+  ) => Client.HttpClient<E | Error.ResponseError, R>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(internalResponse.filterStatus(f))))
 
 /** @internal */
 export const filterStatusOk = <E, R>(
-  self: Client.HttpClient.WithResponse<E, R>
-): Client.HttpClient.WithResponse<E | Error.ResponseError, R> =>
+  self: Client.HttpClient<E, R>
+): Client.HttpClient<E | Error.ResponseError, R> =>
   transformResponse(self, Effect.flatMap(internalResponse.filterStatusOk))
 
 /** @internal */
 export const transformResponse = dual<
-  <A, E, R, A1, E1, R1>(
-    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ) => (self: Client.HttpClient<A, E, R>) => Client.HttpClient<A1, E1, R1>,
-  <A, E, R, A1, E1, R1>(
-    self: Client.HttpClient<A, E, R>,
-    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ) => Client.HttpClient<A1, E1, R1>
+  <E, R, E1, R1>(
+    f: (
+      effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ) => (self: Client.HttpClient<E, R>) => Client.HttpClient<E1, R1>,
+  <E, R, E1, R1>(
+    self: Client.HttpClient<E, R>,
+    f: (
+      effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ) => Client.HttpClient<E1, R1>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make((request) => f(client.postprocess(request)), client.preprocess)
+  const client = self as HttpClientImpl<any, any>
+  return makeWith((request) => f(client.postprocess(request)), client.preprocess)
 })
 
 /** @internal */
 export const catchTag: {
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, E1, R1>(
     tag: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): <A, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R>
   <
     R,
     E,
-    A,
     K extends E extends { _tag: string } ? E["_tag"] : never,
-    A1,
     R1,
     E1
   >(
-    self: Client.HttpClient<A, E, R>,
+    self: Client.HttpClient<E, R>,
     tag: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client.HttpClient<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ): Client.HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R>
 } = dual(
   3,
   <
     R,
     E,
-    A,
     K extends E extends { _tag: string } ? E["_tag"] : never,
     R1,
-    E1,
-    A1
+    E1
   >(
-    self: Client.HttpClient<A, E, R>,
+    self: Client.HttpClient<E, R>,
     tag: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client.HttpClient<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
+  ): Client.HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
 )
 
 /** @internal */
@@ -304,7 +317,7 @@ export const catchTags: {
       & {
         [K in Extract<E, { _tag: string }>["_tag"]]+?: (
           error: Extract<E, { _tag: K }>
-        ) => Effect.Effect<any, any, any>
+        ) => Effect.Effect<ClientResponse.HttpClientResponse, any, any>
       }
       & (unknown extends E ? {}
         : {
@@ -317,16 +330,7 @@ export const catchTags: {
         })
   >(
     cases: Cases
-  ): <A, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<
-    | A
-    | {
-      [K in keyof Cases]: Cases[K] extends (
-        ...args: Array<any>
-      ) => Effect.Effect<infer A, any, any> ? A
-        : never
-    }[keyof Cases],
+  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -343,14 +347,13 @@ export const catchTags: {
     }[keyof Cases]
   >
   <
-    A,
     E extends { _tag: string },
     R,
     Cases extends
       & {
         [K in Extract<E, { _tag: string }>["_tag"]]+?: (
           error: Extract<E, { _tag: K }>
-        ) => Effect.Effect<any, any, any>
+        ) => Effect.Effect<ClientResponse.HttpClientResponse, any, any>
       }
       & (unknown extends E ? {}
         : {
@@ -362,16 +365,9 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.HttpClient<A, E, R>,
+    self: Client.HttpClient<E, R>,
     cases: Cases
   ): Client.HttpClient<
-    | A
-    | {
-      [K in keyof Cases]: Cases[K] extends (
-        ...args: Array<any>
-      ) => Effect.Effect<infer A, any, any> ? A
-        : never
-    }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -390,14 +386,13 @@ export const catchTags: {
 } = dual(
   2,
   <
-    A,
     E extends { _tag: string },
     R,
     Cases extends
       & {
         [K in Extract<E, { _tag: string }>["_tag"]]+?: (
           error: Extract<E, { _tag: K }>
-        ) => Effect.Effect<any, any, any>
+        ) => Effect.Effect<ClientResponse.HttpClientResponse, any, any>
       }
       & (unknown extends E ? {}
         : {
@@ -409,16 +404,9 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.HttpClient<A, E, R>,
+    self: Client.HttpClient<E, R>,
     cases: Cases
   ): Client.HttpClient<
-    | A
-    | {
-      [K in keyof Cases]: Cases[K] extends (
-        ...args: Array<any>
-      ) => Effect.Effect<infer A, any, any> ? A
-        : never
-    }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -433,122 +421,66 @@ export const catchTags: {
       ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases]
-  > => transformResponse(self, Effect.catchTags(cases))
+  > => transformResponse(self, Effect.catchTags(cases) as any)
 )
 
 /** @internal */
 export const catchAll: {
-  <E, A2, E2, R2>(
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): <A, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A2 | A, E2, R | R2>
-  <A, E, R, A2, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Client.HttpClient<A2 | A, E2, R | R2>
+  <E, E2, R2>(
+    f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
+  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E2, R | R2>
+  <E, R, E2, R2>(
+    self: Client.HttpClient<E, R>,
+    f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
+  ): Client.HttpClient<E2, R | R2>
 } = dual(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Client.HttpClient<A2 | A, E2, R | R2> => transformResponse(self, Effect.catchAll(f))
+  <E, R, E2, R2>(
+    self: Client.HttpClient<E, R>,
+    f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
+  ): Client.HttpClient<E2, R | R2> => transformResponse(self, Effect.catchAll(f))
 )
 
 /** @internal */
 export const filterOrElse: {
-  <A, B extends A, C, E2, R2>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
-  ): <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B | C, E | E2, R | R2>
-  <A, B, E2, R2>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orElse: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  <E2, R2>(
+    predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
+    orElse: (response: ClientResponse.HttpClientResponse) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
   ): <E, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<A | B, E2 | E, R2 | R>
-  <A, E, R, B extends A, C, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    refinement: Predicate.Refinement<A, B>,
-    orElse: (a: A) => Effect.Effect<C, E2, R2>
-  ): Client.HttpClient<B | C, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    predicate: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ): Client.HttpClient<A | B, E2 | E, R2 | R>
+    self: Client.HttpClient<E, R>
+  ) => Client.HttpClient<E2 | E, R2 | R>
+  <E, R, E2, R2>(
+    self: Client.HttpClient<E, R>,
+    predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
+    orElse: (response: ClientResponse.HttpClientResponse) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
+  ): Client.HttpClient<E2 | E, R2 | R>
 } = dual(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
 
 /** @internal */
 export const filterOrFail: {
-  <A, B extends A, E2>(
-    refinement: Predicate.Refinement<NoInfer<A>, B>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E | E2, R>
-  <A, E2>(
-    predicate: Predicate.Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E2 | E, R>
-  <A, B extends A, E, R, E2>(
-    self: Client.HttpClient<A, E, R>,
-    refinement: Predicate.Refinement<A, B>,
-    orFailWith: (a: A) => E2
-  ): Client.HttpClient<B, E2 | E, R>
-  <A, E, R, E2>(
-    self: Client.HttpClient<A, E, R>,
-    predicate: Predicate.Predicate<A>,
-    orFailWith: (a: A) => E2
-  ): Client.HttpClient<A, E2 | E, R>
+  <E2>(
+    predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
+    orFailWith: (response: ClientResponse.HttpClientResponse) => E2
+  ): <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E2 | E, R>
+  <E, R, E2>(
+    self: Client.HttpClient<E, R>,
+    predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
+    orFailWith: (response: ClientResponse.HttpClientResponse) => E2
+  ): Client.HttpClient<E2 | E, R>
 } = dual(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)))
 
-/** @internal */
-export const map = dual<
-  <A, B>(
-    f: (a: A) => B
-  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E, R>,
-  <A, E, R, B>(
-    self: Client.HttpClient<A, E, R>,
-    f: (a: A) => B
-  ) => Client.HttpClient<B, E, R>
->(2, (self, f) => transformResponse(self, Effect.map(f)))
-
-/** @internal */
-export const mapEffect = dual<
-  <A, B, E2, R2>(
-    f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E | E2, R | R2>,
-  <A, E, R, B, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.HttpClient<B, E | E2, R | R2>
->(2, (self, f) => transformResponse(self, Effect.flatMap(f)))
-
-/** @internal */
-export const scoped = <A, E, R>(
-  self: Client.HttpClient<A, E, R>
-): Client.HttpClient<A, E, Exclude<R, Scope.Scope>> => transformResponse(self, Effect.scoped)
-
-/** @internal */
-export const mapEffectScoped = dual<
-  <A, B, E2, R2>(
-    f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E | E2, Exclude<R | R2, Scope.Scope>>,
-  <A, E, R, B, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.HttpClient<B, E | E2, Exclude<R | R2, Scope.Scope>>
->(2, (self, f) => scoped(mapEffect(self, f)))
-
 /** @internal */
 export const mapRequest = dual<
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => <A, E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R>,
-  <A, E, R>(
-    self: Client.HttpClient<A, E, R>,
+  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
+  <E, R>(
+    self: Client.HttpClient<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<E, R>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make(client.postprocess, (request) => Effect.map(client.preprocess(request), f))
+  const client = self as HttpClientImpl<any, any>
+  return makeWith(client.postprocess, (request) => Effect.map(client.preprocess(request), f))
 })
 
 /** @internal */
@@ -557,32 +489,32 @@ export const mapRequestEffect = dual<
     f: (
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => <A, E, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<A, E | E2, R | R2>,
-  <A, E, R, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
+  ) => <E, R>(
+    self: Client.HttpClient<E, R>
+  ) => Client.HttpClient<E | E2, R | R2>,
+  <E, R, E2, R2>(
+    self: Client.HttpClient<E, R>,
     f: (
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => Client.HttpClient<A, E | E2, R | R2>
+  ) => Client.HttpClient<E | E2, R | R2>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make(client.postprocess as any, (request) => Effect.flatMap(client.preprocess(request), f))
+  const client = self as HttpClientImpl<any, any>
+  return makeWith(client.postprocess as any, (request) => Effect.flatMap(client.preprocess(request), f))
 })
 
 /** @internal */
 export const mapRequestInput = dual<
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => <A, E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R>,
-  <A, E, R>(
-    self: Client.HttpClient<A, E, R>,
+  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
+  <E, R>(
+    self: Client.HttpClient<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<E, R>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make(client.postprocess, (request) => client.preprocess(f(request)))
+  const client = self as HttpClientImpl<any, any>
+  return makeWith(client.postprocess, (request) => client.preprocess(f(request)))
 })
 
 /** @internal */
@@ -591,44 +523,42 @@ export const mapRequestInputEffect = dual<
     f: (
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => <A, E, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<A, E | E2, R | R2>,
-  <A, E, R, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
+  ) => <E, R>(
+    self: Client.HttpClient<E, R>
+  ) => Client.HttpClient<E | E2, R | R2>,
+  <E, R, E2, R2>(
+    self: Client.HttpClient<E, R>,
     f: (
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => Client.HttpClient<A, E | E2, R | R2>
+  ) => Client.HttpClient<E | E2, R | R2>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make(client.postprocess as any, (request) => Effect.flatMap(f(request), client.preprocess))
+  const client = self as HttpClientImpl<any, any>
+  return makeWith(client.postprocess as any, (request) => Effect.flatMap(f(request), client.preprocess))
 })
 
 /** @internal */
 export const retry: {
   <E, O extends Effect.Retry.Options<E>>(
     options: O
-  ): <A, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.Retry.Return<R, E, A, O>
+  ): <R>(self: Client.HttpClient<E, R>) => Client.Retry.Return<R, E, O>
   <B, E, R1>(
     policy: Schedule.Schedule<B, NoInfer<E>, R1>
-  ): <A, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R1 | R>
-  <A, E, R, O extends Effect.Retry.Options<E>>(
-    self: Client.HttpClient<A, E, R>,
+  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R1 | R>
+  <E, R, O extends Effect.Retry.Options<E>>(
+    self: Client.HttpClient<E, R>,
     options: O
-  ): Client.Retry.Return<R, E, A, O>
-  <A, E, R, B, R1>(
-    self: Client.HttpClient<A, E, R>,
+  ): Client.Retry.Return<R, E, O>
+  <E, R, B, R1>(
+    self: Client.HttpClient<E, R>,
     policy: Schedule.Schedule<B, E, R1>
-  ): Client.HttpClient<A, E, R1 | R>
+  ): Client.HttpClient<E, R1 | R>
 } = dual(
   2,
-  <A, E extends E0, E0, R, R1, B>(
-    self: Client.HttpClient<A, E, R>,
+  <E extends E0, E0, R, R1, B>(
+    self: Client.HttpClient<E, R>,
     policy: Schedule.Schedule<B, E0, R1>
-  ): Client.HttpClient<A, E, R | R1> => transformResponse(self, Effect.retry(policy))
+  ): Client.HttpClient<E, R | R1> => transformResponse(self, Effect.retry(policy))
 )
 
 /** @internal */
@@ -638,23 +568,23 @@ export const retryTransient: {
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): <A, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R1 | R>
-  <A, E, R, B, R1 = never>(
-    self: Client.HttpClient<A, E, R>,
+  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R1 | R>
+  <E, R, B, R1 = never>(
+    self: Client.HttpClient<E, R>,
     options: {
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): Client.HttpClient<A, E, R1 | R>
+  ): Client.HttpClient<E, R1 | R>
 } = dual(
   2,
-  <A, E extends E0, E0, R, B, R1 = never>(
-    self: Client.HttpClient<A, E, R>,
+  <E extends E0, E0, R, B, R1 = never>(
+    self: Client.HttpClient<E, R>,
     options: {
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): Client.HttpClient<A, E, R | R1> =>
+  ): Client.HttpClient<E, R | R1> =>
     transformResponse(
       self,
       Effect.retry({
@@ -668,94 +598,50 @@ export const retryTransient: {
     )
 )
 
-/** @internal */
-export const schemaFunction = dual<
-  <SA, SI, SR>(
-    schema: Schema.Schema<SA, SI, SR>,
-    options?: ParseOptions | undefined
-  ) => <A, E, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => (
-    request: ClientRequest.HttpClientRequest
-  ) => (
-    a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
-  <A, E, R, SA, SI, SR>(
-    self: Client.HttpClient<A, E, R>,
-    schema: Schema.Schema<SA, SI, SR>,
-    options?: ParseOptions | undefined
-  ) => (
-    request: ClientRequest.HttpClientRequest
-  ) => (
-    a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
->((args) => isClient(args[0]), (self, schema, options) => {
-  const encode = Schema.encode(schema, options)
-  return (request) => (a) =>
-    Effect.flatMap(
-      Effect.tryMap(encode(a), {
-        try: (body) => new TextEncoder().encode(JSON.stringify(body)),
-        catch: (cause) =>
-          new Error.RequestError({
-            request,
-            reason: "Encode",
-            cause
-          })
-      }),
-      (body) =>
-        self.execute(
-          internalRequest.setBody(
-            request,
-            internalBody.uint8Array(body, "application/json")
-          )
-        )
-    )
-})
-
 /** @internal */
 export const tap = dual<
-  <A, _, E2, R2>(
-    f: (a: A) => Effect.Effect<_, E2, R2>
-  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E | E2, R | R2>,
-  <A, E, R, _, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
-    f: (a: A) => Effect.Effect<_, E2, R2>
-  ) => Client.HttpClient<A, E | E2, R | R2>
+  <_, E2, R2>(
+    f: (response: ClientResponse.HttpClientResponse) => Effect.Effect<_, E2, R2>
+  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E | E2, R | R2>,
+  <E, R, _, E2, R2>(
+    self: Client.HttpClient<E, R>,
+    f: (response: ClientResponse.HttpClientResponse) => Effect.Effect<_, E2, R2>
+  ) => Client.HttpClient<E | E2, R | R2>
 >(2, (self, f) => transformResponse(self, Effect.tap(f)))
 
 /** @internal */
 export const tapRequest = dual<
   <_, E2, R2>(
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
-  ) => <A, E, R>(
-    self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<A, E | E2, R | R2>,
-  <A, E, R, _, E2, R2>(
-    self: Client.HttpClient<A, E, R>,
+  ) => <E, R>(
+    self: Client.HttpClient<E, R>
+  ) => Client.HttpClient<E | E2, R | R2>,
+  <E, R, _, E2, R2>(
+    self: Client.HttpClient<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
-  ) => Client.HttpClient<A, E | E2, R | R2>
+  ) => Client.HttpClient<E | E2, R | R2>
 >(2, (self, f) => {
-  const client = self as HttpClientImpl<any, any, any>
-  return make(client.postprocess as any, (request) => Effect.tap(client.preprocess(request), f))
+  const client = self as HttpClientImpl<any, any>
+  return makeWith(client.postprocess as any, (request) => Effect.tap(client.preprocess(request), f))
 })
 
 /** @internal */
 export const withCookiesRef = dual<
   (
     ref: Ref.Ref<Cookies.Cookies>
-  ) => <E, R>(self: Client.HttpClient.WithResponse<E, R>) => Client.HttpClient.WithResponse<E, R>,
+  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
   <E, R>(
-    self: Client.HttpClient.WithResponse<E, R>,
+    self: Client.HttpClient<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ) => Client.HttpClient.WithResponse<E, R>
+  ) => Client.HttpClient<E, R>
 >(
   2,
   <E, R>(
-    self: Client.HttpClient.WithResponse<E, R>,
+    self: Client.HttpClient<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ): Client.HttpClient.WithResponse<E, R> => {
-    const client = self as HttpClientImpl<ClientResponse.HttpClientResponse, E, R>
-    return make(
+  ): Client.HttpClient<E, R> => {
+    const client = self as HttpClientImpl<E, R>
+    return makeWith(
       (request: Effect.Effect<ClientRequest.HttpClientRequest, E, R>) =>
         Effect.tap(
           client.postprocess(request),
@@ -778,17 +664,17 @@ export const withCookiesRef = dual<
 export const followRedirects = dual<
   (
     maxRedirects?: number | undefined
-  ) => <E, R>(self: Client.HttpClient.WithResponse<E, R>) => Client.HttpClient.WithResponse<E, R>,
+  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
   <E, R>(
-    self: Client.HttpClient.WithResponse<E, R>,
+    self: Client.HttpClient<E, R>,
     maxRedirects?: number | undefined
-  ) => Client.HttpClient.WithResponse<E, R>
+  ) => Client.HttpClient<E, R>
 >((args) => isClient(args[0]), <E, R>(
-  self: Client.HttpClient.WithResponse<E, R>,
+  self: Client.HttpClient<E, R>,
   maxRedirects?: number | undefined
-): Client.HttpClient.WithResponse<E, R> => {
-  const client = self as HttpClientImpl<ClientResponse.HttpClientResponse, E, R>
-  return make(
+): Client.HttpClient<E, R> => {
+  const client = self as HttpClientImpl<E, R>
+  return makeWith(
     (request) => {
       const loop = (
         request: ClientRequest.HttpClientRequest,
@@ -815,7 +701,9 @@ export const followRedirects = dual<
 })
 
 /** @internal */
-export const layerMergedContext = <E, R>(effect: Effect.Effect<Client.HttpClient.Service, E, R>) =>
+export const layerMergedContext = <E, R>(
+  effect: Effect.Effect<Client.HttpClient, E, R>
+): Layer.Layer<Client.HttpClient, E, R> =>
   Layer.effect(
     tag,
     Effect.flatMap(Effect.context<never>(), (context) =>