@effect/platform 0.64.1 → 0.65.0

package/src/HttpClient.ts

@@ -9,7 +9,7 @@ import type * as Effect from "effect/Effect"
 import type { RuntimeFiber } from "effect/Fiber"
 import type * as FiberRef from "effect/FiberRef"
 import type { Inspectable } from "effect/Inspectable"
-import type * as Layer from "effect/Layer"
+import type { Layer } from "effect/Layer"
 import type { Pipeable } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
 import type { Ref } from "effect/Ref"
@@ -38,10 +38,16 @@ export type TypeId = typeof TypeId
  * @category models
  */
 export interface HttpClient<A = ClientResponse.HttpClientResponse, E = never, R = never> extends Pipeable, Inspectable {
-  (request: ClientRequest.HttpClientRequest): Effect.Effect<A, E, R>
   readonly [TypeId]: TypeId
-  readonly preprocess: HttpClient.Preprocess<E, R>
-  readonly execute: HttpClient.Execute<A, E, R>
+  readonly execute: (request: ClientRequest.HttpClientRequest) => Effect.Effect<A, E, R>
+
+  readonly get: (url: string | URL, options?: ClientRequest.Options.NoBody) => Effect.Effect<A, E, R>
+  readonly head: (url: string | URL, options?: ClientRequest.Options.NoBody) => Effect.Effect<A, E, R>
+  readonly post: (url: string | URL, options?: ClientRequest.Options.NoUrl) => Effect.Effect<A, E, R>
+  readonly patch: (url: string | URL, options?: ClientRequest.Options.NoUrl) => Effect.Effect<A, E, R>
+  readonly put: (url: string | URL, options?: ClientRequest.Options.NoUrl) => Effect.Effect<A, E, R>
+  readonly del: (url: string | URL, options?: ClientRequest.Options.NoUrl) => Effect.Effect<A, E, R>
+  readonly options: (url: string | URL, options?: ClientRequest.Options.NoUrl) => Effect.Effect<A, E, R>
 }
 
 /**
@@ -60,7 +66,7 @@ export declare namespace HttpClient {
    * @since 1.0.0
    * @category models
    */
-  export type Execute<A, E = never, R = never> = (
+  export type Postprocess<A, E = never, R = never> = (
     request: Effect.Effect<ClientRequest.HttpClientRequest, E, R>
   ) => Effect.Effect<A, E, R>
 
@@ -74,46 +80,14 @@ export declare namespace HttpClient {
    * @since 1.0.0
    * @category models
    */
-  export type Default = WithResponse<Error.HttpClientError, Scope.Scope>
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface Fetch {
-  readonly _: unique symbol
+  export type Service = WithResponse<Error.HttpClientError, Scope.Scope>
 }
 
 /**
  * @since 1.0.0
  * @category tags
  */
-export const HttpClient: Context.Tag<HttpClient.Default, HttpClient.Default> = internal.tag
-
-/**
- * @since 1.0.0
- * @category tags
- */
-export const Fetch: Context.Tag<Fetch, typeof globalThis.fetch> = internal.Fetch
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layer: Layer.Layer<HttpClient.Default> = internal.layer
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const fetch: HttpClient.Default = internal.fetch
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const fetchOk: HttpClient.Default = internal.fetchOk
+export const HttpClient: Context.Tag<HttpClient.Service, HttpClient.Service> = internal.tag
 
 /**
  * @since 1.0.0
@@ -200,15 +174,26 @@ export const catchTags: {
  * @category filters
  */
 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: HttpClient<A, E, R>) => HttpClient<B | C, E | E2, R | R2>
   <A, B, E2, R2>(
-    f: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ): <E, R>(self: HttpClient<A, E, R>) => HttpClient<A | B, E2 | E, R2 | R>
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E, R>(
+    self: HttpClient<A, E, R>
+  ) => HttpClient<A | B, E2 | E, R2 | R>
+  <A, E, R, B extends A, C, E2, R2>(
+    self: HttpClient<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    orElse: (a: A) => Effect.Effect<C, E2, R2>
+  ): HttpClient<B | C, E | E2, R | R2>
   <A, E, R, B, E2, R2>(
     self: HttpClient<A, E, R>,
-    f: Predicate.Predicate<A>,
+    predicate: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ): HttpClient<A | B, E | E2, R | R2>
+  ): HttpClient<A | B, E2 | E, R2 | R>
 } = internal.filterOrElse
 
 /**
@@ -216,15 +201,24 @@ export const filterOrElse: {
  * @category filters
  */
 export const filterOrFail: {
+  <A, B extends A, E2>(
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
+    orFailWith: (a: NoInfer<A>) => E2
+  ): <E, R>(self: HttpClient<A, E, R>) => HttpClient<B, E | E2, R>
   <A, E2>(
-    f: Predicate.Predicate<A>,
-    orFailWith: (a: A) => E2
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orFailWith: (a: NoInfer<A>) => E2
   ): <E, R>(self: HttpClient<A, E, R>) => HttpClient<A, E2 | E, R>
+  <A, B extends A, E, R, E2>(
+    self: HttpClient<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    orFailWith: (a: A) => E2
+  ): HttpClient<B, E2 | E, R>
   <A, E, R, E2>(
     self: HttpClient<A, E, R>,
-    f: Predicate.Predicate<A>,
+    predicate: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ): HttpClient<A, E | E2, R>
+  ): HttpClient<A, E2 | E, R>
 } = internal.filterOrFail
 
 /**
@@ -262,14 +256,14 @@ export const make: <A, E, R, E2, R2>(
  * @since 1.0.0
  * @category constructors
  */
