@effect/platform 0.57.7 → 0.58.0

package/src/internal/{http/clientRequest.ts → httpClientRequest.ts}

@@ -7,32 +7,32 @@ import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import type * as Stream from "effect/Stream"
-import type * as PlatformError from "../../Error.js"
-import type * as FileSystem from "../../FileSystem.js"
-import type * as Body from "../../Http/Body.js"
-import type { Client } from "../../Http/Client.js"
-import type * as ClientRequest from "../../Http/ClientRequest.js"
-import * as Headers from "../../Http/Headers.js"
-import type { Method } from "../../Http/Method.js"
-import * as UrlParams from "../../Http/UrlParams.js"
-import * as internalBody from "./body.js"
+import type * as PlatformError from "../Error.js"
+import type * as FileSystem from "../FileSystem.js"
+import * as Headers from "../Headers.js"
+import type * as Body from "../HttpBody.js"
+import type { HttpClient } from "../HttpClient.js"
+import type * as ClientRequest from "../HttpClientRequest.js"
+import type { HttpMethod } from "../HttpMethod.js"
+import * as UrlParams from "../UrlParams.js"
+import * as internalBody from "./httpBody.js"
 
 /** @internal */
-export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/Http/ClientRequest") as ClientRequest.TypeId
+export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/HttpClientRequest") as ClientRequest.TypeId
 
 /** @internal */
