@effect/platform 0.48.28 → 0.49.0

package/src/internal/http/router.ts

@@ -32,6 +32,8 @@ export const RouteContextTypeId: Router.RouteContextTypeId = Symbol.for(
 /** @internal */
 export const RouteContext = Context.GenericTag<Router.RouteContext>("@effect/platform/Http/Router/RouteContext")
 
+const isRouter = (u: unknown): u is Router.Router<unknown, unknown> => Predicate.hasProperty(u, TypeId)
+
 /** @internal */
 export const params = Effect.map(RouteContext, (_) => _.params)
 
@@ -131,18 +133,18 @@ export const schemaSearchParams = <R, I extends Readonly<Record<string, string>>
   return Effect.flatMap(RouteContext, (_) => parse(_.searchParams))
 }
 
-class RouterImpl<R, E> extends Effectable.StructuralClass<
+class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
   ServerResponse.ServerResponse,
   E | Error.RouteNotFound,
   Exclude<R, Router.RouteContext>
-> implements Router.Router<R, E> {
+> implements Router.Router<E, R> {
   readonly [TypeId]: Router.TypeId
   constructor(
-    readonly routes: Chunk.Chunk<Router.Route<R, E>>,
+    readonly routes: Chunk.Chunk<Router.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
       ]
     >
@@ -176,9 +178,9 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
 }
 
 const toHttpApp = <R, E>(
-  self: Router.Router<R, E>
-): App.Default<R, E | Error.RouteNotFound> => {
-  const router = FindMyWay.make<Router.Route<R, E>>()
+  self: Router.Router<E, R>
+): App.Default<E | Error.RouteNotFound, R> => {
+  const router = FindMyWay.make<Router.Route<E, R>>()
   const mounts = Chunk.toReadonlyArray(self.mounts).map(([path, app, options]) =>
     [
       path,
@@ -187,7 +189,8 @@ const toHttpApp = <R, E>(
           "*",
           options?.includePrefix ? `${path}/*` as Router.PathInput : "/*",
           app,
-          options?.includePrefix ? Option.none() : Option.some(path)
+          options?.includePrefix ? Option.none() : Option.some(path),
+          false
         ),
         {},
         {}
@@ -219,7 +222,7 @@ const toHttpApp = <R, E>(
             context = Context.add(context, ServerRequest.ServerRequest, sliceRequestUrl(request, path))
           }
           return Effect.locally(
-            routeContext.route.handler as App.Default<R, E>,
+            routeContext.route.handler as App.Default<E, R>,
             FiberRef.currentContext,
             context
           )
@@ -240,7 +243,13 @@ const toHttpApp = <R, E>(
     }
     context = Context.add(context, RouteContext, new RouteContextImpl(route, result.params, result.searchParams))
     return Effect.locally(
-      route.handler as Effect.Effect<ServerResponse.ServerResponse, E, Router.Router.ExcludeProvided<R>>,
+      (route.uninterruptible ?
+        route.handler :
+        Effect.interruptible(route.handler)) as Effect.Effect<
+          ServerResponse.ServerResponse,
+          E,
+          Router.Router.ExcludeProvided<R>
+        >,
       FiberRef.currentContext,
       context
     )
@@ -252,13 +261,14 @@ function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
   return request.modify({ url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen) })
 }
 
-class RouteImpl<R, E> extends Inspectable.Class implements Router.Route<R, E> {
+class RouteImpl<E = never, R = never> extends Inspectable.Class implements Router.Route<E, R> {
   readonly [RouteTypeId]: Router.RouteTypeId
   constructor(
     readonly method: Method.Method | "*",
     readonly path: Router.PathInput,
-    readonly handler: Router.Route.Handler<R, E>,
-    readonly prefix = Option.none<string>()
+    readonly handler: Router.Route.Handler<E, R>,
+    readonly prefix = Option.none<string>(),
+    readonly uninterruptible = false
   ) {
     super()
     this[RouteTypeId] = RouteTypeId
@@ -285,28 +295,36 @@ class RouteContextImpl implements Router.RouteContext {
 }
 
 /** @internal */
-export const empty: Router.Router<never, never> = new RouterImpl(Chunk.empty(), Chunk.empty())
+export const empty: Router.Router<never> = new RouterImpl(Chunk.empty(), Chunk.empty())
 
 /** @internal */
 export const fromIterable = <R extends Router.Route<any, any>>(
   routes: Iterable<R>
 ): Router.Router<
-  R extends Router.Route<infer Env, infer _> ? Env : never,
-  R extends Router.Route<infer _, infer E> ? E : never
+  R extends Router.Route<infer E, infer _> ? E : never,
+  R extends Router.Route<infer _, infer Env> ? Env : never
 > => new RouterImpl(Chunk.fromIterable(routes), Chunk.empty()) as any
 
 /** @internal */
-export const makeRoute = <R, E>(
+export const makeRoute = <E, R>(
   method: Method.Method,
   path: Router.PathInput,
-  handler: Router.Route.Handler<R, E>,
-  prefix: Option.Option<string> = Option.none()
-): Router.Route<Router.Router.ExcludeProvided<R>, E> => new RouteImpl(method, path, handler, prefix) as any
+  handler: Router.Route.Handler<E, R>,
+  prefix: Option.Option<string> = Option.none(),
+  uninterruptible = false
+): Router.Route<E, Router.Router.ExcludeProvided<R>> =>
+  new RouteImpl(
+    method,
+    path,
+    handler,
+    prefix,
+    uninterruptible
+  ) as any
 
 /** @internal */
 export const concat = dual<
-  <R1, E1>(that: Router.Router<R1, E1>) => <R, E>(self: Router.Router<R, E>) => Router.Router<R | R1, E | E1>,
-  <R, E, R1, E1>(self: Router.Router<R, E>, that: Router.Router<R1, E1>) => Router.Router<R | R1, E | E1>
+  <R1, E1>(that: Router.Router<E1, R1>) => <R, E>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
+  <R, E, R1, E1>(self: Router.Router<E, R>, that: Router.Router<E1, R1>) => Router.Router<E | E1, R | R1>
 >(2, (self, that) => new RouterImpl(Chunk.appendAll(self.routes, that.routes) as any, self.mounts))
 
 const removeTrailingSlash = (
@@ -315,8 +333,8 @@ const removeTrailingSlash = (
 
 /** @internal */
 export const prefixAll = dual<
-  (prefix: Router.PathInput) => <R, E>(self: Router.Router<R, E>) => Router.Router<R, E>,
-  <R, E>(self: Router.Router<R, E>, prefix: Router.PathInput) => Router.Router<R, E>
+  (prefix: Router.PathInput) => <R, E>(self: Router.Router<E, R>) => Router.Router<E, R>,
+  <R, E>(self: Router.Router<E, R>, prefix: Router.PathInput) => Router.Router<E, R>
 >(
   2,
   (self, prefix) => {
@@ -330,7 +348,8 @@ export const prefixAll = dual<
           Option.orElse(
             Option.map(route.prefix, (_) => prefix + _),
             () => Option.some(prefix)
-          )
+          ),
+          route.uninterruptible
         )),
       Chunk.map(self.mounts, ([path, app]) => [path === "/" ? prefix : prefix + path, app])
     )
@@ -341,13 +360,13 @@ export const prefixAll = dual<
 export const mount = dual<
   <R1, E1>(
     path: `/${string}`,
-    that: Router.Router<R1, E1>
-  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R | R1, E | E1>,
+    that: Router.Router<E1, R1>
+  ) => <R, E>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
   <R, E, R1, E1>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     path: `/${string}`,
-    that: Router.Router<R1, E1>
-  ) => Router.Router<R | R1, E | E1>
+    that: Router.Router<E1, R1>
+  ) => Router.Router<E | E1, R | R1>
 >(
   3,
   (self, path, that) => concat(self, prefixAll(that, path))
@@ -357,31 +376,31 @@ export const mount = dual<
 export const mountApp = dual<
   <R1, E1>(
     path: `/${string}`,
-    that: App.Default<R1, E1>,
+    that: App.Default<E1, R1>,
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
   ) => <R, E>(
-    self: Router.Router<R, E>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>,
+    self: Router.Router<E, R>
+  ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
   <R, E, R1, E1>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     path: `/${string}`,
-    that: App.Default<R1, E1>,
+    that: App.Default<E1, R1>,
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>
+  ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>
 >(
   (args) => Predicate.hasProperty(args[0], TypeId),
   <R, E, R1, E1>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     path: `/${string}`,
-    that: App.Default<R1, E1>,
+    that: App.Default<E1, R1>,
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
-  ): Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1> =>
+  ): Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>> =>
     new RouterImpl<any, any>(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that, options])) as any
 )
 
@@ -389,31 +408,49 @@ export const mountApp = dual<
 export const route = (method: Method.Method | "*"): {
   <R1, E1>(
     path: Router.PathInput,
-    handler: Router.Route.Handler<R1, E1>
+    handler: Router.Route.Handler<E1, R1>,
+    options?: {
+      readonly uninterruptible?: boolean | undefined
+    } | undefined
   ): <R, E>(
-    self: Router.Router<R, E>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
+    self: Router.Router<E, R>
+  ) => Router.Router<E1 | E, R | Router.Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     path: Router.PathInput,
-    handler: Router.Route.Handler<R1, E1>
-  ): Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
+    handler: Router.Route.Handler<E1, R1>,
+    options?: {
+      readonly uninterruptible?: boolean | undefined
+    } | undefined
+  ): Router.Router<E1 | E, R | Router.Router.ExcludeProvided<R1>>
 } =>
   dual<
     <R1, E1>(
       path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
     ) => <R, E>(
-      self: Router.Router<R, E>
-    ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>,
+      self: Router.Router<E, R>
+    ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
     <R, E, R1, E1>(
-      self: Router.Router<R, E>,
+      self: Router.Router<E, R>,
       path: Router.PathInput,
-      handler: Router.Route.Handler<R1, E1>
-    ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>
-  >(3, (self, path, handler) =>
+      handler: Router.Route.Handler<E1, R1>,
+      options?: {
+        readonly uninterruptible?: boolean | undefined
+      } | undefined
+    ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>
+  >((args) => isRouter(args[0]), (self, path, handler, options) =>
     new RouterImpl<any, any>(
-      Chunk.append(self.routes, new RouteImpl(method, path, handler)),
+      Chunk.append(
+        self.routes,
+        new RouteImpl(
+          method,
+          path,
+          handler,
+          Option.none(),
+          options?.uninterruptible ?? false
+        )
+      ),
       self.mounts
     ))
 
@@ -443,18 +480,18 @@ export const options = route("OPTIONS")
 
 /** @internal */
 export const use = dual<
-  <R, E, R1, E1>(
-    f: (self: Router.Route.Handler<R, E>) => App.Default<R1, E1>
-  ) => (self: Router.Router<R, E>) => Router.Router<Router.Router.ExcludeProvided<R1>, E1>,
-  <R, E, R1, E1>(
-    self: Router.Router<R, E>,
-    f: (self: Router.Route.Handler<R, E>) => App.Default<R1, E1>
-  ) => Router.Router<Router.Router.ExcludeProvided<R1>, E1>
+  <E, R, R1, E1>(
+    f: (self: Router.Route.Handler<E, R>) => App.Default<E1, R1>
+  ) => (self: Router.Router<E, R>) => Router.Router<E1, Router.Router.ExcludeProvided<R1>>,
+  <E, R, R1, E1>(
+    self: Router.Router<E, R>,
+    f: (self: Router.Route.Handler<E, R>) => App.Default<E1, R1>
+  ) => Router.Router<E1, Router.Router.ExcludeProvided<R1>>
 >(2, (self, f) =>
   new RouterImpl<any, any>(
     Chunk.map(
       self.routes,
-      (route) => new RouteImpl(route.method, route.path, f(route.handler) as any, route.prefix)
+      (route) => new RouteImpl(route.method, route.path, f(route.handler) as any, route.prefix, route.uninterruptible)
     ),
     Chunk.map(
       self.mounts,
@@ -464,39 +501,39 @@ export const use = dual<
 
 /** @internal */
 export const catchAll = dual<
-  <E, R2, E2>(
-    f: (e: E) => Router.Route.Handler<R2, E2>
-  ) => <R>(self: Router.Router<R, E>) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>,
-  <R, E, R2, E2>(
-    self: Router.Router<R, E>,
-    f: (e: E) => Router.Route.Handler<R2, E2>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>
+  <E, E2, R2>(
+    f: (e: E) => Router.Route.Handler<E2, R2>
+  ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
+  <R, E, E2, R2>(
+    self: Router.Router<E, R>,
+    f: (e: E) => Router.Route.Handler<E2, R2>
+  ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
 >(2, (self, f) => use(self, Effect.catchAll(f)))
 
 /** @internal */
 export const catchAllCause = dual<
-  <E, R2, E2>(
-    f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
-  ) => <R>(self: Router.Router<R, E>) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>,
-  <R, E, R2, E2>(
-    self: Router.Router<R, E>,
-    f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>
+  <E, E2, R2>(
+    f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
+  ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
+  <R, E, E2, R2>(
+    self: Router.Router<E, R>,
+    f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
+  ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
 >(2, (self, f) => use(self, Effect.catchAllCause(f)))
 
 /** @internal */
 export const catchTag = dual<
-  <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 }>) => Router.Route.Handler<R1, E1>
+    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<E1, R1>
   ) => <R>(
-    self: Router.Router<R, E>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, Exclude<E, { _tag: K }> | E1>,
-  <R, E, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>
+  ) => Router.Router<Exclude<E, { _tag: K }> | E1, R | Router.Router.ExcludeProvided<R1>>,
+  <R, E, K extends (E extends { _tag: string } ? E["_tag"] : never), E1, R1>(
+    self: Router.Router<E, R>,
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, Exclude<E, { _tag: K }> | E1>
+    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<E1, R1>
+  ) => Router.Router<Exclude<E, { _tag: K }> | E1, R | Router.Router.ExcludeProvided<R1>>
 >(3, (self, k, f) => use(self, Effect.catchTag(k, f)))
 
 /** @internal */
@@ -509,17 +546,17 @@ export const catchTags: {
       {})
   >(
     cases: Cases
-  ): <R>(self: Router.Router<R, E>) => Router.Router<
+  ): <R>(self: Router.Router<E, R>) => Router.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
     | Router.Router.ExcludeProvided<
       {
         [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 }>
-    | {
-      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
-    }[keyof Cases]
+    >
   >
   <
     R,
@@ -529,19 +566,19 @@ export const catchTags: {
       } :
       {})
   >(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     cases: Cases
   ): Router.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
     | Router.Router.ExcludeProvided<
       {
         [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 }>
-    | {
-      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
-    }[keyof Cases]
+    >
   >
 } = dual(2, (self: Router.Router<any, any>, cases: {}) => use(self, Effect.catchTags(cases)))
 
@@ -550,18 +587,18 @@ export const provideService = dual<
     tag: T,
     service: Context.Tag.Service<T>
   ) => <R, E>(
-    self: Router.Router<R, E>
-  ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>,
+    self: Router.Router<E, R>
+  ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>,
   <R, E, T extends Context.Tag<any, any>>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
-  ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+  ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>
 >(3, <R, E, T extends Context.Tag<any, any>>(
-  self: Router.Router<R, E>,
+  self: Router.Router<E, R>,
   tag: T,
   service: Context.Tag.Service<T>
-): Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E> => use(self, Effect.provideService(tag, service)))
+): Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>> => use(self, Effect.provideService(tag, service)))
 
 /* @internal */
 export const provideServiceEffect = dual<
@@ -569,40 +606,33 @@ export const provideServiceEffect = dual<
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ) => <R, E>(
-    self: Router.Router<R, E>
+    self: Router.Router<E, R>
   ) => Router.Router<
+    E | E1,
     Exclude<
       R | Router.Router.ExcludeProvided<R1>,
       Context.Tag.Identifier<T>
-    >,
-    E | E1
+    >
   >,
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ) => Router.Router<
+    E | E1,
     Exclude<
       R | Router.Router.ExcludeProvided<R1>,
       Context.Tag.Identifier<T>
-    >,
-    E | E1
+    >
   >
 >(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
-  self: Router.Router<R, E>,
+  self: Router.Router<E, R>,
   tag: T,
   effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
 ): Router.Router<
+  E | E1,
   Exclude<
     R | Router.Router.ExcludeProvided<R1>,
     Context.Tag.Identifier<T>
-  >,
-  E | E1
+  >
 > => use(self, Effect.provideServiceEffect(tag, effect)) as any)
-
-/* @internal */
-export const uninterruptible = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-  Effect.uninterruptible(Effect.flatMap(
-    effect,
-    Effect.die
-  ))

package/src/internal/http/server.ts

@@ -25,7 +25,7 @@ export const isServer = (u: unknown): u is Server.Server => typeof u === "object
 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: Server.Address
@@ -36,10 +36,10 @@ export const make = (
 export const serve = dual<
   {
     (): <R, E>(
-      httpApp: App.Default<R, E>
+      httpApp: App.Default<E, R>
     ) => Layer.Layer<never, never, Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
-    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
-      httpApp: App.Default<R, E>
+    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
+      httpApp: App.Default<E, R>
     ) => Layer.Layer<
       never,
       never,
@@ -48,11 +48,11 @@ export const serve = dual<
   },
   {
     <R, E>(
-      httpApp: App.Default<R, E>
+      httpApp: App.Default<E, R>
     ): Layer.Layer<never, never, Server.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,
@@ -62,8 +62,8 @@ export const serve = dual<
 >(
   (args) => Effect.isEffect(args[0]),
   <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,
@@ -81,14 +81,14 @@ export const serve = dual<
 export const serveEffect = dual<
   {
     (): <R, E>(
-      httpApp: App.Default<R, E>
+      httpApp: App.Default<E, R>
     ) => Effect.Effect<
       void,
       never,
       Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>
     >
-    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
-      httpApp: App.Default<R, E>
+    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
+      httpApp: App.Default<E, R>
     ) => Effect.Effect<
       void,
       never,
@@ -97,11 +97,11 @@ export const serveEffect = dual<
   },
   {
     <R, E>(
-      httpApp: App.Default<R, E>
+      httpApp: App.Default<E, R>
     ): Effect.Effect<void, never, Server.Server | Scope.Scope | 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,
@@ -111,8 +111,8 @@ export const serveEffect = dual<
 >(
   (args) => Effect.isEffect(args[0]),
   (<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,

package/src/internal/http/serverRequest.ts

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