@effect/platform 0.43.11 → 0.44.1

package/src/Http/Client.ts

@@ -31,7 +31,7 @@ export type TypeId = typeof TypeId
  * @category models
  */
 export interface Client<R, E, A> extends Pipeable {
-  (request: ClientRequest.ClientRequest): Effect.Effect<R, E, A>
+  (request: ClientRequest.ClientRequest): Effect.Effect<A, E, R>
   readonly [TypeId]: TypeId
   readonly preprocess: Client.Preprocess<R, E>
   readonly execute: Client.Execute<R, E, A>
@@ -47,15 +47,15 @@ export declare namespace Client {
    */
   export type Preprocess<R, E> = (
     request: ClientRequest.ClientRequest
-  ) => Effect.Effect<R, E, ClientRequest.ClientRequest>
+  ) => Effect.Effect<ClientRequest.ClientRequest, E, R>
 
   /**
    * @since 1.0.0
    * @category models
    */
   export type Execute<R, E, A> = (
-    request: Effect.Effect<R, E, ClientRequest.ClientRequest>
-  ) => Effect.Effect<R, E, A>
+    request: Effect.Effect<ClientRequest.ClientRequest, E, R>
+  ) => Effect.Effect<A, E, R>
 
   /**
    * @since 1.0.0
@@ -94,7 +94,7 @@ export const Fetch: Context.Tag<Fetch, typeof globalThis.fetch> = internal.Fetch
  * @since 1.0.0
  * @category layers
  */
-export const layer: Layer.Layer<never, never, Client.Default> = internal.layer
+export const layer: Layer.Layer<Client.Default> = internal.layer
 
 /**
  * @since 1.0.0
@@ -113,8 +113,8 @@ export const fetchOk: (options?: RequestInit) => Client.Default = internal.fetch
  * @category error handling
  */
 export const catchAll: {
-  <E, R2, E2, A2>(f: (e: E) => Effect.Effect<R2, E2, A2>): <R, A>(self: Client<R, E, A>) => Client<R2 | R, E2, A2 | A>
-  <R, E, A, R2, E2, A2>(self: Client<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, A2>): Client<R | R2, E2, A | A2>
+  <E, R2, E2, A2>(f: (e: E) => Effect.Effect<A2, E2, R2>): <R, A>(self: Client<R, E, A>) => Client<R2 | R, E2, A2 | A>
+  <R, E, A, R2, E2, A2>(self: Client<R, E, A>, f: (e: E) => Effect.Effect<A2, E2, R2>): Client<R | R2, E2, A | A2>
 } = internal.catchAll
 
 /**
@@ -124,12 +124,12 @@ export const catchAll: {
 export const catchTag: {
   <E extends { _tag: string }, K extends E["_tag"] & string, 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<R, E, A>) => Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
   <R, E extends { _tag: string }, A, K extends E["_tag"] & string, E1, R1, A1>(
     self: 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<R | R1, E1 | Exclude<E, { _tag: K }>, A | A1>
 } = internal.catchTag
 
@@ -148,7 +148,7 @@ export const catchTags: {
   ) => Client<
     | R
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer R, any, any> ? R : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
@@ -156,7 +156,7 @@ export const catchTags: {
     }[keyof Cases],
     | A
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer A> ? A : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : never
     }[keyof Cases]
   >
   <
@@ -170,7 +170,7 @@ export const catchTags: {
   ): Client<
     | R
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer R, any, any> ? R : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
@@ -178,7 +178,7 @@ export const catchTags: {
     }[keyof Cases],
     | A
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer A> ? A : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : never
     }[keyof Cases]
   >
 } = internal.catchTags
@@ -190,12 +190,12 @@ export const catchTags: {
 export const filterOrElse: {
   <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<R, E, A>) => Client<R2 | R, E2 | E, A | B>
   <R, E, A, R2, E2, B>(
     self: 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<R | R2, E | E2, A | B>
 } = internal.filterOrElse
 
@@ -235,7 +235,7 @@ export const filterStatusOk: <R, E>(
  * @category constructors
  */
 export const make: <R, E, A, R2, E2>(
-  execute: (request: Effect.Effect<R2, E2, ClientRequest.ClientRequest>) => Effect.Effect<R, E, A>,
+  execute: (request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>) => Effect.Effect<A, E, R>,
   preprocess: Client.Preprocess<R2, E2>
 ) => Client<R, E, A> = internal.make
 
