@effect/platform 0.48.28 → 0.49.0

package/src/Http/Router.ts

@@ -34,13 +34,15 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Router<R, E> extends App.Default<Exclude<R, RouteContext>, E | Error.RouteNotFound>, Inspectable {
+export interface Router<E = never, R = never>
+  extends App.Default<E | Error.RouteNotFound, Exclude<R, RouteContext>>, Inspectable
+{
   readonly [TypeId]: TypeId
-  readonly routes: Chunk.Chunk<Route<R, E>>
+  readonly routes: Chunk.Chunk<Route<E, R>>
   readonly mounts: Chunk.Chunk<
     readonly [
       prefix: string,
-      httpApp: App.Default<R, E>,
+      httpApp: App.Default<E, R>,
       options?: { readonly includePrefix?: boolean | undefined } | undefined
     ]
   >
@@ -78,12 +80,13 @@ export type PathInput = `/${string}` | "*"
  * @since 1.0.0
  * @category models
  */
-export interface Route<R, E> extends Inspectable {
+export interface Route<E = never, R = never> extends Inspectable {
   readonly [RouteTypeId]: RouteTypeId
   readonly method: Method.Method | "*"
   readonly path: PathInput
-  readonly handler: Route.Handler<R, E>
+  readonly handler: Route.Handler<E, R>
   readonly prefix: Option.Option<string>
+  readonly uninterruptible: boolean
 }
 
 /**
@@ -93,7 +96,7 @@ export declare namespace Route {
   /**
    * @since 1.0.0
    */
-  export type Handler<R, E> = Effect.Effect<
+  export type Handler<E, R> = Effect.Effect<
     ServerResponse.ServerResponse,
     E,
     R | RouteContext | ServerRequest.ServerRequest
@@ -224,7 +227,7 @@ export const schemaSearchParams: <R, I extends Readonly<Record<string, string>>,
  * @since 1.0.0
  * @category constructors
  */
-export const empty: Router<never, never> = internal.empty
+export const empty: Router = internal.empty
 
 /**
  * @since 1.0.0
@@ -232,27 +235,28 @@ export const empty: Router<never, never> = internal.empty
  */
 export const fromIterable: <R extends Route<any, any>>(
   routes: Iterable<R>
-) => Router<R extends Route<infer Env, infer _> ? Env : never, R extends Route<infer _, infer E> ? E : never> =
+) => Router<R extends Route<infer E, infer _> ? E : never, R extends Route<infer _, infer Env> ? Env : never> =
   internal.fromIterable
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makeRoute: <R, E>(
+export const makeRoute: <E, R>(
   method: Method.Method,
   path: PathInput,
-  handler: Route.Handler<R, E>,
-  prefix?: Option.Option<string>
-) => Route<Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E> = internal.makeRoute
+  handler: Route.Handler<E, R>,
+  prefix?: Option.Option<string>,
+  uninterruptible?: boolean
+) => Route<E, Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>> = internal.makeRoute
 
 /**
  * @since 1.0.0
  * @category combinators
  */
 export const prefixAll: {
-  (prefix: PathInput): <R, E>(self: Router<R, E>) => Router<R, E>
-  <R, E>(self: Router<R, E>, prefix: PathInput): Router<R, E>
+  (prefix: PathInput): <R, E>(self: Router<E, R>) => Router<E, R>
+  <R, E>(self: Router<E, R>, prefix: PathInput): Router<E, R>
 } = internal.prefixAll
 
 /**
@@ -260,12 +264,12 @@ export const prefixAll: {
  * @category combinators
  */
 export const concat: {
-  <R1, E1>(that: Router<R1, E1>): <R, E>(
-    self: Router<R, E>
-  ) => Router<R1 | R, E1 | E>
-  <R, E, R1, E1>(self: Router<R, E>, that: Router<R1, E1>): Router<
-    R | R1,
-    E | E1
+  <R1, E1>(that: Router<E1, R1>): <R, E>(
+    self: Router<E, R>
+  ) => Router<E1 | E, R1 | R>
+  <R, E, R1, E1>(self: Router<E, R>, that: Router<E1, R1>): Router<
+    E | E1,
+    R | R1
   >
 } = internal.concat
 
@@ -274,8 +278,8 @@ export const concat: {
  * @category routing
  */
 export const mount: {
-  <R1, E1>(path: `/${string}`, that: Router<R1, E1>): <R, E>(self: Router<R, E>) => Router<R1 | R, E1 | E>
-  <R, E, R1, E1>(self: Router<R, E>, path: `/${string}`, that: Router<R1, E1>): Router<R | R1, E | E1>
+  <R1, E1>(path: `/${string}`, that: Router<E1, R1>): <R, E>(self: Router<E, R>) => Router<E1 | E, R1 | R>
+  <R, E, R1, E1>(self: Router<E, R>, path: `/${string}`, that: Router<E1, R1>): Router<E | E1, R | R1>
 } = internal.mount
 
 /**
@@ -285,24 +289,24 @@ export const mount: {
 export const mountApp: {
   <R1, E1>(
     path: `/${string}`,
-    that: App.Default<R1, E1>,
+    that: App.Default<E1, R1>,
     options?: { readonly includePrefix?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
+    self: Router<E, R>
   ) => Router<
+    E1 | E,
     | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
-    | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>,
-    E1 | E
+    | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
   >
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: `/${string}`,
-    that: App.Default<R1, E1>,
+    that: App.Default<E1, R1>,
     options?: { readonly includePrefix?: boolean | undefined } | undefined
   ): Router<
+    E | E1,
     | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
-    | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>,
-    E | E1
+    | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
   >
 } = internal.mountApp
 
@@ -315,15 +319,17 @@ export const route: (
 ) => {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>>
 } = internal.route
 
 /**
@@ -333,15 +339,17 @@ export const route: (
 export const all: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.all
 
 /**
@@ -351,15 +359,17 @@ export const all: {
 export const get: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.get
 
 /**
@@ -369,15 +379,17 @@ export const get: {
 export const post: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.post
 
 /**
@@ -387,15 +399,17 @@ export const post: {
 export const patch: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.patch
 
 /**
@@ -405,15 +419,17 @@ export const patch: {
 export const put: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.put
 
 /**
@@ -423,15 +439,17 @@ export const put: {
 export const del: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.del
 
 /**
@@ -441,15 +459,17 @@ export const del: {
 export const head: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.head
 
 /**
@@ -459,15 +479,17 @@ export const head: {
 export const options: {
   <R1, E1>(
     path: PathInput,
-    handler: Route.Handler<R1, E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | E>
+    self: Router<E, R>
+  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+    handler: Route.Handler<E1, R1>,
+    options?: { readonly uninterruptible?: boolean | undefined } | undefined
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.options
 
 /**
@@ -475,13 +497,13 @@ export const options: {
  * @category combinators
  */
 export const use: {
-  <R, E, R1, E1>(
-    f: (self: Route.Handler<R, E>) => App.Default<R1, E1>
-  ): (self: Router<R, E>) => Router<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1>
-  <R, E, R1, E1>(
-    self: Router<R, E>,
-    f: (self: Route.Handler<R, E>) => App.Default<R1, E1>
-  ): Router<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1>
+  <E, R, R1, E1>(
+    f: (self: Route.Handler<E, R>) => App.Default<E1, R1>
+  ): (self: Router<E, R>) => Router<E1, Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  <E, R, R1, E1>(
+    self: Router<E, R>,
+    f: (self: Route.Handler<E, R>) => App.Default<E1, R1>
+  ): Router<E1, Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.use
 
 /**
@@ -489,13 +511,13 @@ export const use: {
  * @category combinators
  */
 export const catchAll: {
-  <E, R2, E2>(
-    f: (e: E) => Route.Handler<R2, E2>
-  ): <R>(self: Router<R, E>) => Router<R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E2>
-  <R, E, R2, E2>(
-    self: Router<R, E>,
-    f: (e: E) => Route.Handler<R2, E2>
-  ): Router<R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E2>
+  <E, E2, R2>(
+    f: (e: E) => Route.Handler<E2, R2>
+  ): <R>(self: Router<E, R>) => Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  <R, E, E2, R2>(
+    self: Router<E, R>,
+    f: (e: E) => Route.Handler<E2, R2>
+  ): Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.catchAll
 
 /**
@@ -503,13 +525,13 @@ export const catchAll: {
  * @category combinators
  */
 export const catchAllCause: {
-  <E, R2, E2>(
-    f: (e: Cause.Cause<E>) => Route.Handler<R2, E2>
-  ): <R>(self: Router<R, E>) => Router<R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E2>
-  <R, E, R2, E2>(
-    self: Router<R, E>,
-    f: (e: Cause.Cause<E>) => Route.Handler<R2, E2>
-  ): Router<R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E2>
+  <E, E2, R2>(
+    f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
+  ): <R>(self: Router<E, R>) => Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  <R, E, E2, R2>(
+    self: Router<E, R>,
+    f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
+  ): Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.catchAllCause
 
 /**
@@ -517,17 +539,17 @@ export const catchAllCause: {
  * @category combinators
  */
 export const catchTag: {
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1>(
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, E1, R1>(
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Route.Handler<R1, E1>
+    f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
   ): <R>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | Exclude<E, { _tag: K }>>
-  <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>
+  ) => Router<E1 | Exclude<E, { _tag: K }>, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
+    self: Router<E, R>,
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Route.Handler<R1, E1>
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | Exclude<E, { _tag: K }>>
+    f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
+  ): Router<E1 | Exclude<E, { _tag: K }>, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.catchTag
 
 /**
@@ -543,19 +565,19 @@ export const catchTags: {
   >(
     cases: Cases
   ): <R>(
-    self: Router<R, E>
+    self: Router<E, R>
   ) => Router<
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
+    }[keyof Cases],
     | R
     | Exclude<
       {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
       }[keyof Cases],
       RouteContext | ServerRequest.ServerRequest | Scope.Scope
-    >,
-    | Exclude<E, { _tag: keyof Cases }>
-    | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
-    }[keyof Cases]
+    >
   >
   <
     R,
@@ -564,20 +586,20 @@ export const catchTags: {
       ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Route.Handler<any, any>) | undefined } :
       {}
   >(
-    self: Router<R, E>,
+    self: Router<E, R>,
     cases: Cases
   ): Router<
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
+    }[keyof Cases],
     | R
     | Exclude<
       {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
       }[keyof Cases],
       RouteContext | ServerRequest.ServerRequest | Scope.Scope
-    >,
-    | Exclude<E, { _tag: keyof Cases }>
-    | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
-    }[keyof Cases]
+    >
   >
 } = internal.catchTags
 
@@ -589,12 +611,12 @@ export const provideService: {
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ): <R, E>(self: Router<R, E>) => Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+  ): <R, E>(self: Router<E, R>) => Router<E, Exclude<R, Context.Tag.Identifier<T>>>
   <R, E, T extends Context.Tag<any, any>>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
-  ): Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+  ): Router<E, Exclude<R, Context.Tag.Identifier<T>>>
 } = internal.provideService
 
 /**
@@ -606,26 +628,19 @@ export const provideServiceEffect: {
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ): <R, E>(
-    self: Router<R, E>
+    self: Router<E, R>
   ) => Router<
+    E1 | E,
     | Exclude<R, Context.Tag.Identifier<T>>
-    | Exclude<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, Context.Tag.Identifier<T>>,
-    E1 | E
+    | Exclude<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, Context.Tag.Identifier<T>>
   >
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ): Router<
+    E | E1,
     | Exclude<R, Context.Tag.Identifier<T>>
-    | Exclude<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, Context.Tag.Identifier<T>>,
-    E | E1
+    | Exclude<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, Context.Tag.Identifier<T>>
   >
 } = internal.provideServiceEffect
-
-/**
- * @since 1.0.0
- * @category combinators
- */
-export const uninterruptible: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
-  internal.uninterruptible

package/src/Http/Server.ts

@@ -29,14 +29,14 @@ export type TypeId = typeof TypeId
 export interface Server {
   readonly [TypeId]: TypeId
   readonly serve: {
-    <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
+    <R, E>(httpApp: App.Default<E, R>): Effect.Effect<
       void,
       never,
       Exclude<R, ServerRequest.ServerRequest> | Scope.Scope
     >
     <R, E, App extends App.Default<any, any>>(
-      httpApp: App.Default<R, E>,
-      middleware: Middleware.Middleware.Applied<R, E, App>
+      httpApp: App.Default<E, R>,
+      middleware: Middleware.Middleware.Applied<App, E, R>
     ): Effect.Effect<
       void,
       never,
@@ -92,7 +92,7 @@ export const Server: Context.Tag<Server, Server> = internal.serverTag
 export const make: (
   options: {
     readonly serve: (
-      httpApp: App.Default<never, unknown>,
+      httpApp: App.Default<unknown>,
       middleware?: Middleware.Middleware
     ) => Effect.Effect<void, never, Scope.Scope>
     readonly address: Address
@@ -105,23 +105,23 @@ export const make: (
  */
 export const serve: {
   (): <R, E>(
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ) => Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, App extends App.Default<any, any>>(
-    middleware: Middleware.Middleware.Applied<R, E, App>
+    middleware: Middleware.Middleware.Applied<App, E, R>
   ): (
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ) => Layer.Layer<
     never,
     never,
     Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   >
   <R, E>(
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ): Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, App extends App.Default<any, any>>(
-    httpApp: App.Default<R, E>,
-    middleware: Middleware.Middleware.Applied<R, E, App>
+    httpApp: App.Default<E, R>,
+    middleware: Middleware.Middleware.Applied<App, E, R>
   ): Layer.Layer<never, never, Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.serve
 
@@ -131,23 +131,23 @@ export const serve: {
  */
 export const serveEffect: {
   (): <R, E>(
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ) => Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
   <R, E, App extends App.Default<any, any>>(
-    middleware: Middleware.Middleware.Applied<R, E, App>
+    middleware: Middleware.Middleware.Applied<App, E, R>
   ): (
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ) => Effect.Effect<
     void,
     never,
     Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>
   >
   <R, E>(
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
   <R, E, App extends App.Default<any, any>>(
-    httpApp: App.Default<R, E>,
-    middleware: Middleware.Middleware.Applied<R, E, App>
+    httpApp: App.Default<E, R>,
+    middleware: Middleware.Middleware.Applied<App, E, R>
   ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>>
 } = internal.serveEffect
 

package/src/Http/ServerRequest.ts

@@ -8,7 +8,7 @@ import type { Channel } from "effect/Channel"
 import type { Chunk } from "effect/Chunk"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
-import type { ReadonlyRecord } from "effect/ReadonlyRecord"
+import type { ReadonlyRecord } from "effect/Record"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as FileSystem from "../FileSystem.js"