diff --git a/.changeset/mighty-trees-wait.md b/.changeset/mighty-trees-wait.md
new file mode 100644
index 0000000000..48ef0aaa2b
--- /dev/null
+++ b/.changeset/mighty-trees-wait.md
@@ -0,0 +1,15 @@
+---
+"@effect/platform": minor
+"@effect/platform-browser": minor
+"@effect/platform-bun": minor
+"@effect/platform-node": minor
+"@effect/platform-node-shared": minor
+---
+
+Swap type parameters in /platform data types
+
+A codemod has been released to make migration easier:
+
+```
+npx @effect/codemod platform-0.49 src/**/*
+```
diff --git a/packages/platform-node/src/Http/Server.ts b/packages/platform-node/src/Http/Server.ts
index 0d94c7f74a..c42e6381fd 100644
--- a/packages/platform-node/src/Http/Server.ts
+++ b/packages/platform-node/src/Http/Server.ts
@@ -38,15 +38,15 @@ export const make: (
  */
 export const makeHandler: {
   <R, E>(
-    httpApp: App.Default<R, E>
+    httpApp: App.Default<E, R>
   ): Effect.Effect<
     (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse<Http.IncomingMessage>) => void,
     never,
     Exclude<R, Scope.Scope | 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<
     (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse<Http.IncomingMessage>) => void,
     never,
diff --git a/packages/platform-node/src/internal/http/server.ts b/packages/platform-node/src/internal/http/server.ts
index 99a55ac86a..f3ee962bb9 100644
--- a/packages/platform-node/src/internal/http/server.ts
+++ b/packages/platform-node/src/internal/http/server.ts
@@ -114,20 +114,20 @@ export const make = (
 
 /** @internal */
 export const makeHandler: {
-  <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
+  <R, E>(httpApp: App.Default<E, R>): Effect.Effect<
     (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => 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<
     (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void,
     never,
     Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   >
-} = <R, E>(httpApp: App.Default<R, E>, middleware?: Middleware.Middleware) => {
+} = <E, R>(httpApp: App.Default<E, R>, middleware?: Middleware.Middleware) => {
   const handledApp = App.toHandled(httpApp, (request, exit) => {
     if (exit._tag === "Success") {
       return Effect.catchAllCause(
@@ -164,7 +164,7 @@ export const makeHandler: {
 /** @internal */
 export const makeUpgradeHandler = <R, E>(
   lazyWss: Effect.Effect<WS.WebSocketServer>,
-  httpApp: App.Default<R, E>,
+  httpApp: App.Default<E, R>,
   middleware?: Middleware.Middleware
 ) => {
   const handledApp = App.toHandled(httpApp, (request, exit) => {
diff --git a/packages/platform/src/Http/App.ts b/packages/platform/src/Http/App.ts
index dadbc66b52..f48da35f07 100644
--- a/packages/platform/src/Http/App.ts
+++ b/packages/platform/src/Http/App.ts
@@ -22,26 +22,28 @@ import * as ServerResponse from "./ServerResponse.js"
  * @since 1.0.0
  * @category models
  */
-export interface HttpApp<R, E, A> extends Effect.Effect<A, E, R | ServerRequest.ServerRequest> {}
+export interface HttpApp<A = ServerResponse.ServerResponse, E = never, R = never>
+  extends Effect.Effect<A, E, R | ServerRequest.ServerRequest>
+{}
 
 /**
  * @since 1.0.0
  * @category models
  */
-export type Default<R, E> = HttpApp<R, E, ServerResponse.ServerResponse>
+export type Default<E = never, R = never> = HttpApp<ServerResponse.ServerResponse, E, R>
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const toHandled = <R, E, _, RH>(
-  self: Default<R, E>,
+export const toHandled = <E, R, _, RH>(
+  self: Default<E, R>,
   handleResponse: (
     request: ServerRequest.ServerRequest,
     exit: Exit.Exit<ServerResponse.ServerResponse, E | ServerError.ResponseError>
   ) => Effect.Effect<_, never, RH>,
   middleware?: Middleware | undefined
-): Default<Exclude<R | RH, Scope.Scope>, E | ServerError.ResponseError> => {
+): Default<E | ServerError.ResponseError, Exclude<R | RH, Scope.Scope>> => {
   const withTracer = internalMiddleware.tracer(self)
   const responded = Effect.withFiberRuntime<
     ServerResponse.ServerResponse,
@@ -110,8 +112,8 @@ export const appendPreResponseHandler: (handler: PreResponseHandler) => Effect.E
  * @category fiber refs
  */
 export const withPreResponseHandler = dual<
-  (handler: PreResponseHandler) => <R, E, A>(self: HttpApp<R, E, A>) => HttpApp<R, E, A>,
-  <R, E, A>(self: HttpApp<R, E, A>, handler: PreResponseHandler) => HttpApp<R, E, A>
+  (handler: PreResponseHandler) => <R, E, A>(self: HttpApp<A, E, R>) => HttpApp<A, E, R>,
+  <R, E, A>(self: HttpApp<A, E, R>, handler: PreResponseHandler) => HttpApp<A, E, R>
 >(2, (self, handler) =>
   Effect.locallyWith(
     self,
@@ -131,23 +133,25 @@ export const withPreResponseHandler = dual<
  */
 export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   const run = Runtime.runFork(runtime)
-  return <E>(self: Default<R | Scope.Scope, E>) => {
+  const resolveSymbol = Symbol()
+  const rejectSymbol = Symbol()
+  return <E>(self: Default<E, R | Scope.Scope>) => {
     const handled = Effect.scoped(toHandled(self, (request, exit) => {
       const webRequest = request.source as Request
       if (Exit.isSuccess(exit)) {
-        ;(request as any)._resolve(ServerResponse.toWeb(exit.value, request.method === "HEAD"))
+        ;(request as any)[resolveSymbol](ServerResponse.toWeb(exit.value, request.method === "HEAD"))
       } else if (Cause.isInterruptedOnly(exit.cause)) {
-        ;(request as any)._resolve(new Response(null, { status: webRequest.signal.aborted ? 499 : 503 }))
+        ;(request as any)[resolveSymbol](new Response(null, { status: webRequest.signal.aborted ? 499 : 503 }))
       } else {
-        ;(request as any)._reject(Cause.pretty(exit.cause))
+        ;(request as any)[rejectSymbol](Cause.pretty(exit.cause))
       }
       return Effect.unit
     }))
     return (request: Request): Promise<Response> =>
       new Promise((resolve, reject) => {
         const req = ServerRequest.fromWeb(request)
-        ;(req as any)._resolve = resolve
-        ;(req as any)._reject = reject
+        ;(req as any)[resolveSymbol] = resolve
+        ;(req as any)[rejectSymbol] = reject
         const fiber = run(
           Effect.provideService(handled, ServerRequest.ServerRequest, req)
         )
@@ -162,7 +166,7 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
  * @since 1.0.0
  * @category conversions
  */
-export const toWebHandler: <E>(self: Default<Scope.Scope, E>) => (request: Request) => Promise<Response> =
+export const toWebHandler: <E>(self: Default<E, Scope.Scope>) => (request: Request) => Promise<Response> =
   toWebHandlerRuntime(Runtime.defaultRuntime)
 
 /**
@@ -170,7 +174,7 @@ export const toWebHandler: <E>(self: Default<Scope.Scope, E>) => (request: Reque
  * @category conversions
  */
 export const toWebHandlerLayer = <R, E, RE>(
-  self: Default<R | Scope.Scope, E>,
+  self: Default<E, R | Scope.Scope>,
   layer: Layer.Layer<R, RE>
 ): {
   readonly close: () => Promise<void>
diff --git a/packages/platform/src/Http/Client.ts b/packages/platform/src/Http/Client.ts
index 360df1bf0c..1374e0a212 100644
--- a/packages/platform/src/Http/Client.ts
+++ b/packages/platform/src/Http/Client.ts
@@ -37,11 +37,11 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Client<R, E, A> extends Pipeable, Inspectable {
+export interface Client<A = ClientResponse.ClientResponse, E = never, R = never> extends Pipeable, Inspectable {
   (request: ClientRequest.ClientRequest): Effect.Effect<A, E, R>
   readonly [TypeId]: TypeId
-  readonly preprocess: Client.Preprocess<R, E>
-  readonly execute: Client.Execute<R, E, A>
+  readonly preprocess: Client.Preprocess<E, R>
+  readonly execute: Client.Execute<A, E, R>
 }
 
 /**
@@ -52,7 +52,7 @@ export declare namespace Client {
    * @since 1.0.0
    * @category models
    */
-  export type Preprocess<R, E> = (
+  export type Preprocess<E, R> = (
     request: ClientRequest.ClientRequest
   ) => Effect.Effect<ClientRequest.ClientRequest, E, R>
 
@@ -60,7 +60,7 @@ export declare namespace Client {
    * @since 1.0.0
    * @category models
    */
-  export type Execute<R, E, A> = (
+  export type Execute<A, E = never, R = never> = (
     request: Effect.Effect<ClientRequest.ClientRequest, E, R>
   ) => Effect.Effect<A, E, R>
 
@@ -68,13 +68,13 @@ export declare namespace Client {
    * @since 1.0.0
    * @category models
    */
-  export type WithResponse<R, E> = Client<R, E, ClientResponse.ClientResponse>
+  export type WithResponse<E = never, R = never> = Client<ClientResponse.ClientResponse, E, R>
 
   /**
    * @since 1.0.0
    * @category models
    */
-  export type Default = WithResponse<Scope.Scope, Error.HttpClientError>
+  export type Default = WithResponse<Error.HttpClientError, Scope.Scope>
 }
 
 /**
@@ -120,8 +120,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<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>
+  <E, R2, E2, A2>(f: (e: E) => Effect.Effect<A2, E2, R2>): <A, R>(self: Client<A, E, R>) => Client<A2 | A, E2, R2 | R>
+  <A, E, R, R2, E2, A2>(self: Client<A, E, R>, f: (e: E) => Effect.Effect<A2, E2, R2>): Client<A | A2, E2, R | R2>
 } = internal.catchAll
 
 /**
@@ -132,12 +132,12 @@ 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<A1, E1, R1>
-  ): <R, A>(self: Client<R, E, A>) => Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
+  ): <A, R>(self: Client<A, E, R>) => Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   <R, E extends { _tag: string }, A, K extends E["_tag"] & string, E1, R1, A1>(
-    self: Client<R, E, A>,
+    self: Client<A, E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client<R | R1, E1 | Exclude<E, { _tag: K }>, A | A1>
+  ): Client<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1>
 } = internal.catchTag
 
 /**
@@ -150,42 +150,42 @@ export const catchTags: {
     Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) | undefined }
   >(
     cases: Cases
-  ): <R, A>(
-    self: Client<R, E, A>
+  ): <A, R>(
+    self: Client<A, E, R>
   ) => Client<
-    | R
+    | A
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : 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],
-    | A
+    | R
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
     }[keyof Cases]
   >
   <
-    R,
-    E extends { _tag: string },
     A,
+    E extends { _tag: string },
+    R,
     Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) | undefined }
   >(
-    self: Client<R, E, A>,
+    self: Client<A, E, R>,
     cases: Cases
   ): Client<
-    | R
+    | A
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : 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],
-    | A
+    | R
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer A, any, any> ? A : never
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
     }[keyof Cases]
   >
 } = internal.catchTags
@@ -198,12 +198,12 @@ export const filterOrElse: {
   <A, R2, E2, B>(
     f: Predicate.Predicate<A>,
     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>,
+  ): <E, R>(self: Client<A, E, R>) => Client<A | B, E2 | E, R2 | R>
+  <A, E, R, R2, E2, B>(
+    self: Client<A, E, R>,
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ): Client<R | R2, E | E2, A | B>
+  ): Client<A | B, E | E2, R | R2>
 } = internal.filterOrElse
 
 /**
@@ -211,8 +211,8 @@ export const filterOrElse: {
  * @category filters
  */
 export const filterOrFail: {
-  <A, E2>(f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): <R, E>(self: Client<R, E, A>) => Client<R, E2 | E, A>
-  <R, E, A, E2>(self: Client<R, E, A>, f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): Client<R, E | E2, A>
+  <A, E2>(f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): <E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R>
+  <A, E, R, E2>(self: Client<A, E, R>, f: Predicate.Predicate<A>, orFailWith: (a: A) => E2): Client<A, E | E2, R>
 } = internal.filterOrFail
 
 /**
@@ -222,29 +222,29 @@ export const filterOrFail: {
 export const filterStatus: {
   (
     f: (status: number) => boolean
-  ): <R, E>(self: Client.WithResponse<R, E>) => Client.WithResponse<R, E | Error.ResponseError>
-  <R, E>(
-    self: Client.WithResponse<R, E>,
+  ): <E, R>(self: Client.WithResponse<E, R>) => Client.WithResponse<E | Error.ResponseError, R>
+  <E, R>(
+    self: Client.WithResponse<E, R>,
     f: (status: number) => boolean
-  ): Client.WithResponse<R, Error.ResponseError | E>
+  ): Client.WithResponse<Error.ResponseError | E, R>
 } = internal.filterStatus
 
 /**
  * @since 1.0.0
  * @category filters
  */
-export const filterStatusOk: <R, E>(
-  self: Client.WithResponse<R, E>
-) => Client.WithResponse<R, Error.ResponseError | E> = internal.filterStatusOk
+export const filterStatusOk: <E, R>(
+  self: Client.WithResponse<E, R>
+) => Client.WithResponse<Error.ResponseError | E, R> = internal.filterStatusOk
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const make: <R, E, A, R2, E2>(
+export const make: <A, E, R, R2, E2>(
   execute: (request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>) => Effect.Effect<A, E, R>,
-  preprocess: Client.Preprocess<R2, E2>
-) => Client<R, E, A> = internal.make
+  preprocess: Client.Preprocess<E2, R2>
+) => Client<A, E, R> = internal.make
 
 /**
  * @since 1.0.0
@@ -262,13 +262,13 @@ export const makeDefault: (
  * @category mapping & sequencing
  */
 export const transform: {
-  <R, E, A, R1, E1, A1>(
+  <A, E, R, 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>,
+  ): (self: Client<A, E, R>) => Client<A1, E | E1, R | R1>
+  <A, E, R, R1, E1, A1>(
+    self: Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
-  ): Client<R | R1, E | E1, A1>
+  ): Client<A1, E | E1, R | R1>
 } = internal.transform
 
 /**
@@ -276,13 +276,13 @@ export const transform: {
  * @category mapping & sequencing
  */
 export const transformResponse: {
-  <R, E, A, R1, E1, A1>(
+  <A, E, R, 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>,
+  ): (self: Client<A, E, R>) => Client<A1, E1, R1>
+  <A, E, R, R1, E1, A1>(
+    self: Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ): Client<R1, E1, A1>
+  ): Client<A1, E1, R1>
 } = internal.transformResponse
 
 /**
@@ -290,8 +290,8 @@ export const transformResponse: {
  * @category mapping & sequencing
  */
 export const map: {
-  <A, B>(f: (a: A) => B): <R, E>(self: Client<R, E, A>) => Client<R, E, B>
-  <R, E, A, B>(self: Client<R, E, A>, f: (a: A) => B): Client<R, E, B>
+  <A, B>(f: (a: A) => B): <E, R>(self: Client<A, E, R>) => Client<B, E, R>
+  <A, E, R, B>(self: Client<A, E, R>, f: (a: A) => B): Client<B, E, R>
 } = internal.map
 
 /**
@@ -299,8 +299,8 @@ export const map: {
  * @category mapping & sequencing
  */
 export const mapEffect: {
-  <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>
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(self: Client<A, E, R>) => Client<B, E2 | E, R2 | R>
+  <A, E, R, R2, E2, B>(self: Client<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Client<B, E | E2, R2 | R>
 } = internal.mapEffect
 
 /**
@@ -310,11 +310,11 @@ export const mapEffect: {
 export const mapEffectScoped: {
   <A, R2, E2, B>(
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ): <R, E>(self: Client<R, E, A>) => Client<Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>, E2 | E, B>
-  <R, E, A, R2, E2, B>(
-    self: Client<R, E, A>,
+  ): <E, R>(self: Client<A, E, R>) => Client<B, E2 | E, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
+  <A, E, R, R2, E2, B>(
+    self: Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ): Client<Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>, E | E2, B>
+  ): Client<B, E | E2, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
 } = internal.mapEffectScoped
 
 /**
@@ -324,8 +324,8 @@ export const mapEffectScoped: {
 export const mapRequest: {
   (
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ): <R, E, A>(self: Client<R, E, A>) => Client<R, E, A>
-  <R, E, A>(self: Client<R, E, A>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<R, E, A>
+  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E, R>
+  <A, E, R>(self: Client<A, E, R>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<A, E, R>
 } = internal.mapRequest
 
 /**
@@ -335,11 +335,11 @@ export const mapRequest: {
 export const mapRequestEffect: {
   <R2, E2>(
     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>,
+  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
+  <A, E, R, R2, E2>(
+    self: Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ): Client<R | R2, E | E2, A>
+  ): Client<A, E | E2, R | R2>
 } = internal.mapRequestEffect
 
 /**
@@ -349,8 +349,8 @@ export const mapRequestEffect: {
 export const mapInputRequest: {
   (
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ): <R, E, A>(self: Client<R, E, A>) => Client<R, E, A>
-  <R, E, A>(self: Client<R, E, A>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<R, E, A>
+  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E, R>
+  <A, E, R>(self: Client<A, E, R>, f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest): Client<A, E, R>
 } = internal.mapInputRequest
 
 /**
@@ -360,11 +360,11 @@ export const mapInputRequest: {
 export const mapInputRequestEffect: {
   <R2, E2>(
     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>,
+  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
+  <A, E, R, R2, E2>(
+    self: Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ): Client<R | R2, E | E2, A>
+  ): Client<A, E | E2, R2 | R>
 } = internal.mapInputRequestEffect
 
 /**
@@ -372,15 +372,15 @@ export const mapInputRequestEffect: {
  * @category error handling
  */
 export const retry: {
-  <R1, E extends E0, E0, B>(policy: Schedule.Schedule<B, E0, R1>): <R, A>(self: Client<R, E, A>) => Client<R1 | R, E, A>
-  <R, E extends E0, E0, A, R1, B>(self: Client<R, E, A>, policy: Schedule.Schedule<B, E0, R1>): Client<R | R1, E, A>
+  <B, E extends E0, E0, R1>(policy: Schedule.Schedule<B, E0, R1>): <A, R>(self: Client<A, E, R>) => Client<A, E, R1 | R>
+  <A, E extends E0, E0, R, R1, B>(self: Client<A, E, R>, policy: Schedule.Schedule<B, E0, R1>): Client<A, E, R1 | R>
 } = internal.retry
 
 /**
  * @since 1.0.0
  * @category resources & finalizers
  */
-export const scoped: <R, E, A>(self: Client<R, E, A>) => Client<Exclude<R, Scope.Scope>, E, A> = internal.scoped
+export const scoped: <A, E, R>(self: Client<A, E, R>) => Client<A, E, Exclude<R, Scope.Scope>> = internal.scoped
 
 /**
  * @since 1.0.0
@@ -390,13 +390,13 @@ export const schemaFunction: {
   <SA, SI, SR>(
     schema: Schema.Schema<SA, SI, SR>,
     options?: ParseOptions | undefined
-  ): <R, E, A>(
-    self: Client<R, E, A>
+  ): <A, E, R>(
+    self: Client<A, E, R>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (a: SA) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
-  <R, E, A, SA, SI, SR>(
-    self: Client<R, E, A>,
+  <A, E, R, SA, SI, SR>(
+    self: Client<A, E, R>,
     schema: Schema.Schema<SA, SI, SR>,
     options?: ParseOptions | undefined
   ): (
@@ -409,8 +409,8 @@ export const schemaFunction: {
  * @category mapping & sequencing
  */
 export const tap: {
-  <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>
+  <A, R2, E2, _>(f: (a: A) => Effect.Effect<_, E2, R2>): <E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
+  <A, E, R, R2, E2, _>(self: Client<A, E, R>, f: (a: A) => Effect.Effect<_, E2, R2>): Client<A, E | E2, R2 | R>
 } = internal.tap
 
 /**
@@ -420,11 +420,11 @@ export const tap: {
 export const tapRequest: {
   <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>,
+  ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
+  <A, E, R, R2, E2, _>(
+    self: Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
-  ): Client<R | R2, E | E2, A>
+  ): Client<A, E | E2, R | R2>
 } = internal.tapRequest
 
 /**
@@ -432,8 +432,8 @@ export const tapRequest: {
  * @category cookies
  */
 export const withCookiesRef: {
-  (ref: Ref<Cookies>): <R, E>(self: Client.WithResponse<R, E>) => Client.WithResponse<R, E>
-  <R, E>(self: Client.WithResponse<R, E>, ref: Ref<Cookies>): Client.WithResponse<R, E>
+  (ref: Ref<Cookies>): <E, R>(self: Client.WithResponse<E, R>) => Client.WithResponse<E, R>
+  <E, R>(self: Client.WithResponse<E, R>, ref: Ref<Cookies>): Client.WithResponse<E, R>
 } = internal.withCookiesRef
 
 /**
diff --git a/packages/platform/src/Http/Middleware.ts b/packages/platform/src/Http/Middleware.ts
index 81623e1aa5..ed2c56d2e8 100644
--- a/packages/platform/src/Http/Middleware.ts
+++ b/packages/platform/src/Http/Middleware.ts
@@ -13,7 +13,7 @@ import type * as ServerRequest from "./ServerRequest.js"
  * @category models
  */
 export interface Middleware {
-  <R, E>(self: App.Default<R, E>): App.Default<any, any>
+  <R, E>(self: App.Default<E, R>): App.Default<any, any>
 }
 
 /**
@@ -23,8 +23,8 @@ export declare namespace Middleware {
   /**
    * @since 1.0.0
    */
-  export interface Applied<R, E, A extends App.Default<any, any>> {
-    (self: App.Default<R, E>): A
+  export interface Applied<A extends App.Default<any, any>, E, R> {
+    (self: App.Default<E, R>): A
   }
 }
 
@@ -38,7 +38,7 @@ export const make: <M extends Middleware>(middleware: M) => M = internal.make
  * @since 1.0.0
  * @category constructors
  */
-export const logger: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.logger
+export const logger: <R, E>(httpApp: App.Default<E, R>) => App.Default<E, R> = internal.logger
 
 /**
  * @since 1.0.0
@@ -78,4 +78,4 @@ export const withTracerDisabledWhen: {
  * @since 1.0.0
  * @category constructors
  */
-export const xForwardedHeaders: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.xForwardedHeaders
+export const xForwardedHeaders: <R, E>(httpApp: App.Default<E, R>) => App.Default<E, R> = internal.xForwardedHeaders
diff --git a/packages/platform/src/Http/Multiplex.ts b/packages/platform/src/Http/Multiplex.ts
index 4bcc8d10a7..8393ac2498 100644
--- a/packages/platform/src/Http/Multiplex.ts
+++ b/packages/platform/src/Http/Multiplex.ts
@@ -24,12 +24,12 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Multiplex<R, E> extends App.Default<R, E | Error.RouteNotFound>, Inspectable {
+export interface Multiplex<E = never, R = never> extends App.Default<E | Error.RouteNotFound, R>, Inspectable {
   readonly [TypeId]: TypeId
   readonly apps: ReadonlyArray<
     readonly [
       predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>,
-      app: App.Default<R, E>
+      app: App.Default<E, R>
     ]
   >
 }
@@ -38,7 +38,7 @@ export interface Multiplex<R, E> extends App.Default<R, E | Error.RouteNotFound>
  * @since 1.0.0
  * @category constructors
  */
-export const empty: Multiplex<never, never> = internal.empty
+export const empty: Multiplex<never> = internal.empty
 
 /**
  * @since 1.0.0
@@ -46,9 +46,9 @@ export const empty: Multiplex<never, never> = internal.empty
  */
 export const make: <R, E>(
   apps: Iterable<
-    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<R, E>]
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
   >
-) => Multiplex<R, E> = internal.make
+) => Multiplex<E, R> = internal.make
 
 /**
  * @since 1.0.0
@@ -57,13 +57,13 @@ export const make: <R, E>(
 export const add: {
   <R2, E2, R3, E3>(
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
-    app: App.Default<R3, E3>
-  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R3 | R, E2 | E3 | E>
+    app: App.Default<E3, R3>
+  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E3 | E, R2 | R3 | R>
   <R, E, R2, E2, R3, E3>(
-    self: Multiplex<R, E>,
+    self: Multiplex<E, R>,
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
-    app: App.Default<R3, E3>
-  ): Multiplex<R | R2 | R3, E | E2 | E3>
+    app: App.Default<E3, R3>
+  ): Multiplex<E | E2 | E3, R | R2 | R3>
 } = internal.add
 
 /**
@@ -74,14 +74,14 @@ export const headerExact: {
   <R2, E2>(
     header: string,
     value: string,
-    app: App.Default<R2, E2>
-  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+    app: App.Default<E2, R2>
+  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
   <R, E, R2, E2>(
-    self: Multiplex<R, E>,
+    self: Multiplex<E, R>,
     header: string,
     value: string,
-    app: App.Default<R2, E2>
-  ): Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ): Multiplex<E | E2, R | R2>
 } = internal.headerExact
 
 /**
@@ -92,14 +92,14 @@ export const headerRegex: {
   <R2, E2>(
     header: string,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+    app: App.Default<E2, R2>
+  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
   <R, E, R2, E2>(
-    self: Multiplex<R, E>,
+    self: Multiplex<E, R>,
     header: string,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ): Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ): Multiplex<E | E2, R | R2>
 } = internal.headerRegex
 
 /**
@@ -110,14 +110,14 @@ export const headerStartsWith: {
   <R2, E2>(
     header: string,
     prefix: string,
-    app: App.Default<R2, E2>
-  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+    app: App.Default<E2, R2>
+  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
   <R, E, R2, E2>(
-    self: Multiplex<R, E>,
+    self: Multiplex<E, R>,
     header: string,
     prefix: string,
-    app: App.Default<R2, E2>
-  ): Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ): Multiplex<E | E2, R | R2>
 } = internal.headerStartsWith
 
 /**
@@ -128,14 +128,14 @@ export const headerEndsWith: {
   <R2, E2>(
     header: string,
     suffix: string,
-    app: App.Default<R2, E2>
-  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+    app: App.Default<E2, R2>
+  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
   <R, E, R2, E2>(
-    self: Multiplex<R, E>,
+    self: Multiplex<E, R>,
     header: string,
     suffix: string,
-    app: App.Default<R2, E2>
-  ): Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ): Multiplex<E | E2, R | R2>
 } = internal.headerEndsWith
 
 /**
@@ -143,8 +143,8 @@ export const headerEndsWith: {
  * @category combinators
  */
 export const hostExact: {
-  <R2, E2>(host: string, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
-  <R, E, R2, E2>(self: Multiplex<R, E>, host: string, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+  <R2, E2>(host: string, app: App.Default<E2, R2>): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <R, E, R2, E2>(self: Multiplex<E, R>, host: string, app: App.Default<E2, R2>): Multiplex<E | E2, R | R2>
 } = internal.hostExact
 
 /**
@@ -152,8 +152,8 @@ export const hostExact: {
  * @category combinators
  */
 export const hostRegex: {
-  <R2, E2>(regex: RegExp, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
-  <R, E, R2, E2>(self: Multiplex<R, E>, regex: RegExp, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+  <R2, E2>(regex: RegExp, app: App.Default<E2, R2>): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <R, E, R2, E2>(self: Multiplex<E, R>, regex: RegExp, app: App.Default<E2, R2>): Multiplex<E | E2, R | R2>
 } = internal.hostRegex
 
 /**
@@ -161,8 +161,8 @@ export const hostRegex: {
  * @category combinators
  */
 export const hostStartsWith: {
-  <R2, E2>(prefix: string, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
-  <R, E, R2, E2>(self: Multiplex<R, E>, prefix: string, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+  <R2, E2>(prefix: string, app: App.Default<E2, R2>): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <R, E, R2, E2>(self: Multiplex<E, R>, prefix: string, app: App.Default<E2, R2>): Multiplex<E | E2, R | R2>
 } = internal.hostStartsWith
 
 /**
@@ -170,6 +170,6 @@ export const hostStartsWith: {
  * @category combinators
  */
 export const hostEndsWith: {
-  <R2, E2>(suffix: string, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
-  <R, E, R2, E2>(self: Multiplex<R, E>, suffix: string, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+  <R2, E2>(suffix: string, app: App.Default<E2, R2>): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <R, E, R2, E2>(self: Multiplex<E, R>, suffix: string, app: App.Default<E2, R2>): Multiplex<E | E2, R | R2>
 } = internal.hostEndsWith
diff --git a/packages/platform/src/Http/Router.ts b/packages/platform/src/Http/Router.ts
index 7613996a54..01728dce05 100644
--- a/packages/platform/src/Http/Router.ts
+++ b/packages/platform/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,7 +80,7 @@ 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
@@ -225,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
@@ -233,7 +235,7 @@ 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
 
 /**
@@ -246,15 +248,15 @@ export const makeRoute: <R, E>(
   handler: Route.Handler<R, E>,
   prefix?: Option.Option<string>,
   uninterruptible?: boolean
-) => Route<Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E> = internal.makeRoute
+) => 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
 
 /**
@@ -262,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
 
@@ -276,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
 
 /**
@@ -287,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
 
@@ -313,21 +315,21 @@ export const mountApp: {
  * @category routing
  */
 export const route: (
-  method: "*" | Method.Method
+  method: Method.Method | "*"
 ) => {
   <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, ServerRequest.ServerRequest | RouteContext | Scope.Scope>>
   <R, E, R1, E1>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     path: PathInput,
-    handler: Route.Handler<R1, E1>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>>
 } = internal.route
 
 /**
@@ -337,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.all
 
 /**
@@ -357,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.get
 
 /**
@@ -377,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.post
 
 /**
@@ -397,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.patch
 
 /**
@@ -417,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.put
 
 /**
@@ -437,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.del
 
 /**
@@ -457,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.head
 
 /**
@@ -477,17 +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>,
+    handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E | E1>
+  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.options
 
 /**
@@ -496,12 +498,12 @@ export const options: {
  */
 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>
+    f: (self: Route.Handler<R, E>) => App.Default<E1, R1>
+  ): (self: Router<E, R>) => Router<E1, Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <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>
+    self: Router<E, R>,
+    f: (self: Route.Handler<R, E>) => App.Default<E1, R1>
+  ): Router<E1, Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.use
 
 /**
@@ -511,11 +513,11 @@ export const use: {
 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>(self: Router<E, R>) => Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R2, E2>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     f: (e: E) => Route.Handler<R2, E2>
-  ): Router<R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E2>
+  ): Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.catchAll
 
 /**
@@ -525,11 +527,11 @@ export const catchAll: {
 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>(self: Router<E, R>) => Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, R2, E2>(
-    self: Router<R, E>,
+    self: Router<E, R>,
     f: (e: Cause.Cause<E>) => Route.Handler<R2, E2>
-  ): Router<R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E2>
+  ): Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.catchAllCause
 
 /**
@@ -541,13 +543,13 @@ export const catchTag: {
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Route.Handler<R1, E1>
   ): <R>(
-    self: Router<R, E>
-  ) => Router<R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, E1 | Exclude<E, { _tag: K }>>
+    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, R1, E1>(
-    self: Router<R, E>,
+    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 }>>
+  ): Router<E1 | Exclude<E, { _tag: K }>, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.catchTag
 
 /**
@@ -563,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,
@@ -584,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
 
@@ -609,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
 
 /**
@@ -626,19 +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
diff --git a/packages/platform/src/Http/Server.ts b/packages/platform/src/Http/Server.ts
index c2995c053b..53fc0dcbe5 100644
--- a/packages/platform/src/Http/Server.ts
+++ b/packages/platform/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
 
diff --git a/packages/platform/src/Worker.ts b/packages/platform/src/Worker.ts
index fdadcf0630..4e0ff5d44c 100644
--- a/packages/platform/src/Worker.ts
+++ b/packages/platform/src/Worker.ts
@@ -72,7 +72,7 @@ export const PlatformWorker: Context.Tag<PlatformWorker, PlatformWorker> = inter
  * @since 1.0.0
  * @category models
  */
-export interface Worker<I, E, O> {
+export interface Worker<I, O, E = never> {
   readonly id: number
   readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
   readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
@@ -141,8 +141,8 @@ export declare namespace Worker {
  * @since 1.0.0
  * @category models
  */
-export interface WorkerPool<I, E, O> {
-  readonly backing: Pool.Pool<Worker<I, E, O>, WorkerError>
+export interface WorkerPool<I, O, E = never> {
+  readonly backing: Pool.Pool<Worker<I, O, E>, WorkerError>
   readonly broadcast: (message: I) => Effect.Effect<void, E | WorkerError>
   readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
   readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
@@ -198,9 +198,9 @@ export type WorkerManagerTypeId = typeof WorkerManagerTypeId
  */
 export interface WorkerManager {
   readonly [WorkerManagerTypeId]: WorkerManagerTypeId
-  readonly spawn: <I, E, O>(
+  readonly spawn: <I, O, E>(
     options: Worker.Options<I>
-  ) => Effect.Effect<Worker<I, E, O>, WorkerError, Scope.Scope | Spawner>
+  ) => Effect.Effect<Worker<I, O, E>, WorkerError, Scope.Scope | Spawner>
 }
 
 /**
@@ -225,16 +225,16 @@ export const layerManager: Layer.Layer<WorkerManager, never, PlatformWorker> = i
  * @since 1.0.0
  * @category constructors
  */
-export const makePool: <I, E, O>(
+export const makePool: <I, O, E>(
   options: WorkerPool.Options<I>
-) => Effect.Effect<WorkerPool<I, E, O>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePool
+) => Effect.Effect<WorkerPool<I, O, E>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePool
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makePoolLayer: <Tag, I, E, O>(
-  tag: Context.Tag<Tag, WorkerPool<I, E, O>>,
+export const makePoolLayer: <Tag, I, O, E>(
+  tag: Context.Tag<Tag, WorkerPool<I, O, E>>,
   options: WorkerPool.Options<I>
 ) => Layer.Layer<Tag, never, WorkerManager | Spawner> = internal.makePoolLayer
 
diff --git a/packages/platform/src/WorkerRunner.ts b/packages/platform/src/WorkerRunner.ts
index abc17d3b1f..d8d7e559f1 100644
--- a/packages/platform/src/WorkerRunner.ts
+++ b/packages/platform/src/WorkerRunner.ts
@@ -74,7 +74,7 @@ export declare namespace Runner {
    * @since 1.0.0
    * @category models
    */
-  export interface Options<I, E, O> {
+  export interface Options<I, O, E> {
     readonly decode?: (
       message: unknown
     ) => Effect.Effect<I, WorkerError>
@@ -96,7 +96,7 @@ export declare namespace Runner {
  */
 export const make: <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: Runner.Options<I, E, O> | undefined
+  options?: Runner.Options<I, O, E> | undefined
 ) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
 
 /**
@@ -105,7 +105,7 @@ export const make: <I, R, E, O>(
  */
 export const layer: <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: Runner.Options<I, E, O> | undefined
+  options?: Runner.Options<I, O, E> | undefined
 ) => Layer.Layer<never, WorkerError, R | PlatformRunner> = internal.layer
 
 /**
diff --git a/packages/platform/src/internal/http/client.ts b/packages/platform/src/internal/http/client.ts
index f06fd5ac6f..4b605422bd 100644
--- a/packages/platform/src/internal/http/client.ts
+++ b/packages/platform/src/internal/http/client.ts
@@ -62,12 +62,12 @@ const clientProto = {
 const isClient = (u: unknown): u is Client.Client<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
 /** @internal */
-export const make = <R, E, A, R2, E2>(
+export const make = <A, E, R, R2, E2>(
   execute: (
     request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => Effect.Effect<A, E, R>,
-  preprocess: Client.Client.Preprocess<R2, E2>
-): Client.Client<R, E, A> => {
+  preprocess: Client.Client.Preprocess<E2, R2>
+): Client.Client<A, E, R> => {
   function client(request: ClientRequest.ClientRequest) {
     return execute(preprocess(request))
   }
@@ -187,19 +187,19 @@ export const layer = Layer.succeed(tag, fetch())
 
 /** @internal */
 export const transform = dual<
-  <R, E, A, R1, E1, A1>(
+  <A, E, R, R1, E1, A1>(
     f: (
       effect: Effect.Effect<A, E, R>,
       request: ClientRequest.ClientRequest
     ) => Effect.Effect<A1, E1, R1>
-  ) => (self: Client.Client<R, E, A>) => Client.Client<R | R1, E | E1, A1>,
-  <R, E, A, R1, E1, A1>(
-    self: Client.Client<R, E, A>,
+  ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E | E1, R | R1>,
+  <A, E, R, R1, E1, A1>(
+    self: Client.Client<A, E, R>,
     f: (
       effect: Effect.Effect<A, E, R>,
       request: ClientRequest.ClientRequest
     ) => Effect.Effect<A1, E1, R1>
-  ) => Client.Client<R | R1, E | E1, A1>
+  ) => Client.Client<A1, E | E1, R | R1>
 >(2, (self, f) =>
   make(
     Effect.flatMap((request) => f(self.execute(Effect.succeed(request)), request)),
@@ -208,13 +208,13 @@ export const transform = dual<
 
 /** @internal */
 export const transformResponse = dual<
-  <R, E, A, R1, E1, A1>(
+  <A, E, R, R1, E1, A1>(
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ) => (self: Client.Client<R, E, A>) => Client.Client<R1, E1, A1>,
-  <R, E, A, R1, E1, A1>(
-    self: Client.Client<R, E, A>,
+  ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E1, R1>,
+  <A, E, R, R1, E1, A1>(
+    self: Client.Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ) => Client.Client<R1, E1, A1>
+  ) => Client.Client<A1, E1, R1>
 >(2, (self, f) => make((request) => f(self.execute(request)), self.preprocess))
 
 /** @internal */
@@ -222,9 +222,9 @@ export const catchTag: {
   <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1, A1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): <R, A>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
+  ): <A, R>(
+    self: Client.Client<A, E, R>
+  ) => Client.Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   <
     R,
     E,
@@ -234,10 +234,10 @@ export const catchTag: {
     E1,
     A1
   >(
-    self: Client.Client<R, E, A>,
+    self: Client.Client<A, E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
+  ): Client.Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
 } = dual(
   3,
   <
@@ -249,10 +249,10 @@ export const catchTag: {
     E1,
     A1
   >(
-    self: Client.Client<R, E, A>,
+    self: Client.Client<A, E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A> => transformResponse(self, Effect.catchTag(tag, f))
+  ): Client.Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
 )
 
 /** @internal */
@@ -276,14 +276,14 @@ export const catchTags: {
         })
   >(
     cases: Cases
-  ): <R, A>(
-    self: Client.Client<R, E, A>
+  ): <A, R>(
+    self: Client.Client<A, E, R>
   ) => Client.Client<
-    | R
+    | A
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<any, any, infer R> ? R
+      ) => Effect.Effect<infer A, any, any> ? A
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -293,18 +293,18 @@ export const catchTags: {
       ) => Effect.Effect<any, infer E, any> ? E
         : never
     }[keyof Cases],
-    | A
+    | R
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<infer A, any, any> ? A
+      ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases]
   >
   <
-    R,
-    E extends { _tag: string },
     A,
+    E extends { _tag: string },
+    R,
     Cases extends
       & {
         [K in Extract<E, { _tag: string }>["_tag"]]+?: (
@@ -321,14 +321,14 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.Client<R, E, A>,
+    self: Client.Client<A, E, R>,
     cases: Cases
   ): Client.Client<
-    | R
+    | A
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<any, any, infer R> ? R
+      ) => Effect.Effect<infer A, any, any> ? A
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -338,20 +338,20 @@ export const catchTags: {
       ) => Effect.Effect<any, infer E, any> ? E
         : never
     }[keyof Cases],
-    | A
+    | R
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<infer A, any, any> ? A
+      ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases]
   >
 } = dual(
   2,
   <
-    R,
-    E extends { _tag: string },
     A,
+    E extends { _tag: string },
+    R,
     Cases extends
       & {
         [K in Extract<E, { _tag: string }>["_tag"]]+?: (
@@ -368,14 +368,14 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.Client<R, E, A>,
+    self: Client.Client<A, E, R>,
     cases: Cases
   ): Client.Client<
-    | R
+    | A
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<any, any, infer R> ? R
+      ) => Effect.Effect<infer A, any, any> ? A
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -385,11 +385,11 @@ export const catchTags: {
       ) => Effect.Effect<any, infer E, any> ? E
         : never
     }[keyof Cases],
-    | A
+    | R
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<infer A, any, any> ? A
+      ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases]
   > => transformResponse(self, Effect.catchTags(cases))
@@ -399,17 +399,17 @@ export const catchTags: {
 export const catchAll: {
   <E, R2, E2, A2>(
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): <R, A>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E2, A2 | A>
-  <R, E, A, R2, E2, A2>(
-    self: Client.Client<R, E, A>,
+  ): <A, R>(self: Client.Client<A, E, R>) => Client.Client<A2 | A, E2, R | R2>
+  <A, E, R, R2, E2, A2>(
+    self: Client.Client<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Client.Client<R | R2, E2, A2 | A>
+  ): Client.Client<A2 | A, E2, R | R2>
 } = dual(
   2,
-  <R, E, A, R2, E2, A2>(
-    self: Client.Client<R, E, A>,
+  <A, E, R, R2, E2, A2>(
+    self: Client.Client<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Client.Client<R | R2, E2, A2 | A> => transformResponse(self, Effect.catchAll(f))
+  ): Client.Client<A2 | A, E2, R | R2> => transformResponse(self, Effect.catchAll(f))
 )
 
 /** @internal */
@@ -417,14 +417,14 @@ export const filterOrElse = dual<
   <A, R2, E2, B>(
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <R, E>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R2 | R, E2 | E, A | B>,
-  <R, E, A, R2, E2, B>(
-    self: Client.Client<R, E, A>,
+  ) => <E, R>(
+    self: Client.Client<A, E, R>
+  ) => Client.Client<A | B, E2 | E, R2 | R>,
+  <A, E, R, R2, E2, B>(
+    self: Client.Client<A, E, R>,
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.Client<R2 | R, E2 | E, A | B>
+  ) => Client.Client<A | B, E2 | E, R2 | R>
 >(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
 
 /** @internal */
@@ -432,25 +432,25 @@ export const filterOrFail = dual<
   <A, E2>(
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R, E2 | E, A>,
-  <R, E, A, E2>(
-    self: Client.Client<R, E, A>,
+  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E2 | E, R>,
+  <A, E, R, E2>(
+    self: Client.Client<A, E, R>,
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ) => Client.Client<R, E2 | E, A>
+  ) => Client.Client<A, E2 | E, R>
 >(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)))
 
 /** @internal */
 export const filterStatus = dual<
   (
     f: (status: number) => boolean
-  ) => <R, E>(
-    self: Client.Client.WithResponse<R, E>
-  ) => Client.Client.WithResponse<R, E | Error.ResponseError>,
-  <R, E>(
-    self: Client.Client.WithResponse<R, E>,
+  ) => <E, R>(
+    self: Client.Client.WithResponse<E, R>
+  ) => Client.Client.WithResponse<E | Error.ResponseError, R>,
+  <E, R>(
+    self: Client.Client.WithResponse<E, R>,
     f: (status: number) => boolean
-  ) => Client.Client.WithResponse<R, E | Error.ResponseError>
+  ) => Client.Client.WithResponse<E | Error.ResponseError, R>
 >(2, (self, f) =>
   transform(self, (effect, request) =>
     Effect.filterOrFail(
@@ -466,9 +466,9 @@ export const filterStatus = dual<
     )))
 
 /** @internal */
-export const filterStatusOk: <R, E>(
-  self: Client.Client.WithResponse<R, E>
-) => Client.Client.WithResponse<R, E | Error.ResponseError> = filterStatus(
+export const filterStatusOk: <E, R>(
+  self: Client.Client.WithResponse<E, R>
+) => Client.Client.WithResponse<E | Error.ResponseError, R> = filterStatus(
   (status) => status >= 200 && status < 300
 )
 
@@ -476,49 +476,49 @@ export const filterStatusOk: <R, E>(
 export const map = dual<
   <A, B>(
     f: (a: A) => B
-  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R, E, B>,
-  <R, E, A, B>(
-    self: Client.Client<R, E, A>,
+  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E, R>,
+  <A, E, R, B>(
+    self: Client.Client<A, E, R>,
     f: (a: A) => B
-  ) => Client.Client<R, E, B>
+  ) => Client.Client<B, E, R>
 >(2, (self, f) => transformResponse(self, Effect.map(f)))
 
 /** @internal */
 export const mapEffect = dual<
   <A, R2, E2, B>(
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E | E2, B>,
-  <R, E, A, R2, E2, B>(
-    self: Client.Client<R, E, A>,
+  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, R | R2>,
+  <A, E, R, R2, E2, B>(
+    self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.Client<R | R2, E | E2, B>
+  ) => Client.Client<B, E | E2, R | R2>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(f)))
 
 /** @internal */
-export const scoped = <R, E, A>(
-  self: Client.Client<R, E, A>
-): Client.Client<Exclude<R, Scope.Scope>, E, A> => transformResponse(self, Effect.scoped)
+export const scoped = <A, E, R>(
+  self: Client.Client<A, E, R>
+): Client.Client<A, E, Exclude<R, Scope.Scope>> => transformResponse(self, Effect.scoped)
 
 /** @internal */
 export const mapEffectScoped = dual<
   <A, R2, E2, B>(
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<Exclude<R | R2, Scope.Scope>, E | E2, B>,
-  <R, E, A, R2, E2, B>(
-    self: Client.Client<R, E, A>,
+  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>,
+  <A, E, R, R2, E2, B>(
+    self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.Client<Exclude<R | R2, Scope.Scope>, E | E2, B>
+  ) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>
 >(2, (self, f) => scoped(mapEffect(self, f)))
 
 /** @internal */
 export const mapRequest = dual<
   (
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => <R, E, A>(self: Client.Client<R, E, A>) => Client.Client<R, E, A>,
-  <R, E, A>(
-    self: Client.Client<R, E, A>,
+  ) => <A, E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E, R>,
+  <A, E, R>(
+    self: Client.Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => Client.Client<R, E, A>
+  ) => Client.Client<A, E, R>
 >(2, (self, f) => make(self.execute, (request) => Effect.map(self.preprocess(request), f)))
 
 /** @internal */
@@ -527,26 +527,26 @@ export const mapRequestEffect = dual<
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ) => <R, E, A>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R | R2, E | E2, A>,
-  <R, E, A, R2, E2>(
-    self: Client.Client<R, E, A>,
+  ) => <A, E, R>(
+    self: Client.Client<A, E, R>
+  ) => Client.Client<A, E | E2, R | R2>,
+  <A, E, R, R2, E2>(
+    self: Client.Client<A, E, R>,
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ) => Client.Client<R | R2, E | E2, A>
+  ) => Client.Client<A, E | E2, R | R2>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(self.preprocess(request), f)))
 
 /** @internal */
 export const mapInputRequest = dual<
   (
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => <R, E, A>(self: Client.Client<R, E, A>) => Client.Client<R, E, A>,
-  <R, E, A>(
-    self: Client.Client<R, E, A>,
+  ) => <A, E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E, R>,
+  <A, E, R>(
+    self: Client.Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => Client.Client<R, E, A>
+  ) => Client.Client<A, E, R>
 >(2, (self, f) => make(self.execute, (request) => self.preprocess(f(request))))
 
 /** @internal */
@@ -555,32 +555,32 @@ export const mapInputRequestEffect = dual<
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ) => <R, E, A>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R | R2, E | E2, A>,
-  <R, E, A, R2, E2>(
-    self: Client.Client<R, E, A>,
+  ) => <A, E, R>(
+    self: Client.Client<A, E, R>
+  ) => Client.Client<A, E | E2, R | R2>,
+  <A, E, R, R2, E2>(
+    self: Client.Client<A, E, R>,
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ) => Client.Client<R | R2, E | E2, A>
+  ) => Client.Client<A, E | E2, R | R2>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(f(request), self.preprocess)))
 
 /** @internal */
 export const retry: {
   <R1, E extends E0, E0, B>(
     policy: Schedule.Schedule<B, E0, R1>
-  ): <R, A>(self: Client.Client<R, E, A>) => Client.Client<R1 | R, E, A>
-  <R, E extends E0, E0, A, R1, B>(
-    self: Client.Client<R, E, A>,
+  ): <A, R>(self: Client.Client<A, E, R>) => Client.Client<A, E, R1 | R>
+  <A, E extends E0, E0, R, R1, B>(
+    self: Client.Client<A, E, R>,
     policy: Schedule.Schedule<B, E0, R1>
-  ): Client.Client<R | R1, E, A>
+  ): Client.Client<A, E, R | R1>
 } = dual(
   2,
-  <R, E extends E0, E0, A, R1, B>(
-    self: Client.Client<R, E, A>,
+  <A, E extends E0, E0, R, R1, B>(
+    self: Client.Client<A, E, R>,
     policy: Schedule.Schedule<B, E0, R1>
-  ): Client.Client<R | R1, E, A> => transformResponse(self, Effect.retry(policy))
+  ): Client.Client<A, E, R | R1> => transformResponse(self, Effect.retry(policy))
 )
 
 /** @internal */
@@ -588,15 +588,15 @@ export const schemaFunction = dual<
   <SA, SI, SR>(
     schema: Schema.Schema<SA, SI, SR>,
     options?: ParseOptions | undefined
-  ) => <R, E, A>(
-    self: Client.Client<R, E, A>
+  ) => <A, E, R>(
+    self: Client.Client<A, E, R>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
   ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
-  <R, E, A, SA, SI, SR>(
-    self: Client.Client<R, E, A>,
+  <A, E, R, SA, SI, SR>(
+    self: Client.Client<A, E, R>,
     schema: Schema.Schema<SA, SI, SR>,
     options?: ParseOptions | undefined
   ) => (
@@ -631,41 +631,41 @@ export const schemaFunction = dual<
 export const tap = dual<
   <A, R2, E2, _>(
     f: (a: A) => Effect.Effect<_, E2, R2>
-  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E | E2, A>,
-  <R, E, A, R2, E2, _>(
-    self: Client.Client<R, E, A>,
+  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E | E2, R | R2>,
+  <A, E, R, R2, E2, _>(
+    self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<_, E2, R2>
-  ) => Client.Client<R | R2, E | E2, A>
+  ) => Client.Client<A, E | E2, R | R2>
 >(2, (self, f) => transformResponse(self, Effect.tap(f)))
 
 /** @internal */
 export const tapRequest = dual<
   <R2, E2, _>(
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
-  ) => <R, E, A>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R | R2, E | E2, A>,
-  <R, E, A, R2, E2, _>(
-    self: Client.Client<R, E, A>,
+  ) => <A, E, R>(
+    self: Client.Client<A, E, R>
+  ) => Client.Client<A, E | E2, R | R2>,
+  <A, E, R, R2, E2, _>(
+    self: Client.Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
-  ) => Client.Client<R | R2, E | E2, A>
+  ) => Client.Client<A, E | E2, R | R2>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.tap(self.preprocess(request), f)))
 
 /** @internal */
 export const withCookiesRef = dual<
   (
     ref: Ref.Ref<Cookies.Cookies>
-  ) => <R, E>(self: Client.Client.WithResponse<R, E>) => Client.Client.WithResponse<R, E>,
-  <R, E>(
-    self: Client.Client.WithResponse<R, E>,
+  ) => <E, R>(self: Client.Client.WithResponse<E, R>) => Client.Client.WithResponse<E, R>,
+  <E, R>(
+    self: Client.Client.WithResponse<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ) => Client.Client.WithResponse<R, E>
+  ) => Client.Client.WithResponse<E, R>
 >(
   2,
-  <R, E>(
-    self: Client.Client.WithResponse<R, E>,
+  <E, R>(
+    self: Client.Client.WithResponse<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ): Client.Client.WithResponse<R, E> =>
+  ): Client.Client.WithResponse<E, R> =>
     make(
       (request: Effect.Effect<ClientRequest.ClientRequest, E, R>) =>
         Effect.tap(
diff --git a/packages/platform/src/internal/http/multiplex.ts b/packages/platform/src/internal/http/multiplex.ts
index 24853759b1..b318870efd 100644
--- a/packages/platform/src/internal/http/multiplex.ts
+++ b/packages/platform/src/internal/http/multiplex.ts
@@ -12,9 +12,9 @@ import type * as ServerResponse from "../../Http/ServerResponse.js"
 /** @internal */
 export const TypeId: Multiplex.TypeId = Symbol.for("@effect/platform/Http/Multiplex") as Multiplex.TypeId
 
-class MultiplexImpl<R, E>
+class MultiplexImpl<E = never, R = never>
   extends Effectable.Class<ServerResponse.ServerResponse, E | Error.RouteNotFound, R | ServerRequest.ServerRequest>
-  implements Multiplex.Multiplex<R, E>
+  implements Multiplex.Multiplex<E, R>
 {
   readonly [TypeId]: Multiplex.TypeId
 
@@ -22,14 +22,14 @@ class MultiplexImpl<R, E>
     readonly apps: ReadonlyArray<
       readonly [
         predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>,
-        app: App.Default<R, E>
+        app: App.Default<E, R>
       ]
     >
   ) {
     super()
     this[TypeId] = TypeId
 
-    let execute: (request: ServerRequest.ServerRequest) => App.Default<R, E | Error.RouteNotFound> = (request) =>
+    let execute: (request: ServerRequest.ServerRequest) => App.Default<E | Error.RouteNotFound, R> = (request) =>
       Effect.fail(new Error.RouteNotFound({ request }))
 
     for (let i = apps.length - 1; i >= 0; i--) {
@@ -45,7 +45,7 @@ class MultiplexImpl<R, E>
     this.execute = Effect.flatMap(ServerRequest.ServerRequest, execute)
   }
 
-  execute: App.Default<R, E | Error.RouteNotFound>
+  execute: App.Default<E | Error.RouteNotFound, R>
 
   commit() {
     return this.execute
@@ -65,26 +65,26 @@ class MultiplexImpl<R, E>
 }
 
 /** @internal */
-export const empty: Multiplex.Multiplex<never, never> = new MultiplexImpl([])
+export const empty: Multiplex.Multiplex<never> = new MultiplexImpl([])
 
 /** @internal */
 export const make = <R, E>(
   apps: Iterable<
-    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<R, E>]
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
   >
-): Multiplex.Multiplex<R, E> => new MultiplexImpl(ReadonlyArray.fromIterable(apps))
+): Multiplex.Multiplex<E, R> => new MultiplexImpl(ReadonlyArray.fromIterable(apps))
 
 /** @internal */
 export const add = dual<
   <R2, E2, R3, E3>(
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
-    app: App.Default<R3, E3>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>,
+    app: App.Default<E3, R3>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>,
   <R, E, R2, E2, R3, E3>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
-    app: App.Default<R3, E3>
-  ) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>
+    app: App.Default<E3, R3>
+  ) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>
 >(
   3,
   (self, predicate, app) =>
@@ -99,14 +99,14 @@ export const headerExact = dual<
   <R2, E2>(
     header: string,
     value: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     value: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, value, app) =>
@@ -121,14 +121,14 @@ export const headerRegex = dual<
   <R2, E2>(
     header: string,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, regex, app) =>
@@ -143,14 +143,14 @@ export const headerStartsWith = dual<
   <R2, E2>(
     header: string,
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, prefix, app) =>
@@ -165,14 +165,14 @@ export const headerEndsWith = dual<
   <R2, E2>(
     header: string,
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     header: string,
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(
   4,
   (self, header, suffix, app) =>
@@ -186,50 +186,50 @@ export const headerEndsWith = dual<
 export const hostRegex = dual<
   <R2, E2>(
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     regex: RegExp,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, regex, app) => headerRegex(self, "host", regex, app))
 
 /** @internal */
 export const hostStartsWith = dual<
   <R2, E2>(
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     prefix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, prefix, app) => headerStartsWith(self, "host", prefix, app))
 
 /** @internal */
 export const hostEndsWith = dual<
   <R2, E2>(
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     suffix: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, suffix, app) => headerEndsWith(self, "host", suffix, app))
 
 /** @internal */
 export const hostExact = dual<
   <R2, E2>(
     host: string,
-    app: App.Default<R2, E2>
-  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+    app: App.Default<E2, R2>
+  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
   <R, E, R2, E2>(
-    self: Multiplex.Multiplex<R, E>,
+    self: Multiplex.Multiplex<E, R>,
     host: string,
-    app: App.Default<R2, E2>
-  ) => Multiplex.Multiplex<R | R2, E | E2>
+    app: App.Default<E2, R2>
+  ) => Multiplex.Multiplex<E | E2, R | R2>
 >(3, (self, host, app) => headerExact(self, "host", host, app))
diff --git a/packages/platform/src/internal/http/router.ts b/packages/platform/src/internal/http/router.ts
index 2104e4eaf8..fea4ee162a 100644
--- a/packages/platform/src/internal/http/router.ts
+++ b/packages/platform/src/internal/http/router.ts
@@ -131,18 +131,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 +176,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 +220,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,7 +259,7 @@ 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 | "*",
@@ -293,14 +293,14 @@ 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 */
@@ -310,13 +310,19 @@ export const makeRoute = <R, E>(
   handler: Router.Route.Handler<R, E>,
   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 +331,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 +358,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 +374,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 +406,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>>
+  >(3, (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
     ))
 
@@ -464,12 +479,12 @@ 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>,
+    f: (self: Router.Route.Handler<R, E>) => App.Default<E1, R1>
+  ) => (self: Router.Router<E, R>) => Router.Router<E1, Router.Router.ExcludeProvided<R1>>,
   <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>
+    self: Router.Router<E, R>,
+    f: (self: Router.Route.Handler<R, E>) => App.Default<E1, R1>
+  ) => Router.Router<E1, Router.Router.ExcludeProvided<R1>>
 >(2, (self, f) =>
   new RouterImpl<any, any>(
     Chunk.map(
@@ -486,22 +501,22 @@ export const use = dual<
 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>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
   <R, E, R2, E2>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     f: (e: E) => Router.Route.Handler<R2, E2>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>
+  ) => 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>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
   <R, E, R2, E2>(
-    self: Router.Router<R, E>,
+    self: Router.Router<E, R>,
     f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>
+  ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
 >(2, (self, f) => use(self, Effect.catchAllCause(f)))
 
 /** @internal */
@@ -510,13 +525,13 @@ export const catchTag = dual<
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
   ) => <R>(
-    self: Router.Router<R, E>
-  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, Exclude<E, { _tag: K }> | E1>,
+    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), R1, E1>(
-    self: Router.Router<R, E>,
+    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>
+  ) => 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 +544,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 +564,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 +585,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 +604,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)
diff --git a/packages/platform/src/internal/http/server.ts b/packages/platform/src/internal/http/server.ts
index 0d3d2b2d77..756f927ee6 100644
--- a/packages/platform/src/internal/http/server.ts
+++ b/packages/platform/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,
diff --git a/packages/platform/src/internal/worker.ts b/packages/platform/src/internal/worker.ts
index 9db47f79fe..00d51dd69f 100644
--- a/packages/platform/src/internal/worker.ts
+++ b/packages/platform/src/internal/worker.ts
@@ -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,
@@ -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))
 
diff --git a/packages/platform/src/internal/workerRunner.ts b/packages/platform/src/internal/workerRunner.ts
index e3fdd8c281..e6c898d1d2 100644
--- a/packages/platform/src/internal/workerRunner.ts
+++ b/packages/platform/src/internal/workerRunner.ts
@@ -32,7 +32,7 @@ export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>(
 /** @internal */
 export const make = <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: WorkerRunner.Runner.Options<I, E, O>
+  options?: WorkerRunner.Runner.Options<I, O, E>
 ) =>
   Effect.gen(function*(_) {
     const scope = yield* _(Scope.fork(yield* _(Effect.scope), ExecutionStrategy.parallel))
@@ -170,7 +170,7 @@ export const make = <I, R, E, O>(
 /** @internal */
 export const layer = <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: WorkerRunner.Runner.Options<I, E, O>
+  options?: WorkerRunner.Runner.Options<I, O, E>
 ): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> => Layer.scopedDiscard(make(process, options))
 
 /** @internal */
diff --git a/packages/rpc-http/src/HttpRouter.ts b/packages/rpc-http/src/HttpRouter.ts
index 11bceed470..af3e00f778 100644
--- a/packages/rpc-http/src/HttpRouter.ts
+++ b/packages/rpc-http/src/HttpRouter.ts
@@ -17,8 +17,8 @@ import * as Stream from "effect/Stream"
  * @category conversions
  */
 export const toHttpApp = <R extends Router.Router<any, any>>(self: R): App.Default<
-  Router.Router.Context<R>,
-  ServerError.RequestError
+  ServerError.RequestError,
+  Router.Router.Context<R>
 > => {
   const handler = Router.toHandler(self)
   return Effect.withFiberRuntime((fiber) => {