-export const makeDefault: (
+export const makeService: (
   f: (
     request: ClientRequest.HttpClientRequest,
     url: URL,
     signal: AbortSignal,
     fiber: RuntimeFiber<ClientResponse.HttpClientResponse, Error.HttpClientError>
   ) => Effect.Effect<ClientResponse.HttpClientResponse, Error.HttpClientError, Scope.Scope>
-) => HttpClient.Default = internal.makeDefault
+) => HttpClient.Service = internal.makeService
 
 /**
  * @since 1.0.0
@@ -319,20 +313,6 @@ export const mapEffect: {
   <A, E, R, B, E2, R2>(self: HttpClient<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): HttpClient<B, E | E2, R2 | R>
 } = internal.mapEffect
 
-/**
- * @since 1.0.0
- * @category mapping & sequencing
- */
-export const mapEffectScoped: {
-  <A, B, E2, R2>(
-    f: (a: A) => Effect.Effect<B, E2, R2>
-  ): <E, R>(self: HttpClient<A, E, R>) => HttpClient<B, E2 | E, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
-  <A, E, R, B, E2, R2>(
-    self: HttpClient<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>
-  ): HttpClient<B, E | E2, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
-} = internal.mapEffectScoped
-
 /**
  * @since 1.0.0
  * @category mapping & sequencing
@@ -365,7 +345,7 @@ export const mapRequestEffect: {
  * @since 1.0.0
  * @category mapping & sequencing
  */
-export const mapInputRequest: {
+export const mapRequestInput: {
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
   ): <A, E, R>(self: HttpClient<A, E, R>) => HttpClient<A, E, R>
@@ -373,13 +353,13 @@ export const mapInputRequest: {
     self: HttpClient<A, E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
   ): HttpClient<A, E, R>
-} = internal.mapInputRequest
+} = internal.mapRequestInput
 
 /**
  * @since 1.0.0
  * @category mapping & sequencing
  */