-export const clientTag = Context.GenericTag<Client.Default>("@effect/platform/Http/Client")
+export const clientTag = Context.GenericTag<HttpClient.Default>("@effect/platform/HttpClient")
 
 const Proto = {
   [TypeId]: TypeId,
   ...Effectable.CommitPrototype,
   ...Inspectable.BaseProto,
-  commit(this: ClientRequest.ClientRequest) {
+  commit(this: ClientRequest.HttpClientRequest) {
     return Effect.flatMap(clientTag, (client) => client(this))
   },
-  toJSON(this: ClientRequest.ClientRequest): unknown {
+  toJSON(this: ClientRequest.HttpClientRequest): unknown {
     return {
-      _id: "@effect/platform/Http/ClientRequest",
+      _id: "@effect/platform/HttpClientRequest",
       method: this.method,
       url: this.url,
       urlParams: this.urlParams,
@@ -44,13 +44,13 @@ const Proto = {
 }
 
 function makeInternal(
-  method: Method,
+  method: HttpMethod,
   url: string,
   urlParams: UrlParams.UrlParams,
   hash: Option.Option<string>,
   headers: Headers.Headers,
-  body: Body.Body
-): ClientRequest.ClientRequest {
+  body: Body.HttpBody
+): ClientRequest.HttpClientRequest {
   const self = Object.create(Proto)
   self.method = method
   self.url = url
@@ -62,11 +62,11 @@ function makeInternal(
 }
 
 /** @internal */
-export const isClientRequest = (u: unknown): u is ClientRequest.ClientRequest =>
+export const isClientRequest = (u: unknown): u is ClientRequest.HttpClientRequest =>
   typeof u === "object" && u !== null && TypeId in u
 
 /** @internal */
-export const empty: ClientRequest.ClientRequest = makeInternal(
+export const empty: ClientRequest.HttpClientRequest = makeInternal(
   "GET",
   "",
   UrlParams.empty,
@@ -76,7 +76,7 @@ export const empty: ClientRequest.ClientRequest = makeInternal(
 )
 
 /** @internal */
-export const make = <M extends Method>(method: M) =>
+export const make = <M extends HttpMethod>(method: M) =>
 (
   url: string | URL,
   options?: M extends "GET" | "HEAD" ? ClientRequest.Options.NoBody : ClientRequest.Options.NoUrl
@@ -110,8 +110,8 @@ export const options = make("OPTIONS")
 
 /** @internal */
 export const modify = dual<
-  (options: ClientRequest.Options) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, options: ClientRequest.Options) => ClientRequest.ClientRequest
+  (options: ClientRequest.Options) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, options: ClientRequest.Options) => ClientRequest.HttpClientRequest
 >(2, (self, options) => {
   let result = self
 
@@ -145,8 +145,8 @@ export const modify = dual<
 
 /** @internal */
 export const setHeader = dual<
-  (key: string, value: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, key: string, value: string) => ClientRequest.ClientRequest
+  (key: string, value: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, key: string, value: string) => ClientRequest.HttpClientRequest
 >(3, (self, key, value) =>
   makeInternal(
     self.method,
@@ -159,8 +159,8 @@ export const setHeader = dual<
 
 /** @internal */
 export const setHeaders = dual<
-  (input: Headers.Input) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, input: Headers.Input) => ClientRequest.ClientRequest
+  (input: Headers.Input) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, input: Headers.Input) => ClientRequest.HttpClientRequest
 >(2, (self, input) =>
   makeInternal(
     self.method,
@@ -173,20 +173,20 @@ export const setHeaders = dual<
 
 /** @internal */
 export const basicAuth = dual<
-  (username: string, password: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, username: string, password: string) => ClientRequest.ClientRequest
+  (username: string, password: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, username: string, password: string) => ClientRequest.HttpClientRequest
 >(3, (self, username, password) => setHeader(self, "Authorization", `Basic ${btoa(`${username}:${password}`)}`))
 
 /** @internal */
 export const bearerToken = dual<
-  (token: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, token: string) => ClientRequest.ClientRequest
+  (token: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, token: string) => ClientRequest.HttpClientRequest
 >(2, (self, token) => setHeader(self, "Authorization", `Bearer ${token}`))
 
 /** @internal */
 export const accept = dual<
-  (mediaType: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, mediaType: string) => ClientRequest.ClientRequest
+  (mediaType: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, mediaType: string) => ClientRequest.HttpClientRequest
 >(2, (self, mediaType) => setHeader(self, "Accept", mediaType))
 
 /** @internal */
@@ -194,8 +194,8 @@ export const acceptJson = accept("application/json")
 
 /** @internal */
 export const setMethod = dual<
-  (method: Method) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, method: Method) => ClientRequest.ClientRequest
+  (method: HttpMethod) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, method: HttpMethod) => ClientRequest.HttpClientRequest
 >(2, (self, method) =>
   makeInternal(
     method,
@@ -208,8 +208,8 @@ export const setMethod = dual<
 
 /** @internal */
 export const setUrl = dual<
-  (url: string | URL) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, url: string | URL) => ClientRequest.ClientRequest
+  (url: string | URL) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, url: string | URL) => ClientRequest.HttpClientRequest
 >(2, (self, url) => {
   if (typeof url === "string") {
     return makeInternal(
@@ -238,8 +238,8 @@ export const setUrl = dual<
 
 /** @internal */
 export const appendUrl = dual<
-  (path: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, path: string) => ClientRequest.ClientRequest
+  (path: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, path: string) => ClientRequest.HttpClientRequest
 >(2, (self, url) =>
   makeInternal(
     self.method,
@@ -254,8 +254,8 @@ export const appendUrl = dual<
 
 /** @internal */
 export const prependUrl = dual<
-  (path: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, path: string) => ClientRequest.ClientRequest
+  (path: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, path: string) => ClientRequest.HttpClientRequest
 >(2, (self, url) =>
   makeInternal(
     self.method,
@@ -270,8 +270,8 @@ export const prependUrl = dual<
 
 /** @internal */
 export const updateUrl = dual<
-  (f: (url: string) => string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, f: (url: string) => string) => ClientRequest.ClientRequest
+  (f: (url: string) => string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, f: (url: string) => string) => ClientRequest.HttpClientRequest
 >(2, (self, f) =>
   makeInternal(
     self.method,
@@ -284,8 +284,8 @@ export const updateUrl = dual<
 
 /** @internal */
 export const appendUrlParam = dual<
-  (key: string, value: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, key: string, value: string) => ClientRequest.ClientRequest
+  (key: string, value: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, key: string, value: string) => ClientRequest.HttpClientRequest
 >(3, (self, key, value) =>
   makeInternal(
     self.method,
@@ -298,8 +298,8 @@ export const appendUrlParam = dual<
 
 /** @internal */
 export const appendUrlParams = dual<
-  (input: UrlParams.Input) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, input: UrlParams.Input) => ClientRequest.ClientRequest
+  (input: UrlParams.Input) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, input: UrlParams.Input) => ClientRequest.HttpClientRequest
 >(2, (self, input) =>
   makeInternal(
     self.method,
@@ -312,8 +312,8 @@ export const appendUrlParams = dual<
 
 /** @internal */
 export const setUrlParam = dual<
-  (key: string, value: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, key: string, value: string) => ClientRequest.ClientRequest
+  (key: string, value: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, key: string, value: string) => ClientRequest.HttpClientRequest
 >(3, (self, key, value) =>
   makeInternal(
     self.method,
@@ -326,8 +326,8 @@ export const setUrlParam = dual<
 
 /** @internal */
 export const setUrlParams = dual<
-  (input: UrlParams.Input) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, input: UrlParams.Input) => ClientRequest.ClientRequest
+  (input: UrlParams.Input) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, input: UrlParams.Input) => ClientRequest.HttpClientRequest
 >(2, (self, input) =>
   makeInternal(
     self.method,
@@ -340,8 +340,8 @@ export const setUrlParams = dual<
 
 /** @internal */
 export const setHash = dual<
-  (hash: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, hash: string) => ClientRequest.ClientRequest
+  (hash: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, hash: string) => ClientRequest.HttpClientRequest
 >(2, (self, hash) =>
   makeInternal(
     self.method,
@@ -353,7 +353,7 @@ export const setHash = dual<
   ))
 
 /** @internal */
-export const removeHash = (self: ClientRequest.ClientRequest): ClientRequest.ClientRequest =>
+export const removeHash = (self: ClientRequest.HttpClientRequest): ClientRequest.HttpClientRequest =>
   makeInternal(
     self.method,
     self.url,
@@ -365,8 +365,8 @@ export const removeHash = (self: ClientRequest.ClientRequest): ClientRequest.Cli
 
 /** @internal */
 export const setBody = dual<
-  (body: Body.Body) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, body: Body.Body) => ClientRequest.ClientRequest
+  (body: Body.HttpBody) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, body: Body.HttpBody) => ClientRequest.HttpClientRequest
 >(2, (self, body) => {
   let headers = self.headers
   if (body._tag === "Empty") {
@@ -394,8 +394,11 @@ export const setBody = dual<
 
 /** @internal */
 export const uint8ArrayBody = dual<
-  (body: Uint8Array, contentType?: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, body: Uint8Array, contentType?: string) => ClientRequest.ClientRequest
+  (
+    body: Uint8Array,
+    contentType?: string
+  ) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, body: Uint8Array, contentType?: string) => ClientRequest.HttpClientRequest
 >(
   (args) => isClientRequest(args[0]),
   (self, body, contentType = "application/octet-stream") => setBody(self, internalBody.uint8Array(body, contentType))
@@ -403,8 +406,8 @@ export const uint8ArrayBody = dual<
 
 /** @internal */
 export const textBody = dual<
-  (body: string, contentType?: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, body: string, contentType?: string) => ClientRequest.ClientRequest
+  (body: string, contentType?: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, body: string, contentType?: string) => ClientRequest.HttpClientRequest
 >(
   (args) => isClientRequest(args[0]),
   (self, body, contentType = "text/plain") => setBody(self, internalBody.text(body, contentType))
@@ -414,17 +417,17 @@ export const textBody = dual<
 export const jsonBody = dual<
   (
     body: unknown
-  ) => (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError>,
+  ) => (self: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError>,
   (
-    self: ClientRequest.ClientRequest,
+    self: ClientRequest.HttpClientRequest,
     body: unknown
-  ) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError>
+  ) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError>
 >(2, (self, body) => Effect.map(internalBody.json(body), (body) => setBody(self, body)))
 
 /** @internal */
 export const unsafeJsonBody = dual<
-  (body: unknown) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, body: unknown) => ClientRequest.ClientRequest
+  (body: unknown) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, body: unknown) => ClientRequest.HttpClientRequest
 >(2, (self, body) => setBody(self, internalBody.unsafeJson(body)))
 
 /** @internal */
@@ -433,13 +436,13 @@ export const fileBody = dual<
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
   ) => (
-    self: ClientRequest.ClientRequest
-  ) => Effect.Effect<ClientRequest.ClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>,
+    self: ClientRequest.HttpClientRequest
+  ) => Effect.Effect<ClientRequest.HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>,
   (
-    self: ClientRequest.ClientRequest,
+    self: ClientRequest.HttpClientRequest,
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
-  ) => Effect.Effect<ClientRequest.ClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
+  ) => Effect.Effect<ClientRequest.HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
 >(
   (args) => isClientRequest(args[0]),
   (self, path, options) => Effect.map(internalBody.file(path, options), (body) => setBody(self, body))
@@ -447,28 +450,38 @@ export const fileBody = dual<
 
 /** @internal */
 export const fileWebBody = dual<
-  (file: Body.Body.FileLike) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, file: Body.Body.FileLike) => ClientRequest.ClientRequest
+  (file: Body.HttpBody.FileLike) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, file: Body.HttpBody.FileLike) => ClientRequest.HttpClientRequest
 >(2, (self, file) => setBody(self, internalBody.fileWeb(file)))
 
 /** @internal */
 export const schemaBody = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined): {
-  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
-  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
+  (
+    body: A
+  ): (self: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError, R>
+  (
+    self: ClientRequest.HttpClientRequest,
+    body: A
+  ): Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError, R>
 } => {
   const encode = internalBody.jsonSchema(schema, options)
   return dual<
     (
       body: A
-    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>,
-    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
+    ) => (
+      self: ClientRequest.HttpClientRequest
+    ) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError, R>,
+    (
+      self: ClientRequest.HttpClientRequest,
+      body: A
+    ) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError, R>
   >(2, (self, body) => Effect.map(encode(body), (body) => setBody(self, body)))
 }
 
 /** @internal */
 export const urlParamsBody = dual<
-  (input: UrlParams.Input) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, input: UrlParams.Input) => ClientRequest.ClientRequest
+  (input: UrlParams.Input) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, input: UrlParams.Input) => ClientRequest.HttpClientRequest
 >(2, (self, body) =>
   setBody(
     self,
@@ -480,8 +493,8 @@ export const urlParamsBody = dual<
 
 /** @internal */
 export const formDataBody = dual<
-  (body: FormData) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, body: FormData) => ClientRequest.ClientRequest
+  (body: FormData) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, body: FormData) => ClientRequest.HttpClientRequest
 >(2, (self, body) => setBody(self, internalBody.formData(body)))
 
 /** @internal */
@@ -492,15 +505,15 @@ export const streamBody = dual<
       readonly contentType?: string | undefined
       readonly contentLength?: number | undefined
     }
-  ) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  ) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
   (
-    self: ClientRequest.ClientRequest,
+    self: ClientRequest.HttpClientRequest,
     body: Stream.Stream<Uint8Array, unknown>,
     options?: {
       readonly contentType?: string | undefined
       readonly contentLength?: number | undefined
     }
-  ) => ClientRequest.ClientRequest
+  ) => ClientRequest.HttpClientRequest
 >(
   (args) => isClientRequest(args[0]),
   (self, body, { contentLength, contentType = "application/octet-stream" } = {}) =>

package/src/internal/{http/clientResponse.ts → httpClientResponse.ts}

@@ -5,29 +5,29 @@ import * as Effect from "effect/Effect"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
-import * as Error from "../../Http/ClientError.js"
-import type * as ClientRequest from "../../Http/ClientRequest.js"
-import type * as ClientResponse from "../../Http/ClientResponse.js"
-import * as Cookies from "../../Http/Cookies.js"
-import * as Headers from "../../Http/Headers.js"
-import * as IncomingMessage from "../../Http/IncomingMessage.js"
-import * as UrlParams from "../../Http/UrlParams.js"
+import * as Cookies from "../Cookies.js"
+import * as Headers from "../Headers.js"
+import * as Error from "../HttpClientError.js"
+import type * as ClientRequest from "../HttpClientRequest.js"
+import type * as ClientResponse from "../HttpClientResponse.js"
+import * as IncomingMessage from "../HttpIncomingMessage.js"
+import * as UrlParams from "../UrlParams.js"
 
 /** @internal */
-export const TypeId: ClientResponse.TypeId = Symbol.for("@effect/platform/Http/ClientResponse") as ClientResponse.TypeId
+export const TypeId: ClientResponse.TypeId = Symbol.for("@effect/platform/HttpClientResponse") as ClientResponse.TypeId
 
 /** @internal */
 export const fromWeb = (
-  request: ClientRequest.ClientRequest,
+  request: ClientRequest.HttpClientRequest,
   source: globalThis.Response
-): ClientResponse.ClientResponse => new ClientResponseImpl(request, source)
+): ClientResponse.HttpClientResponse => new ClientResponseImpl(request, source)
 
-class ClientResponseImpl extends Inspectable.Class implements ClientResponse.ClientResponse {
+class ClientResponseImpl extends Inspectable.Class implements ClientResponse.HttpClientResponse {
   readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
   readonly [TypeId]: ClientResponse.TypeId
 
   constructor(
-    private readonly request: ClientRequest.ClientRequest,
+    private readonly request: ClientRequest.HttpClientRequest,
     private readonly source: globalThis.Response
   ) {
     super()
@@ -37,7 +37,7 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Cli
 
   toJSON(): unknown {
     return IncomingMessage.inspect(this, {
-      _id: "@effect/platform/Http/ClientResponse",
+      _id: "@effect/platform/HttpClientResponse",
       request: this.request.toJSON(),
       status: this.status
     })
@@ -163,7 +163,7 @@ export const schemaJson = <
   A
 >(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
   const parse = Schema.decodeUnknown(schema, options)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<A, Error.ResponseError | ParseResult.ParseError, R> =>
+  return (self: ClientResponse.HttpClientResponse): Effect.Effect<A, Error.ResponseError | ParseResult.ParseError, R> =>
     Effect.flatMap(
       self.json,
       (body) =>
@@ -185,7 +185,7 @@ export const schemaNoBody = <
   A
 >(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
   const parse = Schema.decodeUnknown(schema, options)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<A, ParseResult.ParseError, R> =>
+  return (self: ClientResponse.HttpClientResponse): Effect.Effect<A, ParseResult.ParseError, R> =>
     parse({
       status: self.status,
       headers: self.headers
@@ -193,31 +193,31 @@ export const schemaNoBody = <
 }
 
 /** @internal */
-export const arrayBuffer = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const arrayBuffer = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Effect.scoped(Effect.flatMap(effect, (_) => _.arrayBuffer))
 
 /** @internal */
-export const text = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const text = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Effect.scoped(Effect.flatMap(effect, (_) => _.text))
 
 /** @internal */
-export const json = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const json = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Effect.scoped(Effect.flatMap(effect, (_) => _.json))
 
 /** @internal */
-export const urlParamsBody = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const urlParamsBody = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Effect.scoped(Effect.flatMap(effect, (_) => _.urlParamsBody))
 
 /** @internal */
-export const formData = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const formData = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Effect.scoped(Effect.flatMap(effect, (_) => _.formData))
 
 /** @internal */
-export const void_ = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const void_ = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Effect.scoped(Effect.asVoid(effect))
 
 /** @internal */
-export const stream = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+export const stream = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Stream.unwrapScoped(Effect.map(effect, (_) => _.stream))
 
 /** @internal */
@@ -231,7 +231,7 @@ export const schemaJsonScoped = <
   A
 >(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
   const decode = schemaJson(schema, options)
-  return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
+  return <E, R2>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R2>) =>
     Effect.scoped(Effect.flatMap(effect, decode))
 }
 
@@ -245,6 +245,6 @@ export const schemaNoBodyScoped = <
   A
 >(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
   const decode = schemaNoBody(schema, options)
-  return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
+  return <E, R2>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R2>) =>
     Effect.scoped(Effect.flatMap(effect, decode))
 }

package/src/internal/{http/middleware.ts → httpMiddleware.ts}

@@ -6,20 +6,20 @@ import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Predicate from "effect/Predicate"
-import type * as App from "../../Http/App.js"
-import * as Headers from "../../Http/Headers.js"
-import type * as Middleware from "../../Http/Middleware.js"
-import * as ServerError from "../../Http/ServerError.js"
-import * as ServerRequest from "../../Http/ServerRequest.js"
-import type { ServerResponse } from "../../Http/ServerResponse.js"
-import * as TraceContext from "../../Http/TraceContext.js"
+import * as Headers from "../Headers.js"
+import type * as App from "../HttpApp.js"
+import type * as Middleware from "../HttpMiddleware.js"
+import * as ServerError from "../HttpServerError.js"
+import * as ServerRequest from "../HttpServerRequest.js"
+import type { HttpServerResponse } from "../HttpServerResponse.js"
+import * as TraceContext from "../HttpTraceContext.js"
 
 /** @internal */
-export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware
+export const make = <M extends Middleware.HttpMiddleware>(middleware: M): M => middleware
 
 /** @internal */
 export const loggerDisabled = globalValue(
-  Symbol.for("@effect/platform/Http/Middleware/loggerDisabled"),
+  Symbol.for("@effect/platform/HttpMiddleware/loggerDisabled"),
   () => FiberRef.unsafeMake(false)
 )
 
@@ -32,29 +32,29 @@ export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effec
 
 /** @internal */
 export const currentTracerDisabledWhen = globalValue(
-  Symbol.for("@effect/platform/Http/Middleware/tracerDisabledWhen"),
-  () => FiberRef.unsafeMake<Predicate.Predicate<ServerRequest.ServerRequest>>(constFalse)
+  Symbol.for("@effect/platform/HttpMiddleware/tracerDisabledWhen"),
+  () => FiberRef.unsafeMake<Predicate.Predicate<ServerRequest.HttpServerRequest>>(constFalse)
 )
 
 /** @internal */
 export const withTracerDisabledWhen = dual<
   (
-    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+    predicate: Predicate.Predicate<ServerRequest.HttpServerRequest>
   ) => <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
   <A, E, R>(
     layer: Layer.Layer<A, E, R>,
-    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+    predicate: Predicate.Predicate<ServerRequest.HttpServerRequest>
   ) => Layer.Layer<A, E, R>
 >(2, (self, pred) => Layer.locally(self, currentTracerDisabledWhen, pred))
 
 /** @internal */
 export const withTracerDisabledWhenEffect = dual<
   (
-    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+    predicate: Predicate.Predicate<ServerRequest.HttpServerRequest>
   ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <A, E, R>(
     effect: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+    predicate: Predicate.Predicate<ServerRequest.HttpServerRequest>
   ) => Effect.Effect<A, E, R>
 >(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
 
@@ -74,7 +74,7 @@ export const logger = make((httpApp) => {
   let counter = 0
   return Effect.withFiberRuntime((fiber) => {
     const context = fiber.getFiberRef(FiberRef.currentContext)
-    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    const request = Context.unsafeGet(context, ServerRequest.HttpServerRequest)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
         if (fiber.getFiberRef(loggerDisabled)) {
@@ -104,7 +104,7 @@ export const logger = make((httpApp) => {
 export const tracer = make((httpApp) =>
   Effect.withFiberRuntime((fiber) => {
     const context = fiber.getFiberRef(FiberRef.currentContext)
-    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    const request = Context.unsafeGet(context, ServerRequest.HttpServerRequest)
     const disabled = fiber.getFiberRef(currentTracerDisabledWhen)(request)
     if (disabled) {
       return httpApp
@@ -173,7 +173,7 @@ export const tracer = make((httpApp) =>
 
 /** @internal */
 export const xForwardedHeaders = make((httpApp) =>
-  Effect.updateService(httpApp, ServerRequest.ServerRequest, (request) =>
+  Effect.updateService(httpApp, ServerRequest.HttpServerRequest, (request) =>
     request.headers["x-forwarded-host"]
       ? request.modify({
         headers: Headers.set(
@@ -189,12 +189,12 @@ export const xForwardedHeaders = make((httpApp) =>
 /** @internal */
 export const searchParamsParser = <E, R>(httpApp: App.Default<E, R>) =>
   Effect.withFiberRuntime<
-    ServerResponse,
+    HttpServerResponse,
     E,
-    ServerRequest.ServerRequest | Exclude<R, ServerRequest.ParsedSearchParams>
+    ServerRequest.HttpServerRequest | Exclude<R, ServerRequest.ParsedSearchParams>
   >((fiber) => {
     const context = fiber.getFiberRef(FiberRef.currentContext)
-    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    const request = Context.unsafeGet(context, ServerRequest.HttpServerRequest)
     const params = ServerRequest.searchParamsFromURL(new URL(request.url))
     return Effect.locally(
       httpApp,