@effect/platform 0.48.29 → 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,
@@ -220,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
           )
@@ -259,12 +261,12 @@ 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 handler: Router.Route.Handler<E, R>,
     readonly prefix = Option.none<string>(),
     readonly uninterruptible = false
   ) {
@@ -293,30 +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>,
+  handler: Router.Route.Handler<E, R>,
   prefix: Option.Option<string> = Option.none(),
   uninterruptible = false
-): Router.Route<Router.Router.ExcludeProvided<R>, E> =>
-  new RouteImpl(method, path, handler, prefix, uninterruptible) as any
+): 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 = (
@@ -325,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) => {
@@ -352,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))
@@ -368,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
 )
 
@@ -400,40 +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>,
+    handler: Router.Route.Handler<E1, R1>,
     options?: {
       readonly uninterruptible?: boolean | undefined
     } | undefined
-  ): Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
+  ): 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>,
+      handler: Router.Route.Handler<E1, R1>,
       options?: {
         readonly uninterruptible?: boolean | undefined
       } | undefined
-    ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>
-  >((args) => Predicate.hasProperty(args[0], TypeId), (self, path, handler, options) =>
+    ) => 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, Option.none(), options?.uninterruptible ?? false)),
+      Chunk.append(
+        self.routes,
+        new RouteImpl(
+          method,
+          path,
+          handler,
+          Option.none(),
+          options?.uninterruptible ?? false
+        )
+      ),
       self.mounts
     ))
 
@@ -463,13 +480,13 @@ 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(
@@ -484,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 */
@@ -529,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,
@@ -549,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)))
 
@@ -570,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<
@@ -589,33 +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)

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"

package/src/internal/worker.ts

@@ -1,5 +1,6 @@
 import * as Schema from "@effect/schema/Schema"
 import * as Serializable from "@effect/schema/Serializable"
+import * as Array from "effect/Array"
 import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
@@ -13,7 +14,6 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Pool from "effect/Pool"
 import * as Queue from "effect/Queue"
-import * as ReadonlyArray from "effect/ReadonlyArray"
 import * as Schedule from "effect/Schedule"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
@@ -64,7 +64,7 @@ export const makeManager = Effect.gen(function*(_) {
   let idCounter = 0
   return WorkerManager.of({
     [WorkerManagerTypeId]: WorkerManagerTypeId,
-    spawn<I, E, O>({
+    spawn<I, O, E>({
       encode,
       initialMessage,
       permits = 1,
@@ -112,7 +112,7 @@ export const makeManager = Effect.gen(function*(_) {
               Queue.take(backing.queue),
               Effect.flatMap((msg) => {
                 if (msg[0] === 0) {
-                  return Deferred.complete(readyLatch, Effect.unit)
+                  return Deferred.complete(readyLatch, Effect.void)
                 }
                 return handleMessage(msg[1])
               }),
@@ -153,7 +153,7 @@ export const makeManager = Effect.gen(function*(_) {
         const handleMessage = (response: Worker.Worker.Response<E, O>) =>
           Effect.suspend(() => {
             const queue = requestMap.get(response[0])
-            if (!queue) return Effect.unit
+            if (!queue) return Effect.void
 
             switch (response[1]) {
               // data
@@ -210,7 +210,7 @@ export const makeManager = Effect.gen(function*(_) {
           exit: Exit.Exit<unknown, unknown>
         ) => {
           const release = Effect.zipRight(
-            Deferred.complete(deferred, Effect.unit),
+            Deferred.complete(deferred, Effect.void),
             Effect.sync(() => requestMap.delete(id))
           )
           return Exit.isFailure(exit) ?
@@ -229,7 +229,7 @@ export const makeManager = Effect.gen(function*(_) {
                 .flatMap(
                   Queue.take(queue),
                   Exit.match({
-                    onFailure: (cause) => Cause.isEmpty(cause) ? Channel.unit : Channel.failCause(cause),
+                    onFailure: (cause) => Cause.isEmpty(cause) ? Channel.void : Channel.failCause(cause),
                     onSuccess: (value) => Channel.flatMap(Channel.write(Chunk.unsafeFromArray(value)), () => loop)
                   })
                 )
@@ -240,7 +240,7 @@ export const makeManager = Effect.gen(function*(_) {
         const executeEffect = (request: I) =>
           Effect.acquireUseRelease(
             executeAcquire(request),
-            ([, queue]) => Effect.flatMap(Queue.take(queue), Exit.map(ReadonlyArray.unsafeGet(0))),
+            ([, queue]) => Effect.flatMap(Queue.take(queue), Exit.map(Array.unsafeGet(0))),
             executeRelease
           )
 
@@ -251,7 +251,7 @@ export const makeManager = Effect.gen(function*(_) {
             pipe(
               Effect.suspend(() => {
                 const result = requestMap.get(id)
-                if (!result) return Effect.unit
+                if (!result) return Effect.void
                 const transferables = transfers(request)
                 const spanTuple = Option.getOrUndefined(
                   Option.map(span, (span) => [span.traceId, span.spanId, span.sampled] as const)
@@ -296,14 +296,14 @@ export const makeManager = Effect.gen(function*(_) {
 export const layerManager = Layer.effect(WorkerManager, makeManager)
 
 /** @internal */
-export const makePool = <I, E, O>(
+export const makePool = <I, O, E>(
   options: Worker.WorkerPool.Options<I>
 ) =>
   Effect.gen(function*(_) {
     const manager = yield* _(WorkerManager)
-    const workers = new Set<Worker.Worker<I, E, O>>()
+    const workers = new Set<Worker.Worker<I, O, E>>()
     const acquire = pipe(
-      manager.spawn<I, E, O>(options),
+      manager.spawn<I, O, E>(options),
       Effect.tap((worker) => Effect.sync(() => workers.add(worker))),
       Effect.tap((worker) => Effect.addFinalizer(() => Effect.sync(() => workers.delete(worker)))),
       options.onCreate ? Effect.tap(options.onCreate) : identity
@@ -321,7 +321,7 @@ export const makePool = <I, E, O>(
           size: options.size
         })
     )
-    const pool: Worker.WorkerPool<I, E, O> = {
+    const pool: Worker.WorkerPool<I, O, E> = {
       backing,
       broadcast: (message: I) =>
         Effect.forEach(workers, (worker) => worker.executeEffect(message), {
@@ -346,8 +346,8 @@ export const makePool = <I, E, O>(
   })
 
 /** @internal */
-export const makePoolLayer = <Tag, I, E, O>(
-  tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
+export const makePoolLayer = <Tag, I, O, E>(
+  tag: Context.Tag<Tag, Worker.WorkerPool<I, O, E>>,
   options: Worker.WorkerPool.Options<I>
 ) => Layer.scoped(tag, makePool(options))