-export const mapInputRequestEffect: {
+export const mapRequestInputEffect: {
   <E2, R2>(
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ): <A, E, R>(self: HttpClient<A, E, R>) => HttpClient<A, E2 | E, R2 | R>
@@ -387,20 +367,42 @@ export const mapInputRequestEffect: {
     self: HttpClient<A, E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ): HttpClient<A, E | E2, R2 | R>
-} = internal.mapInputRequestEffect
+} = internal.mapRequestInputEffect
+
+/**
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare namespace Retry {
+  /**
+   * @since 1.0.0
+   * @category error handling
+   */
+  export type Return<R, E, A, O extends Effect.Retry.Options<E>> = HttpClient<
+    A,
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer _R> } ? E
+      : O extends { until: Predicate.Refinement<E, infer E2> } ? E2
+      : E)
+    | (O extends { while: (...args: Array<any>) => Effect.Effect<infer _A, infer E, infer _R> } ? E : never)
+    | (O extends { until: (...args: Array<any>) => Effect.Effect<infer _A, infer E, infer _R> } ? E : never),
+    | R
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer R> } ? R : never)
+    | (O extends { while: (...args: Array<any>) => Effect.Effect<infer _A, infer _E, infer R> } ? R : never)
+    | (O extends { until: (...args: Array<any>) => Effect.Effect<infer _A, infer _E, infer R> } ? R : never)
+  > extends infer Z ? Z : never
+}
 
 /**
  * @since 1.0.0
  * @category error handling
  */
 export const retry: {
-  <B, E extends E0, E0, R1>(
-    policy: Schedule.Schedule<B, E0, R1>
+  <E, O extends Effect.Retry.Options<E>>(options: O): <A, R>(self: HttpClient<A, E, R>) => Retry.Return<R, E, A, O>
+  <B, E, R1>(
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
   ): <A, R>(self: HttpClient<A, E, R>) => HttpClient<A, E, R1 | R>
-  <A, E extends E0, E0, R, R1, B>(
-    self: HttpClient<A, E, R>,
-    policy: Schedule.Schedule<B, E0, R1>
-  ): HttpClient<A, E, R1 | R>
+  <A, E, R, O extends Effect.Retry.Options<E>>(self: HttpClient<A, E, R>, options: O): Retry.Return<R, E, A, O>
+  <A, E, R, B, R1>(self: HttpClient<A, E, R>, policy: Schedule.Schedule<B, E, R1>): HttpClient<A, E, R1 | R>
 } = internal.retry
 
 /**
@@ -512,15 +514,7 @@ export const withTracerPropagation: {
 
 /**
  * @since 1.0.0
- * @category fiber refs
- */
-export const currentFetchOptions: FiberRef.FiberRef<RequestInit> = internal.currentFetchOptions
-
-/**
- * @since 1.0.0
- * @category fiber refs
  */
-export const withFetchOptions: {
-  (options: RequestInit): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <A, E, R>(effect: Effect.Effect<A, E, R>, options: RequestInit): Effect.Effect<A, E, R>
-} = internal.withFetchOptions
+export const layerMergedContext: <E, R>(
+  effect: Effect.Effect<HttpClient.Service, E, R>
+) => Layer<HttpClient.Service, E, R> = internal.layerMergedContext

package/src/HttpClientRequest.ts

@@ -36,7 +36,7 @@ export type TypeId = typeof TypeId
  * @category models
  */
 export interface HttpClientRequest
-  extends Effect.Effect<HttpClientResponse, HttpClientError, HttpClient.Default | Scope>, Inspectable
+  extends Effect.Effect<HttpClientResponse, HttpClientError, HttpClient.Service | Scope>, Inspectable
 {
   readonly [TypeId]: TypeId
   readonly method: HttpMethod
@@ -301,73 +301,73 @@ export const setBody: {
  * @since 1.0.0
  * @category combinators
  */
-export const uint8ArrayBody: {
+export const bodyUint8Array: {
   (body: Uint8Array, contentType?: string): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: Uint8Array, contentType?: string): HttpClientRequest
-} = internal.uint8ArrayBody
+} = internal.bodyUint8Array
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const textBody: {
+export const bodyText: {
   (body: string, contentType?: string): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: string, contentType?: string): HttpClientRequest
-} = internal.textBody
+} = internal.bodyText
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const jsonBody: {
+export const bodyJson: {
   (body: unknown): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest, Body.HttpBodyError>
   (self: HttpClientRequest, body: unknown): Effect.Effect<HttpClientRequest, Body.HttpBodyError>
-} = internal.jsonBody
+} = internal.bodyJson
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const unsafeJsonBody: {
+export const bodyUnsafeJson: {
   (body: unknown): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: unknown): HttpClientRequest
-} = internal.unsafeJsonBody
+} = internal.bodyUnsafeJson
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const schemaBody: <A, I, R>(
+export const schemaBodyJson: <A, I, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
   (body: A): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest, Body.HttpBodyError, R>
   (self: HttpClientRequest, body: A): Effect.Effect<HttpClientRequest, Body.HttpBodyError, R>
-} = internal.schemaBody
+} = internal.schemaBodyJson
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const urlParamsBody: {
+export const bodyUrlParams: {
   (input: UrlParams.Input): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, input: UrlParams.Input): HttpClientRequest
-} = internal.urlParamsBody
+} = internal.bodyUrlParams
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const formDataBody: {
+export const bodyFormData: {
   (body: FormData): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: FormData): HttpClientRequest
-} = internal.formDataBody
+} = internal.bodyFormData
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const streamBody: {
+export const bodyStream: {
   (
     body: Stream.Stream<Uint8Array, unknown>,
     options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
@@ -377,13 +377,13 @@ export const streamBody: {
     body: Stream.Stream<Uint8Array, unknown>,
     options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
   ): HttpClientRequest
-} = internal.streamBody
+} = internal.bodyStream
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const fileBody: {
+export const bodyFile: {
   (
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
@@ -393,13 +393,13 @@ export const fileBody: {
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
   ): Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
-} = internal.fileBody
+} = internal.bodyFile
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const fileWebBody: {
+export const bodyFileWeb: {
   (file: Body.HttpBody.FileLike): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, file: Body.HttpBody.FileLike): HttpClientRequest
-} = internal.fileWebBody
+} = internal.bodyFileWeb

package/src/HttpClientResponse.ts

@@ -7,12 +7,12 @@ import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
+import type { Unify } from "effect/Unify"
 import type * as Cookies from "./Cookies.js"
 import type * as Error from "./HttpClientError.js"
 import type * as ClientRequest from "./HttpClientRequest.js"
 import type * as IncomingMessage from "./HttpIncomingMessage.js"
 import * as internal from "./internal/httpClientResponse.js"
-import type * as UrlParams from "./UrlParams.js"
 
 export {
   /**
@@ -20,11 +20,6 @@ export {
    * @category schema
    */
   schemaBodyJson,
-  /**
-   * @since 1.0.0
-   * @category schema
-   */
-  schemaBodyJsonScoped,
   /**
    * @since 1.0.0
    * @category schema
@@ -34,17 +29,7 @@ export {
    * @since 1.0.0
    * @category schema
    */
-  schemaBodyUrlParamsScoped,
-  /**
-   * @since 1.0.0
-   * @category schema
-   */
-  schemaHeaders,
-  /**
-   * @since 1.0.0
-   * @category schema
-   */
-  schemaHeadersScoped
+  schemaHeaders
 } from "./HttpIncomingMessage.js"
 
 /**
@@ -111,41 +96,6 @@ export const schemaNoBody: <
   options?: ParseOptions | undefined
 ) => (self: HttpClientResponse) => Effect.Effect<A, ParseResult.ParseError, R> = internal.schemaNoBody
 
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const arrayBuffer: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<ArrayBuffer, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.arrayBuffer
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const formData: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<FormData, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.formData
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const json: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<unknown, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.json
-
-const void_: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<void, E, Exclude<R, Scope.Scope>> = internal.void_
-export {
-  /**
-   * @since 1.0.0
-   * @category accessors
-   */
-  void_ as void
-}
-
 /**
  * @since 1.0.0
  * @category accessors
@@ -154,64 +104,6 @@ export const stream: <E, R>(
   effect: Effect.Effect<HttpClientResponse, E, R>
 ) => Stream.Stream<Uint8Array, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.stream
 
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const text: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<string, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.text
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const urlParamsBody: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<UrlParams.UrlParams, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.urlParamsBody
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaJsonScoped: <
-  R,
-  I extends {
-    readonly status?: number | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-    readonly body?: unknown
-  },
-  A
->(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => <E, R2>(
-  effect: Effect.Effect<HttpClientResponse, E, R2>
-) => Effect.Effect<
-  A,
-  E | Error.ResponseError | ParseResult.ParseError,
-  Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>
-> = internal.schemaJsonScoped
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaNoBodyScoped: <
-  R,
-  I extends {
-    readonly status?: number | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-  },
-  A
->(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => <E, R2>(
-  effect: Effect.Effect<HttpClientResponse, E, R2>
-) => Effect.Effect<A, E | ParseResult.ParseError, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =
-  internal.schemaNoBodyScoped
-
 /**
  * @since 1.0.0
  * @category pattern matching
@@ -226,7 +118,7 @@ export const matchStatus: {
       readonly "5xx"?: (_: HttpClientResponse) => any
       readonly orElse: (_: HttpClientResponse) => any
     }
-  >(cases: Cases): (self: HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? R : never
+  >(cases: Cases): (self: HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? Unify<R> : never
   <
     const Cases extends {
       readonly [status: number]: (_: HttpClientResponse) => any
@@ -236,55 +128,5 @@ export const matchStatus: {
       readonly "5xx"?: (_: HttpClientResponse) => any
       readonly orElse: (_: HttpClientResponse) => any
     }
-  >(self: HttpClientResponse, cases: Cases): Cases[keyof Cases] extends (_: any) => infer R ? R : never
+  >(self: HttpClientResponse, cases: Cases): Cases[keyof Cases] extends (_: any) => infer R ? Unify<R> : never
 } = internal.matchStatus
-
-/**
- * @since 1.0.0
- * @category pattern matching
- */
-export const matchStatusScoped: {
-  <
-    const Cases extends {
-      readonly [status: number]: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "2xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "3xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "4xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "5xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly orElse: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-    }
-  >(
-    cases: Cases
-  ): <E, R>(
-    self: Effect.Effect<HttpClientResponse, E, R>
-  ) => Effect.Effect<
-    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
-    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
-    Exclude<
-      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
-      Scope.Scope
-    >
-  >
-  <
-    E,
-    R,
-    const Cases extends {
-      readonly [status: number]: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "2xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "3xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "4xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "5xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly orElse: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-    }
-  >(
-    self: Effect.Effect<HttpClientResponse, E, R>,
-    cases: Cases
-  ): Effect.Effect<
-    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
-    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
-    Exclude<
-      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
-      Scope.Scope
-    >
-  >
-} = internal.matchStatusScoped

