diff --git a/.changeset/moody-readers-suffer.md b/.changeset/moody-readers-suffer.md
new file mode 100644
index 0000000000..72159a9738
--- /dev/null
+++ b/.changeset/moody-readers-suffer.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `Fiber` type parameters order from `Fiber<E, A>` to `Fiber<A, E = never>`
diff --git a/packages/effect/mod.ts b/packages/effect/mod.ts
index 42f5b8d802..4f7554b24e 100644
--- a/packages/effect/mod.ts
+++ b/packages/effect/mod.ts
@@ -8,11 +8,12 @@ const enabled = {
   swapDeferredParams: false,
   swapTDeferredParams: false,
   swapTakeParams: false,
+  swapFiberParams: true,
   cleanupSTM: false,
   cleanupEffect: false,
   cleanupStream: false,
   cleanupExit: false,
-  cleanupTake: true
+  cleanupTake: false
 }
 
 const cleanup = (name: string) => (ast: cs.ASTPath<cs.TSTypeReference>) => {
@@ -91,6 +92,7 @@ const swapParamsEA = (nodeName: string) => (ast: cs.ASTPath<cs.TSTypeReference>)
 const swapDeferredParams = swapParamsEA("Deferred")
 const swapTDeferredParams = swapParamsEA("TDeferred")
 const swapTakeParams = swapParamsEA("Take")
+const swapFiberParams = swapParamsEA("Fiber")
 
 const swapSTMParams = swapParamsREA("STM")
 const swapSTMGenParams = swapParamsREA("STMGen")
@@ -139,6 +141,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
     if (enabled.swapTakeParams) {
       swapTakeParams(ast)
     }
+    if (enabled.swapFiberParams) {
+      swapFiberParams(ast)
+    }
     if (enabled.cleanupEffect) {
       cleanupEffect(ast)
     }
diff --git a/packages/effect/src/Effect.ts b/packages/effect/src/Effect.ts
index d737b14a15..432e3d35d5 100644
--- a/packages/effect/src/Effect.ts
+++ b/packages/effect/src/Effect.ts
@@ -2547,11 +2547,11 @@ export const diffFiberRefs: <A, E, R>(
  */
 export const ensuringChild: {
   <X, R2>(
-    f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect<X, never, R2>
+    f: (fiber: Fiber.Fiber<ReadonlyArray<unknown>, any>) => Effect<X, never, R2>
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R2 | R>
   <A, E, R, X, R2>(
     self: Effect<A, E, R>,
-    f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect<X, never, R2>
+    f: (fiber: Fiber.Fiber<ReadonlyArray<unknown>, any>) => Effect<X, never, R2>
   ): Effect<A, E, R | R2>
 } = circular.ensuringChild
 
@@ -2634,7 +2634,7 @@ export const forkAll: {
     options?: {
       readonly discard?: false | undefined
     }
-  ): <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<Fiber.Fiber<E, Array<A>>, never, R>
+  ): <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<Fiber.Fiber<Array<A>, E>, never, R>
   (options: {
     readonly discard: true
   }): <A, E, R>(effects: Iterable<Effect<A, E, R>>) => Effect<void, never, R>
@@ -2643,7 +2643,7 @@ export const forkAll: {
     options?: {
       readonly discard?: false | undefined
     }
-  ): Effect<Fiber.Fiber<E, Array<A>>, never, R>
+  ): Effect<Fiber.Fiber<Array<A>, E>, never, R>
   <A, E, R>(effects: Iterable<Effect<A, E, R>>, options: {
     readonly discard: true
   }): Effect<void, never, R>
@@ -2693,7 +2693,7 @@ export const forkWithErrorHandler: {
  * @since 2.0.0
  * @category supervision & fibers
  */
-export const fromFiber: <E, A>(fiber: Fiber.Fiber<E, A>) => Effect<A, E> = circular.fromFiber
+export const fromFiber: <E, A>(fiber: Fiber.Fiber<A, E>) => Effect<A, E> = circular.fromFiber
 
 /**
  * Creates an `Effect` value that represents the exit value of the specified
@@ -2702,7 +2702,7 @@ export const fromFiber: <E, A>(fiber: Fiber.Fiber<E, A>) => Effect<A, E> = circu
  * @since 2.0.0
  * @category supervision & fibers
  */
-export const fromFiberEffect: <A, E, R>(fiber: Effect<Fiber.Fiber<E, A>, E, R>) => Effect<A, E, R> =
+export const fromFiberEffect: <A, E, R>(fiber: Effect<Fiber.Fiber<A, E>, E, R>) => Effect<A, E, R> =
   circular.fromFiberEffect
 
 /**
@@ -3695,16 +3695,16 @@ export const raceWith: {
   <A1, E1, R1, E, A, A2, E2, R2, A3, E3, R3>(
     other: Effect<A1, E1, R1>,
     options: {
-      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<E1, A1>) => Effect<A2, E2, R2>
-      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<E, A>) => Effect<A3, E3, R3>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<A1, E1>) => Effect<A2, E2, R2>
+      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<A, E>) => Effect<A3, E3, R3>
     }
   ): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, E2 | E3, R1 | R2 | R3 | R>
   <A, E, R, A1, E1, R1, A2, E2, R2, A3, E3, R3>(
     self: Effect<A, E, R>,
     other: Effect<A1, E1, R1>,
     options: {
-      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<E1, A1>) => Effect<A2, E2, R2>
-      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<E, A>) => Effect<A3, E3, R3>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<A1, E1>) => Effect<A2, E2, R2>
+      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<A, E>) => Effect<A3, E3, R3>
     }
   ): Effect<A2 | A3, E2 | E3, R | R1 | R2 | R3>
 } = fiberRuntime.raceWith
diff --git a/packages/effect/src/Fiber.ts b/packages/effect/src/Fiber.ts
index 6785d86897..d5dcb00134 100644
--- a/packages/effect/src/Fiber.ts
+++ b/packages/effect/src/Fiber.ts
@@ -57,7 +57,7 @@ export type RuntimeFiberTypeId = typeof RuntimeFiberTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Fiber<out E, out A> extends Fiber.Variance<E, A>, Pipeable {
+export interface Fiber<out A, out E = never> extends Fiber.Variance<A, E>, Pipeable {
   /**
    * The identity of the fiber.
    */
@@ -101,7 +101,7 @@ export interface Fiber<out E, out A> extends Fiber.Variance<E, A>, Pipeable {
  * @since 2.0.0
  * @category models
  */
-export interface RuntimeFiber<out E, out A> extends Fiber<E, A>, Fiber.RuntimeVariance<E, A> {
+export interface RuntimeFiber<out E, out A> extends Fiber<A, E>, Fiber.RuntimeVariance<E, A> {
   /**
    * Reads the current number of ops that have occurred since the last yield
    */
@@ -171,10 +171,10 @@ export declare namespace Fiber {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out E, out A> {
+  export interface Variance<out A, out E> {
     readonly [FiberTypeId]: {
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Covariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 
@@ -246,7 +246,7 @@ export const isFiber: (u: unknown) => u is Fiber<unknown, unknown> = internal.is
  * @since 2.0.0
  * @category refinements
  */
-export const isRuntimeFiber: <E, A>(self: Fiber<E, A>) => self is RuntimeFiber<E, A> = internal.isRuntimeFiber
+export const isRuntimeFiber: <A, E>(self: Fiber<A, E>) => self is RuntimeFiber<E, A> = internal.isRuntimeFiber
 
 /**
  * The identity of the fiber.
@@ -254,9 +254,9 @@ export const isRuntimeFiber: <E, A>(self: Fiber<E, A>) => self is RuntimeFiber<E
  * @since 2.0.0
  * @category getters
  */
-export const id: <E, A>(self: Fiber<E, A>) => FiberId.FiberId = internal.id
+export const id: <A, E>(self: Fiber<A, E>) => FiberId.FiberId = internal.id
 
-const _await: <E, A>(self: Fiber<E, A>) => Effect.Effect<Exit.Exit<A, E>> = internal._await
+const _await: <A, E>(self: Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>> = internal._await
 
 export {
   /**
@@ -283,7 +283,7 @@ export const awaitAll: (fibers: Iterable<Fiber<any, any>>) => Effect.Effect<void
  * @since 2.0.0
  * @category getters
  */
-export const children: <E, A>(self: Fiber<E, A>) => Effect.Effect<Array<RuntimeFiber<any, any>>> = internal.children
+export const children: <A, E>(self: Fiber<A, E>) => Effect.Effect<Array<RuntimeFiber<any, any>>> = internal.children
 
 /**
  * Collects all fibers into a single fiber producing an in-order list of the
@@ -292,7 +292,7 @@ export const children: <E, A>(self: Fiber<E, A>) => Effect.Effect<Array<RuntimeF
  * @since 2.0.0
  * @category constructors
  */
-export const all: <E, A>(fibers: Iterable<Fiber<E, A>>) => Fiber<E, ReadonlyArray<A>> = fiberRuntime.fiberAll
+export const all: <A, E>(fibers: Iterable<Fiber<A, E>>) => Fiber<ReadonlyArray<A>, E> = fiberRuntime.fiberAll
 
 /**
  * A fiber that is done with the specified `Exit` value.
@@ -300,13 +300,13 @@ export const all: <E, A>(fibers: Iterable<Fiber<E, A>>) => Fiber<E, ReadonlyArra
  * @since 2.0.0
  * @category constructors
  */
-export const done: <A, E>(exit: Exit.Exit<A, E>) => Fiber<E, A> = internal.done
+export const done: <A, E>(exit: Exit.Exit<A, E>) => Fiber<A, E> = internal.done
 
 /**
  * @since 2.0.0
  * @category destructors
  */
-export const dump: <E, A>(self: RuntimeFiber<E, A>) => Effect.Effect<Fiber.Dump> = internal.dump
+export const dump: <A, E>(self: RuntimeFiber<E, A>) => Effect.Effect<Fiber.Dump> = internal.dump
 
 /**
  * @since 2.0.0
@@ -322,7 +322,7 @@ export const dumpAll: (
  * @since 2.0.0
  * @category constructors
  */
-export const fail: <E>(error: E) => Fiber<E, never> = internal.fail
+export const fail: <E>(error: E) => Fiber<never, E> = internal.fail
 
 /**
  * Creates a `Fiber` that has already failed with the specified cause.
@@ -330,7 +330,7 @@ export const fail: <E>(error: E) => Fiber<E, never> = internal.fail
  * @since 2.0.0
  * @category constructors
  */
-export const failCause: <E>(cause: Cause.Cause<E>) => Fiber<E, never> = internal.failCause
+export const failCause: <E>(cause: Cause.Cause<E>) => Fiber<never, E> = internal.failCause
 
 /**
  * Lifts an `Effect` into a `Fiber`.
@@ -338,7 +338,7 @@ export const failCause: <E>(cause: Cause.Cause<E>) => Fiber<E, never> = internal
  * @since 2.0.0
  * @category conversions
  */
-export const fromEffect: <E, A>(effect: Effect.Effect<A, E>) => Effect.Effect<Fiber<E, A>> = internal.fromEffect
+export const fromEffect: <A, E>(effect: Effect.Effect<A, E>) => Effect.Effect<Fiber<A, E>> = internal.fromEffect
 
 /**
  * Gets the current fiber if one is running.
@@ -355,7 +355,7 @@ export const getCurrentFiber: () => Option.Option<RuntimeFiber<any, any>> = inte
  * @since 2.0.0
  * @category destructors
  */
-export const inheritAll: <E, A>(self: Fiber<E, A>) => Effect.Effect<void> = internal.inheritAll
+export const inheritAll: <A, E>(self: Fiber<A, E>) => Effect.Effect<void> = internal.inheritAll
 
 /**
  * Interrupts the fiber from whichever fiber is calling this method. If the
@@ -365,7 +365,7 @@ export const inheritAll: <E, A>(self: Fiber<E, A>) => Effect.Effect<void> = inte
  * @since 2.0.0
  * @category interruption
  */
-export const interrupt: <E, A>(self: Fiber<E, A>) => Effect.Effect<Exit.Exit<A, E>> = core.interruptFiber
+export const interrupt: <A, E>(self: Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>> = core.interruptFiber
 
 /**
  * Constructrs a `Fiber` that is already interrupted.
@@ -373,7 +373,7 @@ export const interrupt: <E, A>(self: Fiber<E, A>) => Effect.Effect<Exit.Exit<A,
  * @since 2.0.0
  * @category constructors
  */
-export const interrupted: (fiberId: FiberId.FiberId) => Fiber<never, never> = internal.interrupted
+export const interrupted: (fiberId: FiberId.FiberId) => Fiber<never> = internal.interrupted
 
 /**
  * Interrupts the fiber as if interrupted from the specified fiber. If the
@@ -384,8 +384,8 @@ export const interrupted: (fiberId: FiberId.FiberId) => Fiber<never, never> = in
  * @category interruption
  */
 export const interruptAs: {
-  (fiberId: FiberId.FiberId): <E, A>(self: Fiber<E, A>) => Effect.Effect<Exit.Exit<A, E>>
-  <E, A>(self: Fiber<E, A>, fiberId: FiberId.FiberId): Effect.Effect<Exit.Exit<A, E>>
+  (fiberId: FiberId.FiberId): <A, E>(self: Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>>
+  <A, E>(self: Fiber<A, E>, fiberId: FiberId.FiberId): Effect.Effect<Exit.Exit<A, E>>
 } = core.interruptAsFiber
 
 /**
@@ -397,8 +397,8 @@ export const interruptAs: {
  * @category interruption
  */
 export const interruptAsFork: {
-  (fiberId: FiberId.FiberId): <E, A>(self: Fiber<E, A>) => Effect.Effect<void>
-  <E, A>(self: Fiber<E, A>, fiberId: FiberId.FiberId): Effect.Effect<void>
+  (fiberId: FiberId.FiberId): <A, E>(self: Fiber<A, E>) => Effect.Effect<void>
+  <A, E>(self: Fiber<A, E>, fiberId: FiberId.FiberId): Effect.Effect<void>
 } = internal.interruptAsFork
 
 /**
@@ -429,7 +429,7 @@ export const interruptAllAs: {
  * @since 2.0.0
  * @category interruption
  */
-export const interruptFork: <E, A>(self: Fiber<E, A>) => Effect.Effect<void> = fiberRuntime.fiberInterruptFork
+export const interruptFork: <A, E>(self: Fiber<A, E>) => Effect.Effect<void> = fiberRuntime.fiberInterruptFork
 
 /**
  * Joins the fiber, which suspends the joining fiber until the result of the
@@ -441,7 +441,7 @@ export const interruptFork: <E, A>(self: Fiber<E, A>) => Effect.Effect<void> = f
  * @since 2.0.0
  * @category destructors
  */
-export const join: <E, A>(self: Fiber<E, A>) => Effect.Effect<A, E> = internal.join
+export const join: <A, E>(self: Fiber<A, E>) => Effect.Effect<A, E> = internal.join
 
 /**
  * Joins all fibers, awaiting their _successful_ completion. Attempting to
@@ -451,7 +451,7 @@ export const join: <E, A>(self: Fiber<E, A>) => Effect.Effect<A, E> = internal.j
  * @since 2.0.0
  * @category destructors
  */
-export const joinAll: <E, A>(fibers: Iterable<Fiber<E, A>>) => Effect.Effect<void, E> = fiberRuntime.fiberJoinAll
+export const joinAll: <A, E>(fibers: Iterable<Fiber<A, E>>) => Effect.Effect<void, E> = fiberRuntime.fiberJoinAll
 
 /**
  * Maps over the value the Fiber computes.
@@ -460,8 +460,8 @@ export const joinAll: <E, A>(fibers: Iterable<Fiber<E, A>>) => Effect.Effect<voi
  * @category mapping
  */
 export const map: {
-  <A, B>(f: (a: A) => B): <E>(self: Fiber<E, A>) => Fiber<E, B>
-  <E, A, B>(self: Fiber<E, A>, f: (a: A) => B): Fiber<E, B>
+  <A, B>(f: (a: A) => B): <E>(self: Fiber<A, E>) => Fiber<B, E>
+  <A, E, B>(self: Fiber<A, E>, f: (a: A) => B): Fiber<B, E>
 } = internal.map
 
 /**
@@ -471,8 +471,8 @@ export const map: {
  * @category mapping
  */
 export const mapEffect: {
-  <A, A2, E2>(f: (a: A) => Effect.Effect<A2, E2>): <E>(self: Fiber<E, A>) => Fiber<E2 | E, A2>
-  <E, A, A2, E2>(self: Fiber<E, A>, f: (a: A) => Effect.Effect<A2, E2>): Fiber<E | E2, A2>
+  <A, A2, E2>(f: (a: A) => Effect.Effect<A2, E2>): <E>(self: Fiber<A, E>) => Fiber<A2, E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, f: (a: A) => Effect.Effect<A2, E2>): Fiber<A2, E | E2>
 } = internal.mapEffect
 
 /**
@@ -483,8 +483,8 @@ export const mapEffect: {
  * @category mapping
  */
 export const mapFiber: {
-  <E, E2, A, B>(f: (a: A) => Fiber<E2, B>): (self: Fiber<E, A>) => Effect.Effect<Fiber<E | E2, B>>
-  <E, A, E2, B>(self: Fiber<E, A>, f: (a: A) => Fiber<E2, B>): Effect.Effect<Fiber<E | E2, B>>
+  <E, E2, A, B>(f: (a: A) => Fiber<B, E2>): (self: Fiber<A, E>) => Effect.Effect<Fiber<B, E | E2>>
+  <A, E, E2, B>(self: Fiber<A, E>, f: (a: A) => Fiber<B, E2>): Effect.Effect<Fiber<B, E | E2>>
 } = internal.mapFiber
 
 /**
@@ -494,16 +494,16 @@ export const mapFiber: {
  * @category folding
  */
 export const match: {
-  <E, A, Z>(
+  <A, E, Z>(
     options: {
-      readonly onFiber: (fiber: Fiber<E, A>) => Z
+      readonly onFiber: (fiber: Fiber<A, E>) => Z
       readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
     }
-  ): (self: Fiber<E, A>) => Z
-  <E, A, Z>(
-    self: Fiber<E, A>,
+  ): (self: Fiber<A, E>) => Z
+  <A, E, Z>(
+    self: Fiber<A, E>,
     options: {
-      readonly onFiber: (fiber: Fiber<E, A>) => Z
+      readonly onFiber: (fiber: Fiber<A, E>) => Z
       readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
     }
   ): Z
@@ -515,7 +515,7 @@ export const match: {
  * @since 2.0.0
  * @category constructors
  */
-export const never: Fiber<never, never> = internal.never
+export const never: Fiber<never> = internal.never
 
 /**
  * Returns a fiber that prefers `this` fiber, but falls back to the `that` one
@@ -526,8 +526,8 @@ export const never: Fiber<never, never> = internal.never
  * @category alternatives
  */
 export const orElse: {
-  <E2, A2>(that: Fiber<E2, A2>): <E, A>(self: Fiber<E, A>) => Fiber<E2 | E, A2 | A>
-  <E, A, E2, A2>(self: Fiber<E, A>, that: Fiber<E2, A2>): Fiber<E | E2, A | A2>
+  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<A2 | A, E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<A | A2, E | E2>
 } = internal.orElse
 
 /**
@@ -539,8 +539,8 @@ export const orElse: {
  * @category alternatives
  */
 export const orElseEither: {
-  <E2, A2>(that: Fiber<E2, A2>): <E, A>(self: Fiber<E, A>) => Fiber<E2 | E, Either.Either<A, A2>>
-  <E, A, E2, A2>(self: Fiber<E, A>, that: Fiber<E2, A2>): Fiber<E | E2, Either.Either<A, A2>>
+  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<Either.Either<A, A2>, E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<Either.Either<A, A2>, E | E2>
 } = internal.orElseEither
 
 /**
@@ -550,7 +550,7 @@ export const orElseEither: {
  * @since 2.0.0
  * @category getters
  */
-export const poll: <E, A>(self: Fiber<E, A>) => Effect.Effect<Option.Option<Exit.Exit<A, E>>> = internal.poll
+export const poll: <A, E>(self: Fiber<A, E>) => Effect.Effect<Option.Option<Exit.Exit<A, E>>> = internal.poll
 
 /**
  * Pretty-prints a `RuntimeFiber`.
@@ -558,7 +558,7 @@ export const poll: <E, A>(self: Fiber<E, A>) => Effect.Effect<Option.Option<Exit
  * @since 2.0.0
  * @category destructors
  */
-export const pretty: <E, A>(self: RuntimeFiber<E, A>) => Effect.Effect<string> = internal.pretty
+export const pretty: <A, E>(self: RuntimeFiber<E, A>) => Effect.Effect<string> = internal.pretty
 
 /**
  * Returns a chunk containing all root fibers.
@@ -583,7 +583,7 @@ export const unsafeRoots: (_: void) => Array<RuntimeFiber<any, any>> = internal.
  * @since 2.0.0
  * @category destructors
  */
-export const scoped: <E, A>(self: Fiber<E, A>) => Effect.Effect<Fiber<E, A>, never, Scope.Scope> =
+export const scoped: <A, E>(self: Fiber<A, E>) => Effect.Effect<Fiber<A, E>, never, Scope.Scope> =
   fiberRuntime.fiberScoped
 
 /**
@@ -592,7 +592,7 @@ export const scoped: <E, A>(self: Fiber<E, A>) => Effect.Effect<Fiber<E, A>, nev
  * @since 2.0.0
  * @category getters
  */
-export const status: <E, A>(self: RuntimeFiber<E, A>) => Effect.Effect<FiberStatus.FiberStatus> = internal.status
+export const status: <A, E>(self: RuntimeFiber<E, A>) => Effect.Effect<FiberStatus.FiberStatus> = internal.status
 
 /**
  * Returns a fiber that has already succeeded with the specified value.
@@ -600,7 +600,7 @@ export const status: <E, A>(self: RuntimeFiber<E, A>) => Effect.Effect<FiberStat
  * @since 2.0.0
  * @category constructors
  */
-export const succeed: <A>(value: A) => Fiber<never, A> = internal.succeed
+export const succeed: <A>(value: A) => Fiber<A> = internal.succeed
 
 /**
  * A fiber that has already succeeded with unit.
@@ -608,7 +608,7 @@ export const succeed: <A>(value: A) => Fiber<never, A> = internal.succeed
  * @since 2.0.0
  * @category constructors
  */
-export const unit: Fiber<never, void> = internal.unit
+export const unit: Fiber<void> = internal.unit
 
 /**
  * Zips this fiber and the specified fiber together, producing a tuple of
@@ -618,8 +618,8 @@ export const unit: Fiber<never, void> = internal.unit
  * @category zipping
  */
 export const zip: {
-  <E2, A2>(that: Fiber<E2, A2>): <E, A>(self: Fiber<E, A>) => Fiber<E2 | E, [A, A2]>
-  <E, A, E2, A2>(self: Fiber<E, A>, that: Fiber<E2, A2>): Fiber<E | E2, [A, A2]>
+  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<[A, A2], E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<[A, A2], E | E2>
 } = circular.zipFiber
 
 /**
@@ -629,8 +629,8 @@ export const zip: {
  * @category zipping
  */
 export const zipLeft: {
-  <E2, A2>(that: Fiber<E2, A2>): <E, A>(self: Fiber<E, A>) => Fiber<E2 | E, A>
-  <E, A, E2, A2>(self: Fiber<E, A>, that: Fiber<E2, A2>): Fiber<E | E2, A>
+  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<A, E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<A, E | E2>
 } = circular.zipLeftFiber
 
 /**
@@ -640,8 +640,8 @@ export const zipLeft: {
  * @category zipping
  */
 export const zipRight: {
-  <E2, A2>(that: Fiber<E2, A2>): <E, A>(self: Fiber<E, A>) => Fiber<E2 | E, A2>
-  <E, A, E2, A2>(self: Fiber<E, A>, that: Fiber<E2, A2>): Fiber<E | E2, A2>
+  <A2, E2>(that: Fiber<A2, E2>): <A, E>(self: Fiber<A, E>) => Fiber<A2, E2 | E>
+  <A, E, A2, E2>(self: Fiber<A, E>, that: Fiber<A2, E2>): Fiber<A2, E | E2>
 } = circular.zipRightFiber
 
 /**
@@ -653,6 +653,6 @@ export const zipRight: {
  * @category zipping
  */
 export const zipWith: {
-  <E2, A, B, C>(that: Fiber<E2, B>, f: (a: A, b: B) => C): <E>(self: Fiber<E, A>) => Fiber<E2 | E, C>
-  <E, A, E2, B, C>(self: Fiber<E, A>, that: Fiber<E2, B>, f: (a: A, b: B) => C): Fiber<E | E2, C>
+  <B, E2, A, C>(that: Fiber<B, E2>, f: (a: A, b: B) => C): <E>(self: Fiber<A, E>) => Fiber<C, E2 | E>
+  <A, E, B, E2, C>(self: Fiber<A, E>, that: Fiber<B, E2>, f: (a: A, b: B) => C): Fiber<C, E | E2>
 } = circular.zipWithFiber
diff --git a/packages/effect/src/MergeState.ts b/packages/effect/src/MergeState.ts
index 477e270672..c2a467e05f 100644
--- a/packages/effect/src/MergeState.ts
+++ b/packages/effect/src/MergeState.ts
@@ -49,8 +49,8 @@ export interface BothRunning<_Env, out Err, out Err1, _Err2, out Elem, out Done,
   extends MergeState.Proto
 {
   readonly _tag: "BothRunning"
-  readonly left: Fiber.Fiber<Err, Either.Either<Done, Elem>>
-  readonly right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+  readonly left: Fiber.Fiber<Either.Either<Done, Elem>, Err>
+  readonly right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
 }
 
 /**
@@ -80,8 +80,8 @@ export interface RightDone<out Env, in Err, _Err1, out Err2, _Elem, in Done, _Do
  * @category constructors
  */
 export const BothRunning: <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-  right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+  left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+  right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
 ) => MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = internal.BothRunning
 
 /**
@@ -151,8 +151,8 @@ export const match: {
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
       readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
       readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
@@ -162,8 +162,8 @@ export const match: {
     self: MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
       readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
       readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
diff --git a/packages/effect/src/MetricPolling.ts b/packages/effect/src/MetricPolling.ts
index a40ddbb4ab..508e721eb7 100644
--- a/packages/effect/src/MetricPolling.ts
+++ b/packages/effect/src/MetricPolling.ts
@@ -74,11 +74,11 @@ export const launch: {
     schedule: Schedule.Schedule<R2, unknown, A2>
   ): <Type, In, R, E, Out>(
     self: MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<Fiber.Fiber<E, A2>, never, Scope.Scope | R2 | R>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R2 | R>
   <Type, In, R, E, Out, R2, A2>(
     self: MetricPolling<Type, In, R, E, Out>,
     schedule: Schedule.Schedule<R2, unknown, A2>
-  ): Effect.Effect<Fiber.Fiber<E, A2>, never, Scope.Scope | R | R2>
+  ): Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R | R2>
 } = internal.launch
 
 /**
diff --git a/packages/effect/src/internal/channel.ts b/packages/effect/src/internal/channel.ts
index acfb4887c6..08ac577962 100644
--- a/packages/effect/src/internal/channel.ts
+++ b/packages/effect/src/internal/channel.ts
@@ -1675,7 +1675,7 @@ export const mergeWith = dual<
 
             const handleSide = <Err, Done, Err2, Done2>(
               exit: Exit.Exit<Either.Either<Done, OutElem | OutElem1>, Err>,
-              fiber: Fiber.Fiber<Err2, Either.Either<Done2, OutElem | OutElem1>>,
+              fiber: Fiber.Fiber<Either.Either<Done2, OutElem | OutElem1>, Err2>,
               pull: Effect.Effect<Either.Either<Done, OutElem | OutElem1>, Err, Env | Env1>
             ) =>
             (
@@ -1689,8 +1689,8 @@ export const mergeWith = dual<
                 OutDone2 | OutDone3
               >,
               both: (
-                f1: Fiber.Fiber<Err, Either.Either<Done, OutElem | OutElem1>>,
-                f2: Fiber.Fiber<Err2, Either.Either<Done2, OutElem | OutElem1>>
+                f1: Fiber.Fiber<Either.Either<Done, OutElem | OutElem1>, Err>,
+                f2: Fiber.Fiber<Either.Either<Done2, OutElem | OutElem1>, Err2>
               ) => State,
               single: (
                 f: (
diff --git a/packages/effect/src/internal/channel/mergeState.ts b/packages/effect/src/internal/channel/mergeState.ts
index c72ca3918e..56a6352d74 100644
--- a/packages/effect/src/internal/channel/mergeState.ts
+++ b/packages/effect/src/internal/channel/mergeState.ts
@@ -22,8 +22,8 @@ const proto = {
 
 /** @internal */
 export const BothRunning = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-  right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+  left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+  right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
 ): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_BOTH_RUNNING
@@ -84,8 +84,8 @@ export const match = dual<
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
       readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
       readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
@@ -95,8 +95,8 @@ export const match = dual<
     self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
       readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
       readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
diff --git a/packages/effect/src/internal/core.ts b/packages/effect/src/internal/core.ts
index 13f068d7a5..b731371b11 100644
--- a/packages/effect/src/internal/core.ts
+++ b/packages/effect/src/internal/core.ts
@@ -1474,13 +1474,13 @@ export const never: Effect.Effect<never> = asyncEither<never, never, never>(() =
 // -----------------------------------------------------------------------------
 
 /* @internal */
-export const interruptFiber = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<Exit.Exit<A, E>> =>
+export const interruptFiber = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<Exit.Exit<A, E>> =>
   flatMap(fiberId, (fiberId) => pipe(self, interruptAsFiber(fiberId)))
 
 /* @internal */
 export const interruptAsFiber = dual<
-  (fiberId: FiberId.FiberId) => <E, A>(self: Fiber.Fiber<E, A>) => Effect.Effect<Exit.Exit<A, E>>,
-  <E, A>(self: Fiber.Fiber<E, A>, fiberId: FiberId.FiberId) => Effect.Effect<Exit.Exit<A, E>>
+  (fiberId: FiberId.FiberId) => <A, E>(self: Fiber.Fiber<A, E>) => Effect.Effect<Exit.Exit<A, E>>,
+  <A, E>(self: Fiber.Fiber<A, E>, fiberId: FiberId.FiberId) => Effect.Effect<Exit.Exit<A, E>>
 >(2, (self, fiberId) => flatMap(self.interruptAsFork(fiberId), () => self.await))
 
 // -----------------------------------------------------------------------------
diff --git a/packages/effect/src/internal/effect/circular.ts b/packages/effect/src/internal/effect/circular.ts
index e649c02b24..d9939c1d06 100644
--- a/packages/effect/src/internal/effect/circular.ts
+++ b/packages/effect/src/internal/effect/circular.ts
@@ -206,13 +206,13 @@ const invalidateCache = <E, A>(
 /** @internal */
 export const ensuringChild = dual<
   <X, R2>(
-    f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect.Effect<X, never, R2>
+    f: (fiber: Fiber.Fiber<ReadonlyArray<unknown>, any>) => Effect.Effect<X, never, R2>
   ) => <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E, R | R2>,
   <A, E, R, X, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect.Effect<X, never, R2>
+    f: (fiber: Fiber.Fiber<ReadonlyArray<unknown>, any>) => Effect.Effect<X, never, R2>
   ) => Effect.Effect<A, E, R | R2>
 >(2, (self, f) => ensuringChildren(self, (children) => f(fiberRuntime.fiberAll(children))))
 
@@ -238,7 +238,7 @@ export const forkAll: {
     options?: {
       readonly discard?: false | undefined
     }
-  ): <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<Fiber.Fiber<E, Array<A>>, never, R>
+  ): <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<Fiber.Fiber<Array<A>, E>, never, R>
   (options: {
     readonly discard: true
   }): <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<void, never, R>
@@ -247,7 +247,7 @@ export const forkAll: {
     options?: {
       readonly discard?: false | undefined
     }
-  ): Effect.Effect<Fiber.Fiber<E, Array<A>>, never, R>
+  ): Effect.Effect<Fiber.Fiber<Array<A>, E>, never, R>
   <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>, options: {
     readonly discard: true
   }): Effect.Effect<void, never, R>
@@ -291,10 +291,10 @@ export const forkScoped = <A, E, R>(
   fiberRuntime.scopeWith((scope) => forkIn(self, scope))
 
 /** @internal */
-export const fromFiber = <E, A>(fiber: Fiber.Fiber<E, A>): Effect.Effect<A, E> => internalFiber.join(fiber)
+export const fromFiber = <E, A>(fiber: Fiber.Fiber<A, E>): Effect.Effect<A, E> => internalFiber.join(fiber)
 
 /** @internal */
-export const fromFiberEffect = <A, E, R>(fiber: Effect.Effect<Fiber.Fiber<E, A>, E, R>): Effect.Effect<A, E, R> =>
+export const fromFiberEffect = <A, E, R>(fiber: Effect.Effect<Fiber.Fiber<A, E>, E, R>): Effect.Effect<A, E, R> =>
   core.suspend(() => core.flatMap(fiber, internalFiber.join))
 
 const memoKeySymbol = Symbol.for("effect/Effect/memoizeFunction.key")
@@ -600,33 +600,33 @@ export const updateSomeAndGetEffectSynchronized = dual<
 
 /** @internal */
 export const zipFiber = dual<
-  <E2, A2>(that: Fiber.Fiber<E2, A2>) => <E, A>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, [A, A2]>,
-  <E, A, E2, A2>(self: Fiber.Fiber<E, A>, that: Fiber.Fiber<E2, A2>) => Fiber.Fiber<E | E2, [A, A2]>
+  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<[A, A2], E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<[A, A2], E | E2>
 >(2, (self, that) => zipWithFiber(self, that, (a, b) => [a, b]))
 
 /** @internal */
 export const zipLeftFiber = dual<
-  <E2, A2>(that: Fiber.Fiber<E2, A2>) => <E, A>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, A>,
-  <E, A, E2, A2>(self: Fiber.Fiber<E, A>, that: Fiber.Fiber<E2, A2>) => Fiber.Fiber<E | E2, A>
+  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A, E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<A, E | E2>
 >(2, (self, that) => zipWithFiber(self, that, (a, _) => a))
 
 /** @internal */
 export const zipRightFiber = dual<
-  <E2, A2>(that: Fiber.Fiber<E2, A2>) => <E, A>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, A2>,
-  <E, A, E2, A2>(self: Fiber.Fiber<E, A>, that: Fiber.Fiber<E2, A2>) => Fiber.Fiber<E | E2, A2>
+  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A2, E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<A2, E | E2>
 >(2, (self, that) => zipWithFiber(self, that, (_, b) => b))
 
 /** @internal */
 export const zipWithFiber = dual<
-  <E2, A, B, C>(
-    that: Fiber.Fiber<E2, B>,
+  <B, E2, A, C>(
+    that: Fiber.Fiber<B, E2>,
     f: (a: A, b: B) => C
-  ) => <E>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, C>,
-  <E, A, E2, B, C>(
-    self: Fiber.Fiber<E, A>,
-    that: Fiber.Fiber<E2, B>,
+  ) => <E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<C, E | E2>,
+  <A, E, B, E2, C>(
+    self: Fiber.Fiber<A, E>,
+    that: Fiber.Fiber<B, E2>,
     f: (a: A, b: B) => C
-  ) => Fiber.Fiber<E | E2, C>
+  ) => Fiber.Fiber<C, E | E2>
 >(3, (self, that, f) => ({
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
   id: () => pipe(self.id(), FiberId.getOrElse(that.id())),
diff --git a/packages/effect/src/internal/fiber.ts b/packages/effect/src/internal/fiber.ts
index 248c7d0fa0..8103a804c4 100644
--- a/packages/effect/src/internal/fiber.ts
+++ b/packages/effect/src/internal/fiber.ts
@@ -64,19 +64,19 @@ export const Order: order.Order<Fiber.RuntimeFiber<unknown, unknown>> = pipe(
 export const isFiber = (u: unknown): u is Fiber.Fiber<unknown, unknown> => hasProperty(u, FiberTypeId)
 
 /** @internal */
-export const isRuntimeFiber = <E, A>(self: Fiber.Fiber<E, A>): self is Fiber.RuntimeFiber<E, A> =>
+export const isRuntimeFiber = <A, E>(self: Fiber.Fiber<A, E>): self is Fiber.RuntimeFiber<E, A> =>
   RuntimeFiberTypeId in self
 
 /** @internal */
-export const _await = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<Exit.Exit<A, E>> => self.await
+export const _await = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<Exit.Exit<A, E>> => self.await
 
 /** @internal */
-export const children = <E, A>(
-  self: Fiber.Fiber<E, A>
+export const children = <A, E>(
+  self: Fiber.Fiber<A, E>
 ): Effect.Effect<Array<Fiber.RuntimeFiber<any, any>>> => self.children
 
 /** @internal */
-export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<E, A> => ({
+export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<A, E> => ({
   ...fiberProto,
   id: () => FiberId.none,
   await: core.succeed(exit),
@@ -87,7 +87,7 @@ export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<E, A> => ({
 })
 
 /** @internal */
-export const dump = <E, A>(self: Fiber.RuntimeFiber<E, A>): Effect.Effect<Fiber.Fiber.Dump> =>
+export const dump = <A, E>(self: Fiber.RuntimeFiber<E, A>): Effect.Effect<Fiber.Fiber.Dump> =>
   core.map(self.status, (status) => ({ id: self.id(), status }))
 
 /** @internal */
@@ -96,23 +96,23 @@ export const dumpAll = (
 ): Effect.Effect<Array<Fiber.Fiber.Dump>> => core.forEachSequential(fibers, dump)
 
 /** @internal */
-export const fail = <E>(error: E): Fiber.Fiber<E, never> => done(Exit.fail(error))
+export const fail = <E>(error: E): Fiber.Fiber<never, E> => done(Exit.fail(error))
 
 /** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Fiber.Fiber<E, never> => done(Exit.failCause(cause))
+export const failCause = <E>(cause: Cause.Cause<E>): Fiber.Fiber<never, E> => done(Exit.failCause(cause))
 
 /** @internal */
-export const fromEffect = <E, A>(effect: Effect.Effect<A, E>): Effect.Effect<Fiber.Fiber<E, A>> =>
+export const fromEffect = <A, E>(effect: Effect.Effect<A, E>): Effect.Effect<Fiber.Fiber<A, E>> =>
   core.map(core.exit(effect), done)
 
 /** @internal */
-export const id = <E, A>(self: Fiber.Fiber<E, A>): FiberId.FiberId => self.id()
+export const id = <A, E>(self: Fiber.Fiber<A, E>): FiberId.FiberId => self.id()
 
 /** @internal */
-export const inheritAll = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<void> => self.inheritAll
+export const inheritAll = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<void> => self.inheritAll
 
 /** @internal */
-export const interrupted = (fiberId: FiberId.FiberId): Fiber.Fiber<never, never> => done(Exit.interrupt(fiberId))
+export const interrupted = (fiberId: FiberId.FiberId): Fiber.Fiber<never> => done(Exit.interrupt(fiberId))
 
 /** @internal */
 export const interruptAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.Effect<void> =>
@@ -130,24 +130,24 @@ export const interruptAllAs = dual<
 
 /** @internal */
 export const interruptAsFork = dual<
-  (fiberId: FiberId.FiberId) => <E, A>(self: Fiber.Fiber<E, A>) => Effect.Effect<void>,
-  <E, A>(self: Fiber.Fiber<E, A>, fiberId: FiberId.FiberId) => Effect.Effect<void>
+  (fiberId: FiberId.FiberId) => <A, E>(self: Fiber.Fiber<A, E>) => Effect.Effect<void>,
+  <A, E>(self: Fiber.Fiber<A, E>, fiberId: FiberId.FiberId) => Effect.Effect<void>
 >(2, (self, fiberId) => self.interruptAsFork(fiberId))
 
 /** @internal */
-export const join = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<A, E> =>
+export const join = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<A, E> =>
   core.zipLeft(core.flatten(self.await), self.inheritAll)
 
 /** @internal */
 export const map = dual<
-  <A, B>(f: (a: A) => B) => <E>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E, B>,
-  <E, A, B>(self: Fiber.Fiber<E, A>, f: (a: A) => B) => Fiber.Fiber<E, B>
+  <A, B>(f: (a: A) => B) => <E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<B, E>,
+  <A, E, B>(self: Fiber.Fiber<A, E>, f: (a: A) => B) => Fiber.Fiber<B, E>
 >(2, (self, f) => mapEffect(self, (a) => core.sync(() => f(a))))
 
 /** @internal */
 export const mapEffect = dual<
-  <A, A2, E2>(f: (a: A) => Effect.Effect<A2, E2>) => <E>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, A2>,
-  <E, A, A2, E2>(self: Fiber.Fiber<E, A>, f: (a: A) => Effect.Effect<A2, E2>) => Fiber.Fiber<E | E2, A2>
+  <A, A2, E2>(f: (a: A) => Effect.Effect<A2, E2>) => <E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A2, E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, f: (a: A) => Effect.Effect<A2, E2>) => Fiber.Fiber<A2, E | E2>
 >(2, (self, f) => ({
   ...fiberProto,
   id: () => self.id(),
@@ -171,36 +171,36 @@ export const mapEffect = dual<
 /** @internal */
 export const mapFiber = dual<
   <E, E2, A, B>(
-    f: (a: A) => Fiber.Fiber<E2, B>
-  ) => (self: Fiber.Fiber<E, A>) => Effect.Effect<Fiber.Fiber<E | E2, B>>,
-  <E, A, E2, B>(
-    self: Fiber.Fiber<E, A>,
-    f: (a: A) => Fiber.Fiber<E2, B>
-  ) => Effect.Effect<Fiber.Fiber<E | E2, B>>
->(2, <E, A, E2, B>(
-  self: Fiber.Fiber<E, A>,
-  f: (a: A) => Fiber.Fiber<E2, B>
+    f: (a: A) => Fiber.Fiber<B, E2>
+  ) => (self: Fiber.Fiber<A, E>) => Effect.Effect<Fiber.Fiber<B, E | E2>>,
+  <A, E, E2, B>(
+    self: Fiber.Fiber<A, E>,
+    f: (a: A) => Fiber.Fiber<B, E2>
+  ) => Effect.Effect<Fiber.Fiber<B, E | E2>>
+>(2, <A, E, E2, B>(
+  self: Fiber.Fiber<A, E>,
+  f: (a: A) => Fiber.Fiber<B, E2>
 ) =>
   core.map(
     self.await,
     Exit.match({
-      onFailure: (cause): Fiber.Fiber<E | E2, B> => failCause(cause),
+      onFailure: (cause): Fiber.Fiber<B, E | E2> => failCause(cause),
       onSuccess: (a) => f(a)
     })
   ))
 
 /** @internal */
 export const match = dual<
-  <E, A, Z>(
+  <A, E, Z>(
     options: {
-      readonly onFiber: (fiber: Fiber.Fiber<E, A>) => Z
+      readonly onFiber: (fiber: Fiber.Fiber<A, E>) => Z
       readonly onRuntimeFiber: (fiber: Fiber.RuntimeFiber<E, A>) => Z
     }
-  ) => (self: Fiber.Fiber<E, A>) => Z,
-  <E, A, Z>(
-    self: Fiber.Fiber<E, A>,
+  ) => (self: Fiber.Fiber<A, E>) => Z,
+  <A, E, Z>(
+    self: Fiber.Fiber<A, E>,
     options: {
-      readonly onFiber: (fiber: Fiber.Fiber<E, A>) => Z
+      readonly onFiber: (fiber: Fiber.Fiber<A, E>) => Z
       readonly onRuntimeFiber: (fiber: Fiber.RuntimeFiber<E, A>) => Z
     }
   ) => Z
@@ -212,7 +212,7 @@ export const match = dual<
 })
 
 /** @internal */
-export const never: Fiber.Fiber<never, never> = {
+export const never: Fiber.Fiber<never> = {
   ...fiberProto,
   id: () => FiberId.none,
   await: core.never,
@@ -224,8 +224,8 @@ export const never: Fiber.Fiber<never, never> = {
 
 /** @internal */
 export const orElse = dual<
-  <E2, A2>(that: Fiber.Fiber<E2, A2>) => <E, A>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, A | A2>,
-  <E, A, E2, A2>(self: Fiber.Fiber<E, A>, that: Fiber.Fiber<E2, A2>) => Fiber.Fiber<E | E2, A | A2>
+  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A | A2, E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<A | A2, E | E2>
 >(2, (self, that) => ({
   ...fiberProto,
   id: () => FiberId.getOrElse(self.id(), that.id()),
@@ -260,12 +260,12 @@ export const orElse = dual<
 
 /** @internal */
 export const orElseEither = dual<
-  <E2, A2>(that: Fiber.Fiber<E2, A2>) => <E, A>(self: Fiber.Fiber<E, A>) => Fiber.Fiber<E | E2, Either.Either<A, A2>>,
-  <E, A, E2, A2>(self: Fiber.Fiber<E, A>, that: Fiber.Fiber<E2, A2>) => Fiber.Fiber<E | E2, Either.Either<A, A2>>
+  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<Either.Either<A, A2>, E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<Either.Either<A, A2>, E | E2>
 >(2, (self, that) => orElse(map(self, Either.left), map(that, Either.right)))
 
 /** @internal */
-export const poll = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<Option.Option<Exit.Exit<A, E>>> => self.poll
+export const poll = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<Option.Option<Exit.Exit<A, E>>> => self.poll
 
 // forked from https://github.com/sindresorhus/parse-ms/blob/4da2ffbdba02c6e288c08236695bdece0adca173/index.js
 // MIT License
@@ -300,7 +300,7 @@ const renderStatus = (status: FiberStatus.FiberStatus): string => {
 }
 
 /** @internal */
-export const pretty = <E, A>(self: Fiber.RuntimeFiber<E, A>): Effect.Effect<string> =>
+export const pretty = <A, E>(self: Fiber.RuntimeFiber<E, A>): Effect.Effect<string> =>
   core.flatMap(Clock.currentTimeMillis, (now) =>
     core.map(dump(self), (dump) => {
       const time = now - dump.id.startTimeMillis
@@ -329,13 +329,13 @@ export const unsafeRoots = (): Array<Fiber.RuntimeFiber<any, any>> => Array.from
 export const roots: Effect.Effect<Array<Fiber.RuntimeFiber<any, any>>> = core.sync(unsafeRoots)
 
 /** @internal */
-export const status = <E, A>(self: Fiber.RuntimeFiber<E, A>): Effect.Effect<FiberStatus.FiberStatus> => self.status
+export const status = <A, E>(self: Fiber.RuntimeFiber<E, A>): Effect.Effect<FiberStatus.FiberStatus> => self.status
 
 /** @internal */
-export const succeed = <A>(value: A): Fiber.Fiber<never, A> => done(Exit.succeed(value))
+export const succeed = <A>(value: A): Fiber.Fiber<A> => done(Exit.succeed(value))
 
 /** @internal */
-export const unit: Fiber.Fiber<never, void> = succeed(void 0)
+export const unit: Fiber.Fiber<void> = succeed(void 0)
 
 /** @internal */
 export const currentFiberURI = "effect/FiberCurrent"
diff --git a/packages/effect/src/internal/fiberRuntime.ts b/packages/effect/src/internal/fiberRuntime.ts
index cec92ec6b8..6530493a8f 100644
--- a/packages/effect/src/internal/fiberRuntime.ts
+++ b/packages/effect/src/internal/fiberRuntime.ts
@@ -2316,13 +2316,13 @@ export const raceAll = <A, E, R>(all: Iterable<Effect.Effect<A, E, R>>): Effect.
   }
   const self = Chunk.headNonEmpty(list)
   const effects = Chunk.tailNonEmpty(list)
-  const inheritAll = (res: readonly [A, Fiber.Fiber<E, A>]) =>
+  const inheritAll = (res: readonly [A, Fiber.Fiber<A, E>]) =>
     pipe(
       internalFiber.inheritAll(res[1]),
       core.as(res[0])
     )
   return pipe(
-    core.deferredMake<readonly [A, Fiber.Fiber<E, A>], E>(),
+    core.deferredMake<readonly [A, Fiber.Fiber<A, E>], E>(),
     core.flatMap((done) =>
       pipe(
         Ref.make(effects.length),
@@ -2378,9 +2378,9 @@ export const raceAll = <A, E, R>(all: Iterable<Effect.Effect<A, E, R>>): Effect.
 }
 
 const raceAllArbiter = <E, E1, A, A1>(
-  fibers: Iterable<Fiber.Fiber<E | E1, A | A1>>,
-  winner: Fiber.Fiber<E | E1, A | A1>,
-  deferred: Deferred.Deferred<readonly [A | A1, Fiber.Fiber<E | E1, A | A1>], E | E1>,
+  fibers: Iterable<Fiber.Fiber<A | A1, E | E1>>,
+  winner: Fiber.Fiber<A | A1, E | E1>,
+  deferred: Deferred.Deferred<readonly [A | A1, Fiber.Fiber<A | A1, E | E1>], E | E1>,
   fails: Ref.Ref<number>
 ) =>
 (exit: Exit.Exit<A | A1, E | E1>): Effect.Effect<void> =>
@@ -3061,7 +3061,7 @@ export const fiberAwaitAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.E
   core.asUnit(internalFiber._await(fiberAll(fibers)))
 
 /** @internal */
-export const fiberAll = <E, A>(fibers: Iterable<Fiber.Fiber<E, A>>): Fiber.Fiber<E, Array<A>> => ({
+export const fiberAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Fiber.Fiber<Array<A>, E> => ({
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
   id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
   await: core.exit(forEachParUnbounded(fibers, (fiber) => core.flatten(fiber.await), false)),
@@ -3102,15 +3102,15 @@ export const fiberAll = <E, A>(fibers: Iterable<Fiber.Fiber<E, A>>): Fiber.Fiber
 })
 
 /* @internal */
-export const fiberInterruptFork = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<void> =>
+export const fiberInterruptFork = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<void> =>
   core.asUnit(forkDaemon(core.interruptFiber(self)))
 
 /* @internal */
-export const fiberJoinAll = <E, A>(fibers: Iterable<Fiber.Fiber<E, A>>): Effect.Effect<void, E> =>
+export const fiberJoinAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<void, E> =>
   core.asUnit(internalFiber.join(fiberAll(fibers)))
 
 /* @internal */
-export const fiberScoped = <E, A>(self: Fiber.Fiber<E, A>): Effect.Effect<Fiber.Fiber<E, A>, never, Scope.Scope> =>
+export const fiberScoped = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<Fiber.Fiber<A, E>, never, Scope.Scope> =>
   acquireRelease(core.succeed(self), core.interruptFiber)
 
 //
@@ -3122,16 +3122,16 @@ export const raceWith = dual<
   <A1, E1, R1, E, A, A2, E2, R2, A3, E3, R3>(
     other: Effect.Effect<A1, E1, R1>,
     options: {
-      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<E1, A1>) => Effect.Effect<A2, E2, R2>
-      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<E, A>) => Effect.Effect<A3, E3, R3>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<A1, E1>) => Effect.Effect<A2, E2, R2>
+      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<A, E>) => Effect.Effect<A3, E3, R3>
     }
   ) => <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A3, E2 | E3, R | R1 | R2 | R3>,
   <A, E, R, A1, E1, R1, A2, E2, R2, A3, E3, R3>(
     self: Effect.Effect<A, E, R>,
     other: Effect.Effect<A1, E1, R1>,
     options: {
-      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<E1, A1>) => Effect.Effect<A2, E2, R2>
-      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<E, A>) => Effect.Effect<A3, E3, R3>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>, fiber: Fiber.Fiber<A1, E1>) => Effect.Effect<A2, E2, R2>
+      readonly onOtherDone: (exit: Exit.Exit<A1, E1>, fiber: Fiber.Fiber<A, E>) => Effect.Effect<A3, E3, R3>
     }
   ) => Effect.Effect<A2 | A3, E2 | E3, R | R1 | R2 | R3>
 >(3, (self, other, options) =>
diff --git a/packages/effect/src/internal/metric/polling.ts b/packages/effect/src/internal/metric/polling.ts
index 7940edbc8d..ef5079436f 100644
--- a/packages/effect/src/internal/metric/polling.ts
+++ b/packages/effect/src/internal/metric/polling.ts
@@ -68,11 +68,11 @@ export const launch = dual<
     schedule: Schedule.Schedule<R2, unknown, A2>
   ) => <Type, In, R, E, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<Fiber.Fiber<E, A2>, never, R | R2 | Scope.Scope>,
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
   <Type, In, R, E, Out, R2, A2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
     schedule: Schedule.Schedule<R2, unknown, A2>
-  ) => Effect.Effect<Fiber.Fiber<E, A2>, never, R | R2 | Scope.Scope>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) =>
   pipe(
     pollAndUpdate(self),
diff --git a/packages/effect/src/internal/stream.ts b/packages/effect/src/internal/stream.ts
index dc99e357a2..aba7a1f7c8 100644
--- a/packages/effect/src/internal/stream.ts
+++ b/packages/effect/src/internal/stream.ts
@@ -3276,7 +3276,7 @@ export const haltWhen = dual<
     effect: Effect.Effect<_, E2, R2>
   ): Stream.Stream<A, E | E2, R | R2> => {
     const writer = (
-      fiber: Fiber.Fiber<E2, _>
+      fiber: Fiber.Fiber<_, E2>
     ): Channel.Channel<R2, E | E2, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, void> =>
       pipe(
         Fiber.poll(fiber),
diff --git a/packages/effect/src/internal/stream/debounceState.ts b/packages/effect/src/internal/stream/debounceState.ts
index c076f444dc..f73deb3a15 100644
--- a/packages/effect/src/internal/stream/debounceState.ts
+++ b/packages/effect/src/internal/stream/debounceState.ts
@@ -30,13 +30,13 @@ export interface NotStarted {
 /** @internal */
 export interface Previous<out A> {
   readonly _tag: OP_PREVIOUS
-  readonly fiber: Fiber.Fiber<never, Chunk.Chunk<A>>
+  readonly fiber: Fiber.Fiber<Chunk.Chunk<A>>
 }
 
 /** @internal */
 export interface Current<out E, out A> {
   readonly _tag: OP_CURRENT
-  readonly fiber: Fiber.Fiber<E, HandoffSignal.HandoffSignal<E, A>>
+  readonly fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<E, A>, E>
 }
 
 /** @internal */
@@ -45,13 +45,13 @@ export const notStarted: DebounceState<never, never> = {
 }
 
 /** @internal */
-export const previous = <A>(fiber: Fiber.Fiber<never, Chunk.Chunk<A>>): DebounceState<never, A> => ({
+export const previous = <A>(fiber: Fiber.Fiber<Chunk.Chunk<A>>): DebounceState<never, A> => ({
   _tag: OP_PREVIOUS,
   fiber
 })
 
 /** @internal */
-export const current = <E, A>(fiber: Fiber.Fiber<E, HandoffSignal.HandoffSignal<E, A>>): DebounceState<E, A> => ({
+export const current = <E, A>(fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<E, A>, E>): DebounceState<E, A> => ({
   _tag: OP_CURRENT,
   fiber
 })
diff --git a/packages/effect/src/internal/testing/suspendedWarningData.ts b/packages/effect/src/internal/testing/suspendedWarningData.ts
index b7208125d8..5742f3062b 100644
--- a/packages/effect/src/internal/testing/suspendedWarningData.ts
+++ b/packages/effect/src/internal/testing/suspendedWarningData.ts
@@ -29,7 +29,7 @@ export interface Start {
 /** @internal */
 export interface Pending {
   readonly _tag: OP_SUSPENDED_WARNING_DATA_PENDING
-  readonly fiber: Fiber.Fiber<Error, void>
+  readonly fiber: Fiber.Fiber<void, Error>
 }
 
 /** @internal */
@@ -53,7 +53,7 @@ export const start: SuspendedWarningData = {
  *
  * @internal
  */
-export const pending = (fiber: Fiber.Fiber<Error, void>): SuspendedWarningData => {
+export const pending = (fiber: Fiber.Fiber<void, Error>): SuspendedWarningData => {
   return {
     _tag: OP_SUSPENDED_WARNING_DATA_PENDING,
     fiber
diff --git a/packages/effect/src/internal/testing/warningData.ts b/packages/effect/src/internal/testing/warningData.ts
index 973f76f730..5144dad953 100644
--- a/packages/effect/src/internal/testing/warningData.ts
+++ b/packages/effect/src/internal/testing/warningData.ts
@@ -37,7 +37,7 @@ export interface Start {
 /** @internal */
 export interface Pending {
   readonly _tag: OP_WARNING_DATA_PENDING
-  readonly fiber: Fiber.Fiber<Error, void>
+  readonly fiber: Fiber.Fiber<void, Error>
 }
 
 /** @internal */
@@ -61,7 +61,7 @@ export const start: WarningData = {
  *
  * @internal
  */
-export const pending = (fiber: Fiber.Fiber<Error, void>): WarningData => {
+export const pending = (fiber: Fiber.Fiber<void, Error>): WarningData => {
   return {
     _tag: OP_WARNING_DATA_PENDING,
     fiber
diff --git a/packages/effect/test/Effect/concurrency.test.ts b/packages/effect/test/Effect/concurrency.test.ts
index 94c79b1a0d..482b3c7770 100644
--- a/packages/effect/test/Effect/concurrency.test.ts
+++ b/packages/effect/test/Effect/concurrency.test.ts
@@ -135,7 +135,7 @@ describe("Effect", () => {
     }))
   it.live("supervise fibers", () =>
     Effect.gen(function*($) {
-      const makeChild = (n: number): Effect.Effect<Fiber.Fiber<never, void>> => {
+      const makeChild = (n: number): Effect.Effect<Fiber.Fiber<void>> => {
         return pipe(Effect.sleep(Duration.millis(20 * n)), Effect.zipRight(Effect.never), Effect.fork)
       }
       const ref = yield* $(Ref.make(0))
diff --git a/packages/effect/test/Effect/forking.test.ts b/packages/effect/test/Effect/forking.test.ts
index 9757a5eb7a..cecce33b22 100644
--- a/packages/effect/test/Effect/forking.test.ts
+++ b/packages/effect/test/Effect/forking.test.ts
@@ -90,7 +90,7 @@ describe("Effect", () => {
     Effect.gen(function*($) {
       const boom = new Error("boom")
       const die = Effect.die(boom)
-      const joinDefect = (fiber: Fiber.Fiber<never, unknown>) => {
+      const joinDefect = (fiber: Fiber.Fiber<unknown>) => {
         return pipe(fiber, Fiber.join, Effect.sandbox, Effect.flip)
       }
       const fiber1 = yield* $(Effect.forkAll([die]))
diff --git a/packages/platform-bun/src/internal/http/server.ts b/packages/platform-bun/src/internal/http/server.ts
index 3a9a4171c7..710c1a4a76 100644
--- a/packages/platform-bun/src/internal/http/server.ts
+++ b/packages/platform-bun/src/internal/http/server.ts
@@ -61,7 +61,7 @@ export const make = (
         return pipe(
           Effect.runtime<never>(),
           Effect.flatMap((runtime) =>
-            Effect.async<never, never, never>((_) => {
+            Effect.async<never>((_) => {
               const runFork = Runtime.runFork(runtime)
               function handler(request: Request, _server: BunServer) {
                 return new Promise<Response>((resolve, reject) => {
diff --git a/packages/platform-bun/src/internal/worker.ts b/packages/platform-bun/src/internal/worker.ts
index a7015b8c88..a5e9ad49ba 100644
--- a/packages/platform-bun/src/internal/worker.ts
+++ b/packages/platform-bun/src/internal/worker.ts
@@ -13,7 +13,7 @@ const platformWorkerImpl = Worker.PlatformWorker.of({
 
       yield* _(Effect.addFinalizer(() =>
         pipe(
-          Effect.async<void, never, never>((resume, signal) => {
+          Effect.async<void>((resume, signal) => {
             port.addEventListener("close", () => resume(Effect.unit), { once: true, signal })
             port.postMessage([1])
           }),
@@ -27,7 +27,7 @@ const platformWorkerImpl = Worker.PlatformWorker.of({
       const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
 
       const fiber = yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
+        Effect.async<never, WorkerError>((resume) => {
           function onMessage(event: MessageEvent) {
             queue.unsafeOffer((event as MessageEvent).data)
           }
diff --git a/packages/platform-bun/src/internal/workerRunner.ts b/packages/platform-bun/src/internal/workerRunner.ts
index 32b7f6a382..3356d9f357 100644
--- a/packages/platform-bun/src/internal/workerRunner.ts
+++ b/packages/platform-bun/src/internal/workerRunner.ts
@@ -20,7 +20,7 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
       const port = self
       const queue = yield* _(Queue.unbounded<I>())
       yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
+        Effect.async<never, WorkerError>((resume) => {
           function onMessage(event: MessageEvent) {
             const message = (event as MessageEvent).data as Runner.BackingRunner.Message<I>
             if (message[0] === 0) {
diff --git a/packages/platform-node-shared/src/internal/commandExecutor.ts b/packages/platform-node-shared/src/internal/commandExecutor.ts
index 955c2f3089..18cf3d5cb8 100644
--- a/packages/platform-node-shared/src/internal/commandExecutor.ts
+++ b/packages/platform-node-shared/src/internal/commandExecutor.ts
@@ -46,7 +46,7 @@ const runCommand =
         const spawn = Effect.flatMap(
           Deferred.make<ExitCode>(),
           (exitCode) =>
-            Effect.async<readonly [ChildProcess.ChildProcess, ExitCodeDeferred], Error.PlatformError, never>(
+            Effect.async<readonly [ChildProcess.ChildProcess, ExitCodeDeferred], Error.PlatformError>(
               (resume) => {
                 const handle = ChildProcess.spawn(command.command, command.args, {
                   stdio: [
diff --git a/packages/platform-node-shared/src/internal/fileSystem.ts b/packages/platform-node-shared/src/internal/fileSystem.ts
index 2afdc01fd1..b80a22938f 100644
--- a/packages/platform-node-shared/src/internal/fileSystem.ts
+++ b/packages/platform-node-shared/src/internal/fileSystem.ts
@@ -402,7 +402,7 @@ const readDirectory = (() => {
 // == readFile
 
 const readFile = (path: string) =>
-  Effect.async<Uint8Array, Error.PlatformError, never>((resume, signal) => {
+  Effect.async<Uint8Array, Error.PlatformError>((resume, signal) => {
     try {
       NFS.readFile(path, { signal }, (err, data) => {
         if (err) {
@@ -527,7 +527,7 @@ const utimes = (() => {
 // == writeFile
 
 const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFileOptions) =>
-  Effect.async<void, Error.PlatformError, never>((resume, signal) => {
+  Effect.async<void, Error.PlatformError>((resume, signal) => {
     try {
       NFS.writeFile(path, data, {
         signal,
diff --git a/packages/platform-node-shared/src/internal/stream.ts b/packages/platform-node-shared/src/internal/stream.ts
index fbcd68b0fa..26656fbdb2 100644
--- a/packages/platform-node-shared/src/internal/stream.ts
+++ b/packages/platform-node-shared/src/internal/stream.ts
@@ -225,7 +225,7 @@ export const writeInput = <IE, A>(
 ): AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<A>, unknown> => {
   const write = writeEffect(writable, encoding)
   const close = endOnDone
-    ? Effect.async<void, never, never>((resume) => {
+    ? Effect.async<void>((resume) => {
       if ("closed" in writable && writable.closed) {
         resume(Effect.unit)
       } else {
@@ -250,7 +250,7 @@ export const writeEffect = <A>(
 (chunk: Chunk.Chunk<A>) =>
   chunk.length === 0 ?
     Effect.unit :
-    Effect.async<void, never, never>((resume) => {
+    Effect.async<void>((resume) => {
       const iterator = chunk[Symbol.iterator]()
       let next = iterator.next()
       function loop() {
diff --git a/packages/platform-node-shared/src/internal/terminal.ts b/packages/platform-node-shared/src/internal/terminal.ts
index 14a3caed0a..9cbfe49c8a 100644
--- a/packages/platform-node-shared/src/internal/terminal.ts
+++ b/packages/platform-node-shared/src/internal/terminal.ts
@@ -44,7 +44,7 @@ export const make = (
 
     // Handle the `"keypress"` event emitted by `stdin` (forced by readline)
     const handleKeypressEvent = (input: typeof globalThis.process.stdin) =>
-      Effect.async<Terminal.UserInput, Terminal.QuitException, never>((resume) => {
+      Effect.async<Terminal.UserInput, Terminal.QuitException>((resume) => {
         const handleKeypress = (input: string | undefined, key: readline.Key) => {
           const userInput: Terminal.UserInput = {
             input: Option.fromNullable(input),
diff --git a/packages/platform-node/src/internal/http/client.ts b/packages/platform-node/src/internal/http/client.ts
index 91adf2c2bb..d8a99e07d4 100644
--- a/packages/platform-node/src/internal/http/client.ts
+++ b/packages/platform-node/src/internal/http/client.ts
@@ -142,7 +142,7 @@ const sendBody = (
   })
 
 const waitForResponse = (nodeRequest: Http.ClientRequest, request: ClientRequest.ClientRequest) =>
-  Effect.async<Http.IncomingMessage, Error.RequestError, never>((resume) => {
+  Effect.async<Http.IncomingMessage, Error.RequestError>((resume) => {
     function onError(error: Error) {
       resume(Effect.fail(Error.RequestError({
         request,
@@ -167,7 +167,7 @@ const waitForResponse = (nodeRequest: Http.ClientRequest, request: ClientRequest
   })
 
 const waitForFinish = (nodeRequest: Http.ClientRequest, request: ClientRequest.ClientRequest) =>
-  Effect.async<void, Error.RequestError, never>((resume) => {
+  Effect.async<void, Error.RequestError>((resume) => {
     function onError(error: Error) {
       resume(Effect.fail(Error.RequestError({
         request,
diff --git a/packages/platform-node/src/internal/http/server.ts b/packages/platform-node/src/internal/http/server.ts
index dacfdb9ecd..57ff2a62d9 100644
--- a/packages/platform-node/src/internal/http/server.ts
+++ b/packages/platform-node/src/internal/http/server.ts
@@ -39,7 +39,7 @@ export const make = (
     const server = yield* _(Effect.acquireRelease(
       Effect.sync(evaluate),
       (server) =>
-        Effect.async<void, never, never>((resume) => {
+        Effect.async<void>((resume) => {
           server.close((error) => {
             if (error) {
               resume(Effect.die(error))
@@ -50,7 +50,7 @@ export const make = (
         })
     ))
 
-    yield* _(Effect.async<void, Error.ServeError, never>((resume) => {
+    yield* _(Effect.async<void, Error.ServeError>((resume) => {
       server.on("error", (error) => {
         resume(Effect.fail(Error.ServeError({ error })))
       })
@@ -323,7 +323,7 @@ const handleResponse = (request: ServerRequest.ServerRequest, response: ServerRe
         return Effect.unit
       }
       case "FormData": {
-        return Effect.async<void, Error.ResponseError, never>((resume) => {
+        return Effect.async<void, Error.ResponseError>((resume) => {
           const r = new Response(body.formData)
           const headers = {
             ...response.headers,
diff --git a/packages/platform-node/src/internal/worker.ts b/packages/platform-node/src/internal/worker.ts
index 0c387e7128..68d5b7785b 100644
--- a/packages/platform-node/src/internal/worker.ts
+++ b/packages/platform-node/src/internal/worker.ts
@@ -13,7 +13,7 @@ const platformWorkerImpl = Worker.PlatformWorker.of({
       const worker = worker_ as WorkerThreads.Worker
       yield* _(Effect.addFinalizer(() =>
         pipe(
-          Effect.async<void, never, never>((resume) => {
+          Effect.async<void>((resume) => {
             worker.once("exit", () => {
               resume(Effect.unit)
             })
@@ -26,7 +26,7 @@ const platformWorkerImpl = Worker.PlatformWorker.of({
       const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
       yield* _(Effect.addFinalizer(() => Queue.shutdown(queue)))
       const fiber = yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
+        Effect.async<never, WorkerError>((resume) => {
           worker.on("message", (message: Worker.BackingWorker.Message<O>) => {
             queue.unsafeOffer(message)
           })
diff --git a/packages/platform-node/src/internal/workerRunner.ts b/packages/platform-node/src/internal/workerRunner.ts
index cf03ff4799..960c4d521d 100644
--- a/packages/platform-node/src/internal/workerRunner.ts
+++ b/packages/platform-node/src/internal/workerRunner.ts
@@ -19,7 +19,7 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
       const port = WorkerThreads.parentPort
       const queue = yield* _(Queue.unbounded<I>())
       yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
+        Effect.async<never, WorkerError>((resume) => {
           port.on("message", (message: Runner.BackingRunner.Message<I>) => {
             if (message[0] === 0) {
               queue.unsafeOffer(message[1])
diff --git a/packages/platform/src/Worker.ts b/packages/platform/src/Worker.ts
index d404498d0a..f9fc38d7bf 100644
--- a/packages/platform/src/Worker.ts
+++ b/packages/platform/src/Worker.ts
@@ -24,7 +24,7 @@ import type { WorkerError } from "./WorkerError.js"
  * @category models
  */
 export interface BackingWorker<I, O> {
-  readonly fiber: Fiber.Fiber<WorkerError, never>
+  readonly fiber: Fiber.Fiber<never, WorkerError>
   readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<void, WorkerError>
   readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
 }
diff --git a/packages/platform/src/internal/effectify.ts b/packages/platform/src/internal/effectify.ts
index 8230476c5b..7680b435ad 100644
--- a/packages/platform/src/internal/effectify.ts
+++ b/packages/platform/src/internal/effectify.ts
@@ -16,7 +16,7 @@ export const effectify: {
 } =
   (<A>(fn: Function, onError?: (e: any, args: any) => any, onSyncError?: (e: any, args: any) => any) =>
   (...args: Array<any>) =>
-    Effect.async<A, Error, never>((resume) => {
+    Effect.async<A, Error>((resume) => {
       try {
         fn(...args, (err: Error | null, result: A) => {
           if (err) {
diff --git a/packages/platform/src/internal/workerRunner.ts b/packages/platform/src/internal/workerRunner.ts
index 424c2cf1f9..dc469ba6fc 100644
--- a/packages/platform/src/internal/workerRunner.ts
+++ b/packages/platform/src/internal/workerRunner.ts
@@ -46,7 +46,7 @@ export const make = <I, R, E, O>(
       platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E>>(shutdown),
       Scope.extend(scope)
     )
-    const fiberMap = new Map<number, Fiber.Fiber<never, void>>()
+    const fiberMap = new Map<number, Fiber.Fiber<void>>()
 
     yield* _(
       Queue.take(backing.queue),