@@ -246,7 +246,7 @@ export const make: <R, E, A, R2, E2>(
 export const makeDefault: (
   f: (
     request: ClientRequest.ClientRequest
-  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError>
 ) => Client.Default = internal.makeDefault
 
 /**
@@ -255,11 +255,11 @@ export const makeDefault: (
  */
 export const transform: {
   <R, E, A, R1, E1, A1>(
-    f: (effect: Effect.Effect<R, E, A>, request: ClientRequest.ClientRequest) => Effect.Effect<R1, E1, A1>
+    f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
   ): (self: Client<R, E, A>) => Client<R | R1, E | E1, A1>
   <R, E, A, R1, E1, A1>(
     self: Client<R, E, A>,
-    f: (effect: Effect.Effect<R, E, A>, request: ClientRequest.ClientRequest) => Effect.Effect<R1, E1, A1>
+    f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
   ): Client<R | R1, E | E1, A1>
 } = internal.transform
 
@@ -269,11 +269,11 @@ export const transform: {
  */
 export const transformResponse: {
   <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<R, E, A>) => Client<R1, E1, A1>
   <R, E, A, R1, E1, A1>(
     self: 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<R1, E1, A1>
 } = internal.transformResponse
 
@@ -291,8 +291,8 @@ export const map: {
  * @category mapping & sequencing
  */
 export const mapEffect: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, B>
-  <R, E, A, R2, E2, B>(self: Client<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Client<R | R2, E | E2, B>
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, B>
+  <R, E, A, R2, E2, B>(self: Client<R, E, A>, f: (a: A) => Effect.Effect<B, E2, R2>): Client<R | R2, E | E2, B>
 } = internal.mapEffect
 
 /**
@@ -312,11 +312,11 @@ export const mapRequest: {
  */
 export const mapRequestEffect: {
   <R2, E2>(
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): <R, E, A>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
   <R, E, A, R2, E2>(
     self: Client<R, E, A>,
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): Client<R | R2, E | E2, A>
 } = internal.mapRequestEffect
 
@@ -337,11 +337,11 @@ export const mapInputRequest: {
  */
 export const mapInputRequestEffect: {
   <R2, E2>(
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): <R, E, A>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
   <R, E, A, R2, E2>(
     self: Client<R, E, A>,
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): Client<R | R2, E | E2, A>
 } = internal.mapInputRequestEffect
 
@@ -359,19 +359,19 @@ export const retry: {
  * @category schema
  */
 export const schemaFunction: {
-  <SR, SI, SA>(
-    schema: Schema.Schema<SR, SI, SA>
+  <SA, SI, SR>(
+    schema: Schema.Schema<SA, SI, SR>
   ): <R, E, A>(
     self: Client<R, E, A>
   ) => (
     request: ClientRequest.ClientRequest
-  ) => (a: SA) => Effect.Effect<SR | R, E | ParseResult.ParseError | Error.RequestError, A>
-  <R, E, A, SR, SI, SA>(
+  ) => (a: SA) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
+  <R, E, A, SA, SI, SR>(
     self: 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, ParseResult.ParseError | Error.RequestError | E, A>
+  ) => (a: SA) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
 } = internal.schemaFunction
 
 /**
@@ -379,8 +379,8 @@ export const schemaFunction: {
  * @category mapping & sequencing
  */
 export const tap: {
-  <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, _>(self: Client<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, _>): Client<R | R2, E | E2, A>
+  <A, R2, E2, _>(f: (a: A) => Effect.Effect<_, E2, R2>): <R, E>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
+  <R, E, A, R2, E2, _>(self: Client<R, E, A>, f: (a: A) => Effect.Effect<_, E2, R2>): Client<R | R2, E | E2, A>
 } = internal.tap
 
 /**
@@ -389,10 +389,10 @@ export const tap: {
  */
 export const tapRequest: {
   <R2, E2, _>(
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ): <R, E, A>(self: Client<R, E, A>) => Client<R2 | R, E2 | E, A>
   <R, E, A, R2, E2, _>(
     self: Client<R, E, A>,
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ): Client<R | R2, E | E2, A>
 } = internal.tapRequest

package/src/Http/ClientError.ts

@@ -1,7 +1,6 @@
 /**
  * @since 1.0.0
  */
-import type * as Data from "effect/Data"
 import * as internal from "../internal/http/clientError.js"
 import type * as ClientRequest from "./ClientRequest.js"
 import type * as ClientResponse from "./ClientResponse.js"
@@ -32,7 +31,7 @@ export declare namespace HttpError {
    * @since 1.0.0
    * @category models
    */
-  export interface Proto extends Data.Case {
+  export interface Proto {
     readonly [TypeId]: TypeId
     readonly _tag: string
   }
@@ -40,7 +39,7 @@ export declare namespace HttpError {
   /**
    * @since 1.0.0
    */
-  export type ProvidedFields = TypeId | "_tag" | keyof Data.Case
+  export type ProvidedFields = TypeId | "_tag"
 }
 
 /**

package/src/Http/ClientRequest.ts

@@ -43,13 +43,13 @@ export interface ClientRequest extends Pipeable {
  * @category models
  */
 export interface Options {
-  readonly method?: Method
-  readonly url?: string
-  readonly urlParams?: UrlParams.Input
-  readonly headers?: Headers.Input
-  readonly body?: Body.Body
-  readonly accept?: string
-  readonly acceptJson?: boolean
+  readonly method?: Method | undefined
+  readonly url?: string | undefined
+  readonly urlParams?: UrlParams.Input | undefined
+  readonly headers?: Headers.Input | undefined
+  readonly body?: Body.Body | undefined
+  readonly accept?: string | undefined
+  readonly acceptJson?: boolean | undefined
 }
 
 /**
@@ -283,8 +283,8 @@ export const textBody: {
  * @category combinators
  */
 export const jsonBody: {
-  (body: unknown): (self: ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest>
-  (self: ClientRequest, body: unknown): Effect.Effect<never, Body.BodyError, ClientRequest>
+  (body: unknown): (self: ClientRequest) => Effect.Effect<ClientRequest, Body.BodyError>
+  (self: ClientRequest, body: unknown): Effect.Effect<ClientRequest, Body.BodyError>
 } = internal.jsonBody
 
 /**
@@ -300,11 +300,11 @@ export const unsafeJsonBody: {
  * @since 1.0.0
  * @category combinators
  */
-export const schemaBody: <R, I, A>(
-  schema: Schema.Schema<R, I, A>
+export const schemaBody: <A, I, R>(
+  schema: Schema.Schema<A, I, R>
 ) => {
-  (body: A): (self: ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest>
-  (self: ClientRequest, body: A): Effect.Effect<R, Body.BodyError, ClientRequest>
+  (body: A): (self: ClientRequest) => Effect.Effect<ClientRequest, Body.BodyError, R>
+  (self: ClientRequest, body: A): Effect.Effect<ClientRequest, Body.BodyError, R>
 } = internal.schemaBody
 
 /**
@@ -331,12 +331,12 @@ export const formDataBody: {
  */
 export const streamBody: {
   (
-    body: Stream.Stream<never, unknown, Uint8Array>,
+    body: Stream.Stream<Uint8Array, unknown>,
     options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
   ): (self: ClientRequest) => ClientRequest
   (
     self: ClientRequest,
-    body: Stream.Stream<never, unknown, Uint8Array>,
+    body: Stream.Stream<Uint8Array, unknown>,
     options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
   ): ClientRequest
 } = internal.streamBody
@@ -349,12 +349,12 @@ export const fileBody: {
   (
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
-  ): (self: ClientRequest) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest>
+  ): (self: ClientRequest) => Effect.Effect<ClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
   (
     self: ClientRequest,
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
-  ): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest>
+  ): Effect.Effect<ClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
 } = internal.fileBody
 
 /**

package/src/Http/ClientResponse.ts

@@ -46,7 +46,7 @@ export type TypeId = typeof TypeId
 export interface ClientResponse extends IncomingMessage.IncomingMessage<Error.ResponseError> {
   readonly [TypeId]: TypeId
   readonly status: number
-  readonly formData: Effect.Effect<never, Error.ResponseError, FormData>
+  readonly formData: Effect.Effect<FormData, Error.ResponseError>
 }
 
 /**
@@ -68,8 +68,8 @@ export const schemaJson: <
   },
   A
 >(
-  schema: Schema.Schema<R, I, A>
-) => (self: ClientResponse) => Effect.Effect<R, Error.ResponseError | ParseResult.ParseError, A> = internal.schemaJson
+  schema: Schema.Schema<A, I, R>
+) => (self: ClientResponse) => Effect.Effect<A, Error.ResponseError | ParseResult.ParseError, R> = internal.schemaJson
 
 /**
  * @since 1.0.0
@@ -77,7 +77,10 @@ export const schemaJson: <
  */
 export const schemaNoBody: <
   R,
-  I extends { readonly status?: number | undefined; readonly headers?: Readonly<Record<string, string>> | undefined },
+  I extends {
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+  },
   A
->(schema: Schema.Schema<R, I, A>) => (self: ClientResponse) => Effect.Effect<R, ParseResult.ParseError, A> =
+>(schema: Schema.Schema<A, I, R>) => (self: ClientResponse) => Effect.Effect<A, ParseResult.ParseError, R> =
   internal.schemaNoBody

package/src/Http/Etag.ts

@@ -55,8 +55,8 @@ export type GeneratorTypeId = typeof GeneratorTypeId
  */
 export interface Generator {
   readonly [GeneratorTypeId]: GeneratorTypeId
-  readonly fromFileInfo: (info: FileSystem.File.Info) => Effect.Effect<never, never, Etag>
-  readonly fromFileWeb: (file: Body.Body.FileLike) => Effect.Effect<never, never, Etag>
+  readonly fromFileInfo: (info: FileSystem.File.Info) => Effect.Effect<Etag>
+  readonly fromFileWeb: (file: Body.Body.FileLike) => Effect.Effect<Etag>
 }
 
 /**

package/src/Http/IncomingMessage.ts

@@ -35,20 +35,20 @@ export interface IncomingMessage<E> {
   readonly [TypeId]: TypeId
   readonly headers: Headers.Headers
   readonly remoteAddress: Option.Option<string>
-  readonly json: Effect.Effect<never, E, unknown>
-  readonly text: Effect.Effect<never, E, string>
-  readonly urlParamsBody: Effect.Effect<never, E, UrlParams.UrlParams>
-  readonly arrayBuffer: Effect.Effect<never, E, ArrayBuffer>
-  readonly stream: Stream.Stream<never, E, Uint8Array>
+  readonly json: Effect.Effect<unknown, E>
+  readonly text: Effect.Effect<string, E>
+  readonly urlParamsBody: Effect.Effect<UrlParams.UrlParams, E>
+  readonly arrayBuffer: Effect.Effect<ArrayBuffer, E>
+  readonly stream: Stream.Stream<Uint8Array, E>
 }
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
+export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
   const parse = Schema.decodeUnknown(schema)
-  return <E>(self: IncomingMessage<E>): Effect.Effect<R, E | ParseResult.ParseError, A> =>
+  return <E>(self: IncomingMessage<E>): Effect.Effect<A, E | ParseResult.ParseError, R> =>
     Effect.flatMap(self.json, parse)
 }
 
@@ -57,10 +57,10 @@ export const schemaBodyJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
  * @category schema
  */
 export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => {
   const parse = Schema.decodeUnknown(schema)
-  return <E>(self: IncomingMessage<E>): Effect.Effect<R, E | ParseResult.ParseError, A> =>
+  return <E>(self: IncomingMessage<E>): Effect.Effect<A, E | ParseResult.ParseError, R> =>
     Effect.flatMap(self.urlParamsBody, (_) => parse(Object.fromEntries(_)))
 }
 
@@ -68,9 +68,9 @@ export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>
  * @since 1.0.0
  * @category schema
  */
-export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
+export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<A, I, R>) => {
   const parse = Schema.decodeUnknown(schema)
-  return <E>(self: IncomingMessage<E>): Effect.Effect<R, ParseResult.ParseError, A> => parse(self.headers)
+  return <E>(self: IncomingMessage<E>): Effect.Effect<A, ParseResult.ParseError, R> => parse(self.headers)
 }
 
 const SpanSchema = Schema.struct({
@@ -84,7 +84,9 @@ const SpanSchema = Schema.struct({
  * @since 1.0.0
  * @category schema
  */
-export const schemaExternalSpan = flow(
+export const schemaExternalSpan: <E>(
+  self: IncomingMessage<E>
+) => Effect.Effect<Tracer.ExternalSpan, ParseResult.ParseError> = flow(
   schemaHeaders(Schema.union(
     Schema.transformOrFail(
       Schema.struct({
@@ -94,16 +96,18 @@ export const schemaExternalSpan = flow(
       (input, _, ast) => {
         const parts = input.b3.split("-")
         if (parts.length >= 2) {
-          return ParseResult.succeed({
-            traceId: parts[0],
-            spanId: parts[1],
-            sampled: parts[2] ? parts[2] === "1" : true,
-            parentSpanId: parts[3]
-          })
+          return ParseResult.succeed(
+            {
+              traceId: parts[0],
+              spanId: parts[1],
+              sampled: parts[2] ? parts[2] === "1" : true,
+              parentSpanId: parts[3]
+            } as const
+          )
         }
         return ParseResult.fail(ParseResult.type(ast, input))
       },
-      (_) => ParseResult.succeed({ b3: "" })
+      (_) => ParseResult.succeed({ b3: "" } as const)
     ),
     Schema.transform(
       Schema.struct({
@@ -118,13 +122,13 @@ export const schemaExternalSpan = flow(
         spanId: _["x-b3-spanid"],
         parentSpanId: _["x-b3-parentspanid"],
         sampled: _["x-b3-sampled"] === "1"
-      }),
+      } as const),
       (_) => ({
         "x-b3-traceid": _.traceId,
         "x-b3-spanid": _.spanId,
         "x-b3-parentspanid": _.parentSpanId,
         "x-b3-sampled": _.sampled ? "1" : "0"
-      })
+      } as const)
     )
   )),
   Effect.map((_): ExternalSpan =>
@@ -150,6 +154,6 @@ export const maxBodySize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = Gl
  * @category fiber refs
  */
 export const withMaxBodySize = dual<
-  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<R, E, A>
+  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxBodySize, Option.map(size, FileSystem.Size)))

package/src/Http/Middleware.ts

@@ -50,7 +50,7 @@ export const loggerDisabled: FiberRef.FiberRef<boolean> = internal.loggerDisable
  * @since 1.0.0
  * @category fiber refs
  */
-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> =
   internal.withLoggerDisabled
 
 /**
@@ -67,11 +67,11 @@ export const currentTracerDisabledWhen: FiberRef.FiberRef<Predicate.Predicate<Se
 export const withTracerDisabledWhen: {
   (
     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>
 } = internal.withTracerDisabledWhen
 
 /**