package/src/HttpIncomingMessage.ts

@@ -10,7 +10,6 @@ import { dual } from "effect/Function"
 import * as Global from "effect/GlobalValue"
 import type { Inspectable } from "effect/Inspectable"
 import * as Option from "effect/Option"
-import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import * as FileSystem from "./FileSystem.js"
 import type * as Headers from "./Headers.js"
@@ -53,18 +52,6 @@ export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?
     Effect.flatMap(self.json, parse)
 }
 
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaBodyJsonScoped = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
-  const decode = schemaBodyJson(schema, options)
-  return <E, E2, R2>(
-    effect: Effect.Effect<HttpIncomingMessage<E>, E2, R2>
-  ): Effect.Effect<A, ParseResult.ParseError | E | E2, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /**
  * @since 1.0.0
  * @category schema
@@ -78,21 +65,6 @@ export const schemaBodyUrlParams = <A, I extends Readonly<Record<string, string
     Effect.flatMap(self.urlParamsBody, (_) => parse(Object.fromEntries(_)))
 }
 
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaBodyUrlParamsScoped = <A, I extends Readonly<Record<string, string | undefined>>, R>(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => {
-  const decode = schemaBodyUrlParams(schema, options)
-  return <E, E2, R2>(
-    effect: Effect.Effect<HttpIncomingMessage<E>, E2, R2>
-  ): Effect.Effect<A, ParseResult.ParseError | E | E2, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /**
  * @since 1.0.0
  * @category schema
@@ -105,21 +77,6 @@ export const schemaHeaders = <A, I extends Readonly<Record<string, string | unde
   return <E>(self: HttpIncomingMessage<E>): Effect.Effect<A, ParseResult.ParseError, R> => parse(self.headers)
 }
 
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaHeadersScoped = <A, I extends Readonly<Record<string, string | undefined>>, R>(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => {
-  const decode = schemaHeaders(schema, options)
-  return <E, E2, R2>(
-    effect: Effect.Effect<HttpIncomingMessage<E>, E2, R2>
-  ): Effect.Effect<A, ParseResult.ParseError | E2, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /**
  * @since 1.0.0
  * @category fiber refs