diff --git a/.changeset/nice-falcons-search.md b/.changeset/nice-falcons-search.md
new file mode 100644
index 0000000000..b3533010e1
--- /dev/null
+++ b/.changeset/nice-falcons-search.md
@@ -0,0 +1,5 @@
+---
+"@effect/platform": patch
+---
+
+Update the definition of `Handler` to utilize `App.Default`
diff --git a/packages/platform/src/Http/App.ts b/packages/platform/src/Http/App.ts
index aff69c91ca..b676fdd6da 100644
--- a/packages/platform/src/Http/App.ts
+++ b/packages/platform/src/Http/App.ts
@@ -112,8 +112,8 @@ export const appendPreResponseHandler: (handler: PreResponseHandler) => Effect.E
  * @category fiber refs
  */
 export const withPreResponseHandler = dual<
-  (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>
+  (handler: PreResponseHandler) => <A, E, R>(self: HttpApp<A, E, R>) => HttpApp<A, E, R>,
+  <A, E, R>(self: HttpApp<A, E, R>, handler: PreResponseHandler) => HttpApp<A, E, R>
 >(2, (self, handler) =>
   Effect.locallyWith(
     self,
@@ -171,7 +171,7 @@ export const toWebHandler: <E>(self: Default<E, Scope.Scope>) => (request: Reque
  * @since 1.0.0
  * @category conversions
  */
-export const toWebHandlerLayer = <R, E, RE>(
+export const toWebHandlerLayer = <E, R, RE>(
   self: Default<E, R | Scope.Scope>,
   layer: Layer.Layer<R, RE>
 ): {
diff --git a/packages/platform/src/Http/Client.ts b/packages/platform/src/Http/Client.ts
index 18f04fcff3..b652f13cbb 100644
--- a/packages/platform/src/Http/Client.ts
+++ b/packages/platform/src/Http/Client.ts
@@ -120,8 +120,8 @@ export const fetchOk: Client.Default = internal.fetchOk
  * @category error handling
  */
 export const catchAll: {
-  <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>
+  <E, E2, R2, 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, A2, E2, R2>(self: Client<A, E, R>, f: (e: E) => Effect.Effect<A2, E2, R2>): Client<A | A2, E2, R | R2>
 } = internal.catchAll
 
 /**
@@ -129,11 +129,11 @@ export const catchAll: {
  * @category error handling
  */
 export const catchTag: {
-  <E extends { _tag: string }, K extends E["_tag"] & string, R1, E1, A1>(
+  <E extends { _tag: string }, K extends E["_tag"] & string, A1, E1, R1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): <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>(
+  <R, E extends { _tag: string }, A, K extends E["_tag"] & string, A1, E1, R1>(
     self: Client<A, E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
@@ -195,11 +195,11 @@ export const catchTags: {
  * @category filters
  */
 export const filterOrElse: {
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
   ): <E, R>(self: Client<A, E, R>) => Client<A | B, E2 | E, R2 | R>
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client<A, E, R>,
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
@@ -241,7 +241,7 @@ export const filterStatusOk: <E, R>(
  * @since 1.0.0
  * @category constructors
  */
-export const make: <A, E, R, R2, E2>(
+export const make: <A, E, R, E2, R2>(
   execute: (request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>) => Effect.Effect<A, E, R>,
   preprocess: Client.Preprocess<E2, R2>
 ) => Client<A, E, R> = internal.make
@@ -264,10 +264,10 @@ export const makeDefault: (
  * @category mapping & sequencing
  */
 export const transform: {
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
   ): (self: Client<A, E, R>) => Client<A1, E | E1, R | R1>
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>, request: ClientRequest.ClientRequest) => Effect.Effect<A1, E1, R1>
   ): Client<A1, E | E1, R | R1>
@@ -278,10 +278,10 @@ export const transform: {
  * @category mapping & sequencing
  */
 export const transformResponse: {
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ): (self: Client<A, E, R>) => Client<A1, E1, R1>
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ): Client<A1, E1, R1>
@@ -301,8 +301,8 @@ export const map: {
  * @category mapping & sequencing
  */
 export const mapEffect: {
-  <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>
+  <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(self: Client<A, E, R>) => Client<B, E2 | E, R2 | R>
+  <A, E, R, B, E2, R2>(self: Client<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Client<B, E | E2, R2 | R>
 } = internal.mapEffect
 
 /**
@@ -310,10 +310,10 @@ export const mapEffect: {
  * @category mapping & sequencing
  */
 export const mapEffectScoped: {
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
   ): <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>(
+  <A, E, R, B, E2, R2>(
     self: Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
   ): Client<B, E | E2, Exclude<R2, Scope.Scope> | Exclude<R, Scope.Scope>>
@@ -335,10 +335,10 @@ export const mapRequest: {
  * @category mapping & sequencing
  */
 export const mapRequestEffect: {
-  <R2, E2>(
+  <E2, R2>(
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
-  <A, E, R, R2, E2>(
+  <A, E, R, E2, R2>(
     self: Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): Client<A, E | E2, R | R2>
@@ -360,10 +360,10 @@ export const mapInputRequest: {
  * @category mapping & sequencing
  */
 export const mapInputRequestEffect: {
-  <R2, E2>(
+  <E2, R2>(
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
-  <A, E, R, R2, E2>(
+  <A, E, R, E2, R2>(
     self: Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ): Client<A, E | E2, R2 | R>
@@ -411,8 +411,8 @@ export const schemaFunction: {
  * @category mapping & sequencing
  */
 export const tap: {
-  <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>
+  <A, _, E2, R2>(f: (a: A) => Effect.Effect<_, E2, R2>): <E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(self: Client<A, E, R>, f: (a: A) => Effect.Effect<_, E2, R2>): Client<A, E | E2, R2 | R>
 } = internal.tap
 
 /**
@@ -420,10 +420,10 @@ export const tap: {
  * @category mapping & sequencing
  */
 export const tapRequest: {
-  <R2, E2, _>(
+  <_, E2, R2>(
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ): <A, E, R>(self: Client<A, E, R>) => Client<A, E2 | E, R2 | R>
-  <A, E, R, R2, E2, _>(
+  <A, E, R, _, E2, R2>(
     self: Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ): Client<A, E | E2, R | R2>
@@ -452,8 +452,8 @@ export const currentTracerDisabledWhen: FiberRef.FiberRef<Predicate.Predicate<Cl
 export const withTracerDisabledWhen: {
   (
     predicate: Predicate.Predicate<ClientRequest.ClientRequest>
-  ): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(
+  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ClientRequest.ClientRequest>
   ): Effect.Effect<A, E, R>
@@ -470,8 +470,8 @@ export const currentTracerPropagation: FiberRef.FiberRef<boolean> = internal.cur
  * @category fiber refs
  */
 export const withTracerPropagation: {
-  (enabled: boolean): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(effect: Effect.Effect<A, E, R>, enabled: boolean): Effect.Effect<A, E, R>
+  (enabled: boolean): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, enabled: boolean): Effect.Effect<A, E, R>
 } = internal.withTracerPropagation
 
 /**
@@ -485,6 +485,6 @@ export const currentFetchOptions: FiberRef.FiberRef<RequestInit> = internal.curr
  * @category fiber refs
  */
 export const withFetchOptions: {
-  (options: RequestInit): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(effect: Effect.Effect<A, E, R>, options: RequestInit): Effect.Effect<A, E, R>
+  (options: RequestInit): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, options: RequestInit): Effect.Effect<A, E, R>
 } = internal.withFetchOptions
diff --git a/packages/platform/src/Http/IncomingMessage.ts b/packages/platform/src/Http/IncomingMessage.ts
index e0db9e2697..8e7e18e00f 100644
--- a/packages/platform/src/Http/IncomingMessage.ts
+++ b/packages/platform/src/Http/IncomingMessage.ts
@@ -134,8 +134,8 @@ export const maxBodySize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = Gl
  * @category fiber refs
  */
 export const withMaxBodySize = dual<
-  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
+  (size: Option.Option<FileSystem.SizeInput>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxBodySize, Option.map(size, FileSystem.Size)))
 
 /**
diff --git a/packages/platform/src/Http/Middleware.ts b/packages/platform/src/Http/Middleware.ts
index d5979063ef..072aa997e8 100644
--- a/packages/platform/src/Http/Middleware.ts
+++ b/packages/platform/src/Http/Middleware.ts
@@ -14,7 +14,7 @@ import type * as ServerRequest from "./ServerRequest.js"
  * @category models
  */
 export interface Middleware {
-  <R, E>(self: App.Default<E, R>): App.Default<any, any>
+  <E, R>(self: App.Default<E, R>): App.Default<any, any>
 }
 
 /**
@@ -39,7 +39,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<E, R>) => App.Default<E, R> = internal.logger
+export const logger: <E, R>(httpApp: App.Default<E, R>) => App.Default<E, R> = internal.logger
 
 /**
  * @since 1.0.0
@@ -51,7 +51,7 @@ export const loggerDisabled: FiberRef.FiberRef<boolean> = internal.loggerDisable
  * @since 1.0.0
  * @category fiber refs
  */
-export const withLoggerDisabled: <R, E, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
+export const withLoggerDisabled: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
   internal.withLoggerDisabled
 
 /**
@@ -68,8 +68,8 @@ export const currentTracerDisabledWhen: FiberRef.FiberRef<Predicate.Predicate<Se
 export const withTracerDisabledWhen: {
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ): <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
-  <R, E, A>(
+  ): <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  <A, E, R>(
     layer: Layer.Layer<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ): Layer.Layer<A, E, R>
@@ -82,8 +82,8 @@ export const withTracerDisabledWhen: {
 export const withTracerDisabledWhenEffect: {
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(
+  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ): Effect.Effect<A, E, R>
@@ -94,15 +94,15 @@ export const withTracerDisabledWhenEffect: {
  * @category fiber refs
  */
 export const withTracerDisabledForUrls: {
-  (urls: ReadonlyArray<string>): <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
-  <R, E, A>(layer: Layer.Layer<A, E, R>, urls: ReadonlyArray<string>): Layer.Layer<A, E, R>
+  (urls: ReadonlyArray<string>): <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>
+  <A, E, R>(layer: Layer.Layer<A, E, R>, urls: ReadonlyArray<string>): Layer.Layer<A, E, R>
 } = internal.withTracerDisabledForUrls
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const xForwardedHeaders: <R, E>(httpApp: App.Default<E, R>) => App.Default<E, R> = internal.xForwardedHeaders
+export const xForwardedHeaders: <E, R>(httpApp: App.Default<E, R>) => App.Default<E, R> = internal.xForwardedHeaders
 
 /**
  * @since 1.0.0
diff --git a/packages/platform/src/Http/Multipart.ts b/packages/platform/src/Http/Multipart.ts
index fa7244e956..8f999d63bd 100644
--- a/packages/platform/src/Http/Multipart.ts
+++ b/packages/platform/src/Http/Multipart.ts
@@ -162,8 +162,8 @@ export const maxParts: FiberRef.FiberRef<Option.Option<number>> = internal.maxPa
  * @category fiber refs
  */
 export const withMaxParts: {
-  (count: Option.Option<number>): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>): Effect.Effect<A, E, R>
+  (count: Option.Option<number>): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>): Effect.Effect<A, E, R>
 } = internal.withMaxParts
 
 /**
@@ -177,8 +177,8 @@ export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = internal.maxFiel
  * @category fiber refs
  */
 export const withMaxFieldSize: {
-  (size: FileSystem.SizeInput): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput): Effect.Effect<A, E, R>
+  (size: FileSystem.SizeInput): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput): Effect.Effect<A, E, R>
 } = internal.withMaxFieldSize
 
 /**
@@ -192,8 +192,8 @@ export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = in
  * @category fiber refs
  */
 export const withMaxFileSize: {
-  (size: Option.Option<FileSystem.SizeInput>): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>): Effect.Effect<A, E, R>
+  (size: Option.Option<FileSystem.SizeInput>): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>): Effect.Effect<A, E, R>
 } = internal.withMaxFileSize
 
 /**
@@ -207,8 +207,8 @@ export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = internal.f
  * @category fiber refs
  */
 export const withFieldMimeTypes: {
-  (mimeTypes: ReadonlyArray<string>): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <R, E, A>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>): Effect.Effect<A, E, R>
+  (mimeTypes: ReadonlyArray<string>): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>): Effect.Effect<A, E, R>
 } = internal.withFieldMimeTypes
 
 /**
diff --git a/packages/platform/src/Http/Multiplex.ts b/packages/platform/src/Http/Multiplex.ts
index 8393ac2498..ecb08900d6 100644
--- a/packages/platform/src/Http/Multiplex.ts
+++ b/packages/platform/src/Http/Multiplex.ts
@@ -44,7 +44,7 @@ export const empty: Multiplex<never> = internal.empty
  * @since 1.0.0
  * @category constructors
  */
-export const make: <R, E>(
+export const make: <E, R>(
   apps: Iterable<
     readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
   >
@@ -55,11 +55,11 @@ export const make: <R, E>(
  * @category combinators
  */
 export const add: {
-  <R2, E2, R3, E3>(
+  <E2, R2, E3, R3>(
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
-  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E3 | E, R2 | R3 | R>
-  <R, E, R2, E2, R3, E3>(
+  ): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E3 | E, R2 | R3 | R>
+  <E, R, E2, R2, E3, R3>(
     self: Multiplex<E, R>,
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
@@ -71,12 +71,12 @@ export const add: {
  * @category combinators
  */
 export const headerExact: {
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     value: string,
     app: App.Default<E2, R2>
-  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
-  <R, E, R2, E2>(
+  ): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(
     self: Multiplex<E, R>,
     header: string,
     value: string,
@@ -89,12 +89,12 @@ export const headerExact: {
  * @category combinators
  */
 export const headerRegex: {
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     regex: RegExp,
     app: App.Default<E2, R2>
-  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
-  <R, E, R2, E2>(
+  ): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(
     self: Multiplex<E, R>,
     header: string,
     regex: RegExp,
@@ -107,12 +107,12 @@ export const headerRegex: {
  * @category combinators
  */
 export const headerStartsWith: {
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     prefix: string,
     app: App.Default<E2, R2>
-  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
-  <R, E, R2, E2>(
+  ): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(
     self: Multiplex<E, R>,
     header: string,
     prefix: string,
@@ -125,12 +125,12 @@ export const headerStartsWith: {
  * @category combinators
  */
 export const headerEndsWith: {
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     suffix: string,
     app: App.Default<E2, R2>
-  ): <R, E>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
-  <R, E, R2, E2>(
+  ): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(
     self: Multiplex<E, R>,
     header: string,
     suffix: string,
@@ -143,8 +143,8 @@ export const headerEndsWith: {
  * @category combinators
  */
 export const hostExact: {
-  <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>
+  <E2, R2>(host: string, app: App.Default<E2, R2>): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(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<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>
+  <E2, R2>(regex: RegExp, app: App.Default<E2, R2>): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(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<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>
+  <E2, R2>(prefix: string, app: App.Default<E2, R2>): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(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<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>
+  <E2, R2>(suffix: string, app: App.Default<E2, R2>): <E, R>(self: Multiplex<E, R>) => Multiplex<E2 | E, R2 | R>
+  <E, R, E2, R2>(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 950acae424..4f71d983d4 100644
--- a/packages/platform/src/Http/Router.ts
+++ b/packages/platform/src/Http/Router.ts
@@ -16,7 +16,6 @@ import type * as App from "./App.js"
 import type * as Method from "./Method.js"
 import type * as Error from "./ServerError.js"
 import type * as ServerRequest from "./ServerRequest.js"
-import type * as ServerResponse from "./ServerResponse.js"
 
 /**
  * @since 1.0.0
@@ -99,11 +98,7 @@ export declare namespace Route {
   /**
    * @since 1.0.0
    */
-  export type Handler<E, R> = Effect.Effect<
-    ServerResponse.ServerResponse,
-    E,
-    R | RouteContext | ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams
-  >
+  export type Handler<E, R> = App.Default<E, R | RouteContext | ServerRequest.ParsedSearchParams>
 }
 
 /**
@@ -246,8 +241,8 @@ export const makeRoute: <E, R>(
  * @category combinators
  */
 export const prefixAll: {
-  (prefix: PathInput): <R, E>(self: Router<E, R>) => Router<E, R>
-  <R, E>(self: Router<E, R>, prefix: PathInput): Router<E, R>
+  (prefix: PathInput): <E, R>(self: Router<E, R>) => Router<E, R>
+  <E, R>(self: Router<E, R>, prefix: PathInput): Router<E, R>
 } = internal.prefixAll
 
 /**
@@ -255,10 +250,10 @@ export const prefixAll: {
  * @category combinators
  */
 export const concat: {
-  <R1, E1>(that: Router<E1, R1>): <R, E>(
+  <R1, E1>(that: Router<E1, R1>): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R1 | R>
-  <R, E, R1, E1>(self: Router<E, R>, that: Router<E1, R1>): Router<
+  <E, R, R1, E1>(self: Router<E, R>, that: Router<E1, R1>): Router<
     E | E1,
     R | R1
   >
@@ -269,8 +264,8 @@ export const concat: {
  * @category routing
  */
 export const mount: {
-  <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>
+  <R1, E1>(path: `/${string}`, that: Router<E1, R1>): <E, R>(self: Router<E, R>) => Router<E1 | E, R1 | R>
+  <E, R, E1, R1>(self: Router<E, R>, path: `/${string}`, that: Router<E1, R1>): Router<E | E1, R | R1>
 } = internal.mount
 
 /**
@@ -282,14 +277,14 @@ export const mountApp: {
     path: `/${string}`,
     that: App.Default<E1, R1>,
     options?: { readonly includePrefix?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<
     E1 | E,
     | Router.ExcludeProvided<R1>
     | Router.ExcludeProvided<R>
   >
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
@@ -312,10 +307,10 @@ export const route: (
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -332,13 +327,13 @@ export const all: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<
     E1 | E,
     R | Router.ExcludeProvided<R1>
   >
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -358,10 +353,10 @@ export const get: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -378,10 +373,10 @@ export const post: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -398,10 +393,10 @@ export const patch: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -418,10 +413,10 @@ export const put: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -438,10 +433,10 @@ export const del: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -458,10 +453,10 @@ export const head: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -478,10 +473,10 @@ export const options: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -511,7 +506,7 @@ export const catchAll: {
   <E, E2, R2>(
     f: (e: E) => Route.Handler<E2, R2>
   ): <R>(self: Router<E, R>) => Router<E2, R | Router.ExcludeProvided<R2>>
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router<E, R>,
     f: (e: E) => Route.Handler<E2, R2>
   ): Router<E2, R | Router.ExcludeProvided<R2>>
@@ -525,7 +520,7 @@ export const catchAllCause: {
   <E, E2, R2>(
     f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
   ): <R>(self: Router<E, R>) => Router<E2, R | Router.ExcludeProvided<R2>>
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router<E, R>,
     f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
   ): Router<E2, R | Router.ExcludeProvided<R2>>
@@ -542,7 +537,7 @@ export const catchTag: {
   ): <R>(
     self: Router<E, R>
   ) => Router<E1 | Exclude<E, { _tag: K }>, R | Router.ExcludeProvided<R1>>
-  <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
+  <E, R, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
     self: Router<E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
@@ -606,8 +601,8 @@ export const provideService: {
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ): <R, E>(self: Router<E, R>) => Router<E, Exclude<R, Context.Tag.Identifier<T>>>
-  <R, E, T extends Context.Tag<any, any>>(
+  ): <E, R>(self: Router<E, R>) => Router<E, Exclude<R, Context.Tag.Identifier<T>>>
+  <E, R, T extends Context.Tag<any, any>>(
     self: Router<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
@@ -622,14 +617,14 @@ export const provideServiceEffect: {
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<
     E1 | E,
     | Exclude<R, Context.Tag.Identifier<T>>
     | Exclude<Router.ExcludeProvided<R1>, Context.Tag.Identifier<T>>
   >
-  <R, E, T extends Context.Tag<any, any>, R1, E1>(
+  <E, R, T extends Context.Tag<any, any>, R1, E1>(
     self: Router<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
diff --git a/packages/platform/src/Http/Server.ts b/packages/platform/src/Http/Server.ts
index 53fc0dcbe5..c11a5b0407 100644
--- a/packages/platform/src/Http/Server.ts
+++ b/packages/platform/src/Http/Server.ts
@@ -29,12 +29,12 @@ export type TypeId = typeof TypeId
 export interface Server {
   readonly [TypeId]: TypeId
   readonly serve: {
-    <R, E>(httpApp: App.Default<E, R>): Effect.Effect<
+    <E, R>(httpApp: App.Default<E, R>): Effect.Effect<
       void,
       never,
       Exclude<R, ServerRequest.ServerRequest> | Scope.Scope
     >
-    <R, E, App extends App.Default<any, any>>(
+    <E, R, App extends App.Default<any, any>>(
       httpApp: App.Default<E, R>,
       middleware: Middleware.Middleware.Applied<App, E, R>
     ): Effect.Effect<
@@ -104,10 +104,10 @@ export const make: (
  * @category accessors
  */
 export const serve: {
-  (): <R, E>(
+  (): <E, R>(
     httpApp: App.Default<E, R>
   ) => Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): (
     httpApp: App.Default<E, R>
@@ -116,10 +116,10 @@ export const serve: {
     never,
     Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   >
-  <R, E>(
+  <E, R>(
     httpApp: App.Default<E, R>
   ): Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     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>>
@@ -130,10 +130,10 @@ export const serve: {
  * @category accessors
  */
 export const serveEffect: {
-  (): <R, E>(
+  (): <E, R>(
     httpApp: App.Default<E, R>
   ) => Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): (
     httpApp: App.Default<E, R>
@@ -142,10 +142,10 @@ export const serveEffect: {
     never,
     Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>
   >
-  <R, E>(
+  <E, R>(
     httpApp: App.Default<E, R>
   ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     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>>
@@ -161,7 +161,7 @@ export const formatAddress: (address: Address) => string = internal.formatAddres
  * @since 1.0.0
  * @category address
  */
-export const addressWith: <R, E, A>(
+export const addressWith: <A, E, R>(
   effect: (address: Address) => Effect.Effect<A, E, R>
 ) => Effect.Effect<A, E, Server | R> = internal.addressWith
 
@@ -169,7 +169,7 @@ export const addressWith: <R, E, A>(
  * @since 1.0.0
  * @category address
  */
-export const addressFormattedWith: <R, E, A>(
+export const addressFormattedWith: <A, E, R>(
   effect: (address: string) => Effect.Effect<A, E, R>
 ) => Effect.Effect<A, E, Server | R> = internal.addressFormattedWith
 
@@ -183,5 +183,5 @@ export const logAddress: Effect.Effect<void, never, Server> = internal.logAddres
  * @since 1.0.0
  * @category address
  */
-export const withLogAddress: <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<Server, A>> =
+export const withLogAddress: <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<Server, A>> =
   internal.withLogAddress
diff --git a/packages/platform/src/Socket.ts b/packages/platform/src/Socket.ts
index c57d9c99a9..104e0c8385 100644
--- a/packages/platform/src/Socket.ts
+++ b/packages/platform/src/Socket.ts
@@ -46,10 +46,10 @@ export const Socket: Context.Tag<Socket, Socket> = Context.GenericTag<Socket>(
  */
 export interface Socket {
   readonly [TypeId]: TypeId
-  readonly run: <R, E, _>(
+  readonly run: <_, E, R>(
     handler: (_: Uint8Array) => Effect.Effect<_, E, R>
   ) => Effect.Effect<void, SocketError | E, R>
-  readonly runRaw: <R, E, _>(
+  readonly runRaw: <_, E, R>(
     handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>
   ) => Effect.Effect<void, SocketError | E, R>
   readonly writer: Effect.Effect<
@@ -337,7 +337,7 @@ export const fromWebSocket = <R>(
     ))
     const acquireContext = yield* Effect.context<Exclude<R, Scope.Scope>>()
 
-    const runRaw = <R, E, _>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
+    const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
       Effect.gen(function*(_) {
         const scope = yield* Effect.scope
         const ws = yield* (acquire.pipe(
@@ -433,7 +433,7 @@ export const fromWebSocket = <R>(
       )
 
     const encoder = new TextEncoder()
-    const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+    const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
       runRaw((data) =>
         typeof data === "string"
           ? handler(encoder.encode(data))
diff --git a/packages/platform/src/WorkerRunner.ts b/packages/platform/src/WorkerRunner.ts
index 27dee428e5..8d38a160bb 100644
--- a/packages/platform/src/WorkerRunner.ts
+++ b/packages/platform/src/WorkerRunner.ts
@@ -95,7 +95,7 @@ export declare namespace Runner {
  * @since 1.0.0
  * @category constructors
  */
-export const make: <I, R, E, O>(
+export const make: <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: Runner.Options<I, O, E> | undefined
 ) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
@@ -104,7 +104,7 @@ export const make: <I, R, E, O>(
  * @since 1.0.0
  * @category layers
  */
-export const layer: <I, R, E, O>(
+export const layer: <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   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 b92311c448..4a7a85238f 100644
--- a/packages/platform/src/internal/http/client.ts
+++ b/packages/platform/src/internal/http/client.ts
@@ -45,8 +45,8 @@ export const currentTracerDisabledWhen = globalValue(
 export const withTracerDisabledWhen = dual<
   (
     predicate: Predicate.Predicate<ClientRequest.ClientRequest>
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ClientRequest.ClientRequest>
   ) => Effect.Effect<A, E, R>
@@ -62,8 +62,8 @@ export const currentTracerPropagation = globalValue(
 export const withTracerPropagation = dual<
   (
     enabled: boolean
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     enabled: boolean
   ) => Effect.Effect<A, E, R>
@@ -79,8 +79,8 @@ export const currentFetchOptions = globalValue(
 export const withFetchOptions = dual<
   (
     options: RequestInit
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     options: RequestInit
   ) => Effect.Effect<A, E, R>
@@ -96,7 +96,7 @@ const clientProto = {
 const isClient = (u: unknown): u is Client.Client<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
 /** @internal */
-export const make = <A, E, R, R2, E2>(
+export const make = <E2, R2, A, E, R>(
   execute: (
     request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => Effect.Effect<A, E, R>,
@@ -236,13 +236,13 @@ export const fetch: Client.Client.Default = makeDefault((request, url, signal, f
 
 /** @internal */
 export const transform = dual<
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     f: (
       effect: Effect.Effect<A, E, R>,
       request: ClientRequest.ClientRequest
     ) => Effect.Effect<A1, E1, R1>
   ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E | E1, R | R1>,
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: Client.Client<A, E, R>,
     f: (
       effect: Effect.Effect<A, E, R>,
@@ -305,10 +305,10 @@ export const layer = Layer.succeed(tag, fetch)
 
 /** @internal */
 export const transformResponse = dual<
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E1, R1>,
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: Client.Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => Client.Client<A1, E1, R1>
@@ -316,7 +316,7 @@ export const transformResponse = dual<
 
 /** @internal */
 export const catchTag: {
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1, A1>(
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): <A, R>(
@@ -327,9 +327,9 @@ export const catchTag: {
     E,
     A,
     K extends E extends { _tag: string } ? E["_tag"] : never,
+    A1,
     R1,
-    E1,
-    A1
+    E1
   >(
     self: Client.Client<A, E, R>,
     tag: K,
@@ -494,16 +494,16 @@ export const catchTags: {
 
 /** @internal */
 export const catchAll: {
-  <E, R2, E2, A2>(
+  <E, A2, E2, R2>(
     f: (e: E) => Effect.Effect<A2, E2, R2>
   ): <A, R>(self: Client.Client<A, E, R>) => Client.Client<A2 | A, E2, R | R2>
-  <A, E, R, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
   ): Client.Client<A2 | A, E2, R | R2>
 } = dual(
   2,
-  <A, E, R, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
   ): Client.Client<A2 | A, E2, R | R2> => transformResponse(self, Effect.catchAll(f))
@@ -511,13 +511,13 @@ export const catchAll: {
 
 /** @internal */
 export const filterOrElse = dual<
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A | B, E2 | E, R2 | R>,
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client.Client<A, E, R>,
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
@@ -550,10 +550,10 @@ export const map = dual<
 
 /** @internal */
 export const mapEffect = dual<
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, R | R2>,
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => Client.Client<B, E | E2, R | R2>
@@ -566,10 +566,10 @@ export const scoped = <A, E, R>(
 
 /** @internal */
 export const mapEffectScoped = dual<
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>,
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>
@@ -588,14 +588,14 @@ export const mapRequest = dual<
 
 /** @internal */
 export const mapRequestEffect = dual<
-  <R2, E2>(
+  <E2, R2>(
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => <A, E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2>(
+  <A, E, R, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (
       a: ClientRequest.ClientRequest
@@ -616,14 +616,14 @@ export const mapInputRequest = dual<
 
 /** @internal */
 export const mapInputRequestEffect = dual<
-  <R2, E2>(
+  <E2, R2>(
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => <A, E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2>(
+  <A, E, R, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (
       a: ClientRequest.ClientRequest
@@ -694,10 +694,10 @@ export const schemaFunction = dual<
 
 /** @internal */
 export const tap = dual<
-  <A, R2, E2, _>(
+  <A, _, E2, R2>(
     f: (a: A) => Effect.Effect<_, E2, R2>
   ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2, _>(
+  <A, E, R, _, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<_, E2, R2>
   ) => Client.Client<A, E | E2, R | R2>
@@ -705,12 +705,12 @@ export const tap = dual<
 
 /** @internal */
 export const tapRequest = dual<
-  <R2, E2, _>(
+  <_, E2, R2>(
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => <A, E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2, _>(
+  <A, E, R, _, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => Client.Client<A, E | E2, R | R2>
diff --git a/packages/platform/src/internal/http/middleware.ts b/packages/platform/src/internal/http/middleware.ts
index c4cff7920e..c01360903a 100644
--- a/packages/platform/src/internal/http/middleware.ts
+++ b/packages/platform/src/internal/http/middleware.ts
@@ -24,7 +24,7 @@ export const loggerDisabled = globalValue(
 )
 
 /** @internal */
-export const withLoggerDisabled = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.zipRight(
     FiberRef.set(loggerDisabled, true),
     self
@@ -40,8 +40,8 @@ export const currentTracerDisabledWhen = globalValue(
 export const withTracerDisabledWhen = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ) => <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
+  <A, E, R>(
     layer: Layer.Layer<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ) => Layer.Layer<A, E, R>
@@ -51,8 +51,8 @@ export const withTracerDisabledWhen = dual<
 export const withTracerDisabledWhenEffect = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ) => Effect.Effect<A, E, R>
@@ -62,8 +62,8 @@ export const withTracerDisabledWhenEffect = dual<
 export const withTracerDisabledForUrls = dual<
   (
     urls: ReadonlyArray<string>
-  ) => <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
+  <A, E, R>(
     layer: Layer.Layer<A, E, R>,
     urls: ReadonlyArray<string>
   ) => Layer.Layer<A, E, R>
diff --git a/packages/platform/src/internal/http/multipart.ts b/packages/platform/src/internal/http/multipart.ts
index e2fbaf0ed6..12131ca659 100644
--- a/packages/platform/src/internal/http/multipart.ts
+++ b/packages/platform/src/internal/http/multipart.ts
@@ -60,8 +60,8 @@ export const maxParts: FiberRef.FiberRef<Option.Option<number>> = globalValue(
 
 /** @internal */
 export const withMaxParts = dual<
-  (count: Option.Option<number>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>) => Effect.Effect<A, E, R>
+  (count: Option.Option<number>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>) => Effect.Effect<A, E, R>
 >(2, (effect, count) => Effect.locally(effect, maxParts, count))
 
 /** @internal */
@@ -72,8 +72,8 @@ export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = globalValue(
 
 /** @internal */
 export const withMaxFieldSize = dual<
-  (size: FileSystem.SizeInput) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput) => Effect.Effect<A, E, R>
+  (size: FileSystem.SizeInput) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxFieldSize, FileSystem.Size(size)))
 
 /** @internal */
@@ -84,8 +84,8 @@ export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = gl
 
 /** @internal */
 export const withMaxFileSize = dual<
-  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
+  (size: Option.Option<FileSystem.SizeInput>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxFileSize, Option.map(size, FileSystem.Size)))
 
 /** @internal */
@@ -96,8 +96,8 @@ export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = globalValu
 
 /** @internal */
 export const withFieldMimeTypes = dual<
-  (mimeTypes: ReadonlyArray<string>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<A, E, R>
+  (mimeTypes: ReadonlyArray<string>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<A, E, R>
 >(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
 
 /** @internal */
diff --git a/packages/platform/src/internal/http/multiplex.ts b/packages/platform/src/internal/http/multiplex.ts
index c0d74d3c0e..0149336b57 100644
--- a/packages/platform/src/internal/http/multiplex.ts
+++ b/packages/platform/src/internal/http/multiplex.ts
@@ -68,7 +68,7 @@ class MultiplexImpl<E = never, R = never>
 export const empty: Multiplex.Multiplex<never> = new MultiplexImpl([])
 
 /** @internal */
-export const make = <R, E>(
+export const make = <E, R>(
   apps: Iterable<
     readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
   >
@@ -76,11 +76,11 @@ export const make = <R, E>(
 
 /** @internal */
 export const add = dual<
-  <R2, E2, R3, E3>(
+  <E2, R2, E3, R3>(
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     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>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>,
+  <E, R, E2, R2, E3, R3>(
     self: Multiplex.Multiplex<E, R>,
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
@@ -96,12 +96,12 @@ export const add = dual<
 
 /** @internal */
 export const headerExact = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     value: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     value: string,
@@ -118,12 +118,12 @@ export const headerExact = dual<
 
 /** @internal */
 export const headerRegex = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     regex: RegExp,
@@ -140,12 +140,12 @@ export const headerRegex = dual<
 
 /** @internal */
 export const headerStartsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     prefix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     prefix: string,
@@ -162,12 +162,12 @@ export const headerStartsWith = dual<
 
 /** @internal */
 export const headerEndsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     suffix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     suffix: string,
@@ -184,11 +184,11 @@ export const headerEndsWith = dual<
 
 /** @internal */
 export const hostRegex = dual<
-  <R2, E2>(
+  <E2, R2>(
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     regex: RegExp,
     app: App.Default<E2, R2>
@@ -197,11 +197,11 @@ export const hostRegex = dual<
 
 /** @internal */
 export const hostStartsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     prefix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     prefix: string,
     app: App.Default<E2, R2>
@@ -210,11 +210,11 @@ export const hostStartsWith = dual<
 
 /** @internal */
 export const hostEndsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     suffix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     suffix: string,
     app: App.Default<E2, R2>
@@ -223,11 +223,11 @@ export const hostEndsWith = dual<
 
 /** @internal */
 export const hostExact = dual<
-  <R2, E2>(
+  <E2, R2>(
     host: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     host: string,
     app: App.Default<E2, R2>
diff --git a/packages/platform/src/internal/http/router.ts b/packages/platform/src/internal/http/router.ts
index b007488bff..f46e302cce 100644
--- a/packages/platform/src/internal/http/router.ts
+++ b/packages/platform/src/internal/http/router.ts
@@ -180,7 +180,7 @@ class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
   }
 }
 
-const toHttpApp = <R, E>(
+const toHttpApp = <E, R>(
   self: Router.Router<E, R>
 ): App.Default<E | Error.RouteNotFound, R> => {
   const router = FindMyWay.make<Router.Route<E, R>>()
@@ -331,8 +331,8 @@ export const makeRoute = <E, R>(
 
 /** @internal */
 export const concat = dual<
-  <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>
+  <R1, E1>(that: Router.Router<E1, R1>) => <E, R>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
+  <E, R, E1, R1>(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 = (
@@ -341,8 +341,8 @@ const removeTrailingSlash = (
 
 /** @internal */
 export const prefixAll = dual<
-  (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>
+  (prefix: Router.PathInput) => <E, R>(self: Router.Router<E, R>) => Router.Router<E, R>,
+  <E, R>(self: Router.Router<E, R>, prefix: Router.PathInput) => Router.Router<E, R>
 >(
   2,
   (self, prefix) => {
@@ -369,8 +369,8 @@ export const mount = dual<
   <R1, E1>(
     path: `/${string}`,
     that: Router.Router<E1, R1>
-  ) => <R, E>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
-  <R, E, R1, E1>(
+  ) => <E, R>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: `/${string}`,
     that: Router.Router<E1, R1>
@@ -388,10 +388,10 @@ export const mountApp = dual<
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
-  ) => <R, E>(
+  ) => <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
@@ -401,7 +401,7 @@ export const mountApp = dual<
   ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>
 >(
   (args) => Predicate.hasProperty(args[0], TypeId),
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
@@ -420,10 +420,10 @@ export const route = (method: Method.Method | "*"): {
     options?: {
       readonly uninterruptible?: boolean | undefined
     } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<E1 | E, R | Router.Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: Router.PathInput,
     handler: Router.Route.Handler<E1, R1>,
@@ -436,10 +436,10 @@ export const route = (method: Method.Method | "*"): {
     <R1, E1>(
       path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
-    ) => <R, E>(
+    ) => <E, R>(
       self: Router.Router<E, R>
     ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
-    <R, E, R1, E1>(
+    <E, R, E1, R1>(
       self: Router.Router<E, R>,
       path: Router.PathInput,
       handler: Router.Route.Handler<E1, R1>,
@@ -512,7 +512,7 @@ export const catchAll = dual<
   <E, E2, R2>(
     f: (e: E) => Router.Route.Handler<E2, R2>
   ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router.Router<E, R>,
     f: (e: E) => Router.Route.Handler<E2, R2>
   ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
@@ -523,7 +523,7 @@ export const catchAllCause = dual<
   <E, E2, R2>(
     f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
   ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router.Router<E, R>,
     f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
   ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
@@ -537,7 +537,7 @@ export const catchTag = dual<
   ) => <R>(
     self: Router.Router<E, R>
   ) => Router.Router<Exclude<E, { _tag: K }> | E1, R | Router.Router.ExcludeProvided<R1>>,
-  <R, E, K extends (E extends { _tag: string } ? E["_tag"] : never), E1, R1>(
+  <E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), E1, R1>(
     self: Router.Router<E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<E1, R1>
@@ -594,15 +594,15 @@ export const provideService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ) => <R, E>(
+  ) => <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>,
-  <R, E, T extends Context.Tag<any, any>>(
+  <E, R, T extends Context.Tag<any, any>>(
     self: Router.Router<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
   ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>
->(3, <R, E, T extends Context.Tag<any, any>>(
+>(3, <E, R, T extends Context.Tag<any, any>>(
   self: Router.Router<E, R>,
   tag: T,
   service: Context.Tag.Service<T>
@@ -613,7 +613,7 @@ export const provideServiceEffect = dual<
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ) => <R, E>(
+  ) => <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<
     E | E1,
@@ -622,7 +622,7 @@ export const provideServiceEffect = dual<
       Context.Tag.Identifier<T>
     >
   >,
-  <R, E, T extends Context.Tag<any, any>, R1, E1>(
+  <E, R, T extends Context.Tag<any, any>, R1, E1>(
     self: Router.Router<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
@@ -633,7 +633,7 @@ export const provideServiceEffect = dual<
       Context.Tag.Identifier<T>
     >
   >
->(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
+>(3, <E, R, T extends Context.Tag<any, any>, R1, E1>(
   self: Router.Router<E, R>,
   tag: T,
   effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
diff --git a/packages/platform/src/internal/http/server.ts b/packages/platform/src/internal/http/server.ts
index 756f927ee6..be466c1c71 100644
--- a/packages/platform/src/internal/http/server.ts
+++ b/packages/platform/src/internal/http/server.ts
@@ -35,10 +35,10 @@ export const make = (
 /** @internal */
 export const serve = dual<
   {
-    (): <R, E>(
+    (): <E, R>(
       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<App, E, R>): (
+    <E, R, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
       httpApp: App.Default<E, R>
     ) => Layer.Layer<
       never,
@@ -47,10 +47,10 @@ export const serve = dual<
     >
   },
   {
-    <R, E>(
+    <E, R>(
       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>>(
+    <E, R, App extends App.Default<any, any>>(
       httpApp: App.Default<E, R>,
       middleware: Middleware.Middleware.Applied<App, E, R>
     ): Layer.Layer<
@@ -61,7 +61,7 @@ export const serve = dual<
   }
 >(
   (args) => Effect.isEffect(args[0]),
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     httpApp: App.Default<E, R>,
     middleware?: Middleware.Middleware.Applied<App, E, R>
   ): Layer.Layer<
@@ -80,14 +80,14 @@ export const serve = dual<
 /** @internal */
 export const serveEffect = dual<
   {
-    (): <R, E>(
+    (): <E, R>(
       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<App, E, R>): (
+    <E, R, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
       httpApp: App.Default<E, R>
     ) => Effect.Effect<
       void,
@@ -96,10 +96,10 @@ export const serveEffect = dual<
     >
   },
   {
-    <R, E>(
+    <E, R>(
       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>>(
+    <E, R, App extends App.Default<any, any>>(
       httpApp: App.Default<E, R>,
       middleware: Middleware.Middleware.Applied<App, E, R>
     ): Effect.Effect<
@@ -110,7 +110,7 @@ export const serveEffect = dual<
   }
 >(
   (args) => Effect.isEffect(args[0]),
-  (<R, E, App extends App.Default<any, any>>(
+  (<E, R, App extends App.Default<any, any>>(
     httpApp: App.Default<E, R>,
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): Effect.Effect<
@@ -135,7 +135,7 @@ export const formatAddress = (address: Server.Address): string => {
 }
 
 /** @internal */
-export const addressWith = <R, E, A>(
+export const addressWith = <A, E, R>(
   effect: (address: Server.Address) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, Server.Server | R> =>
   Effect.flatMap(
@@ -144,7 +144,7 @@ export const addressWith = <R, E, A>(
   )
 
 /** @internal */
-export const addressFormattedWith = <R, E, A>(
+export const addressFormattedWith = <A, E, R>(
   effect: (address: string) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, Server.Server | R> =>
   Effect.flatMap(
@@ -158,7 +158,7 @@ export const logAddress: Effect.Effect<void, never, Server.Server> = addressForm
 )
 
 /** @internal */
-export const withLogAddress = <R, E, A>(
+export const withLogAddress = <A, E, R>(
   layer: Layer.Layer<A, E, R>
 ): Layer.Layer<A, E, R | Exclude<Server.Server, A>> =>
   Layer.effectDiscard(logAddress).pipe(
diff --git a/packages/platform/src/internal/workerRunner.ts b/packages/platform/src/internal/workerRunner.ts
index 9ccc48efc0..e9a65cd4dc 100644
--- a/packages/platform/src/internal/workerRunner.ts
+++ b/packages/platform/src/internal/workerRunner.ts
@@ -30,7 +30,7 @@ export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>(
 )
 
 /** @internal */
-export const make = <I, R, E, O>(
+export const make = <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: WorkerRunner.Runner.Options<I, O, E>
 ) =>
@@ -172,7 +172,7 @@ export const make = <I, R, E, O>(
   })
 
 /** @internal */
-export const layer = <I, R, E, O>(
+export const layer = <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: WorkerRunner.Runner.Options<I, O, E>
 ): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> => Layer.scopedDiscard(make(process, options))