@typed/fx 1.22.2 → 1.23.0

package/src/RefSubject.ts

@@ -95,8 +95,8 @@ export interface RefSubject<out R, in out E, in out A> extends Computed<R, E, A>
    * @since 1.20.0
    */
   readonly runUpdates: <R2, E2, B>(
-    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>
-  ) => Effect.Effect<R | R2, E2, B>
+    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<B, E2, R2>
+  ) => Effect.Effect<B, E2, R | R2>
 }
 
 /**
@@ -124,9 +124,9 @@ export namespace RefSubject {
      * @since 1.20.0
      */
     readonly make: <R>(
-      fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A>,
+      fxOrEffect: Fx<R, E, A> | Effect.Effect<A, E, R>,
       options?: RefSubjectOptions<A>
-    ) => Layer.Layer<R, never, I>
+    ) => Layer.Layer<I, never, R>
   }
 
   /**
@@ -135,7 +135,7 @@ export namespace RefSubject {
    * @category models
    */
   export interface Derived<R, E, A> extends RefSubject<R, E, A> {
-    readonly persist: Effect.Effect<R, never, void>
+    readonly persist: Effect.Effect<void, never, R>
   }
 
   /**
@@ -193,9 +193,9 @@ export interface RefSubjectOptions<A> {
  * @since 1.20.0
  */
 export function fromEffect<R, E, A>(
-  effect: Effect.Effect<R, E, A>,
+  effect: Effect.Effect<A, E, R>,
   options?: RefSubjectOptions<A>
-): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>> {
+): Effect.Effect<RefSubject<never, E, A>, never, R | Scope.Scope> {
   return Effect.map(makeCore(effect, options), (core) => new RefSubjectImpl(core))
 }
 
@@ -205,7 +205,7 @@ export function fromEffect<R, E, A>(
 export function fromFx<R, E, A>(
   fx: Fx<R, E, A>,
   options?: RefSubjectOptions<A>
-): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>> {
+): Effect.Effect<RefSubject<never, E, A>, never, R | Scope.Scope> {
   return DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? Equal.equals)).pipe(
     Effect.bindTo("deferredRef"),
     Effect.bind("core", ({ deferredRef }) => makeCore(deferredRef, options)),
@@ -231,7 +231,7 @@ export function fromFx<R, E, A>(
 export function fromRefSubject<R, E, A>(
   ref: RefSubject<R, E, A>,
   options?: RefSubjectOptions<A>
-): Effect.Effect<R | Scope.Scope, never, RefSubject.Derived<never, E, A>> {
+): Effect.Effect<RefSubject.Derived<never, E, A>, never, R | Scope.Scope> {
   return DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? Equal.equals)).pipe(
     Effect.bindTo("deferredRef"),
     Effect.bind("core", ({ deferredRef }) => makeCore<R, E, A>(deferredRef, options)),
@@ -265,21 +265,21 @@ export const make: {
   <R, E, A>(
     ref: RefSubject<R, E, A>,
     options?: RefSubjectOptions<A>
-  ): Effect.Effect<R | Scope.Scope, never, RefSubject.Derived<never, E, A>>
+  ): Effect.Effect<RefSubject.Derived<never, E, A>, never, R | Scope.Scope>
 
   <R, E, A>(
-    fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A>,
+    fxOrEffect: Fx<R, E, A> | Effect.Effect<A, E, R>,
     options?: RefSubjectOptions<A>
-  ): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>
+  ): Effect.Effect<RefSubject<never, E, A>, never, R | Scope.Scope>
 
   <R, E, A>(
-    fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A> | RefSubject<R, E, A>,
+    fxOrEffect: Fx<R, E, A> | Effect.Effect<A, E, R> | RefSubject<R, E, A>,
     options?: RefSubjectOptions<A>
-  ): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A> | RefSubject.Derived<never, E, A>>
+  ): Effect.Effect<RefSubject<never, E, A> | RefSubject.Derived<never, E, A>, never, R | Scope.Scope>
 } = function make<R, E, A>(
-  fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A> | RefSubject<R, E, A>,
+  fxOrEffect: Fx<R, E, A> | Effect.Effect<A, E, R> | RefSubject<R, E, A>,
   options?: RefSubjectOptions<A>
-): Effect.Effect<R | Scope.Scope, never, any> {
+): Effect.Effect<any, never, R | Scope.Scope> {
   if (RefSubjectTypeId in fxOrEffect) return fromRefSubject(fxOrEffect as RefSubject<R, E, A>, options)
   else if (TypeId in fxOrEffect) return fromFx(fxOrEffect, options)
   else return fromEffect(fxOrEffect, options)
@@ -291,7 +291,7 @@ export const make: {
 export function of<A, E = never>(
   a: A,
   options?: RefSubjectOptions<A>
-): Effect.Effect<Scope.Scope, never, RefSubject<never, E, A>> {
+): Effect.Effect<RefSubject<never, E, A>, never, Scope.Scope> {
   return Effect.acquireRelease(
     withScopeAndFiberId(
       (scope, id) =>
@@ -309,7 +309,7 @@ export function of<A, E = never>(
 }
 
 const withScopeAndFiberId = <R, E, A>(
-  f: (scope: Scope.CloseableScope, id: FiberId.FiberId) => Effect.Effect<R, E, A>,
+  f: (scope: Scope.CloseableScope, id: FiberId.FiberId) => Effect.Effect<A, E, R>,
   strategy: ExecutionStrategy.ExecutionStrategy
 ) => Effect.fiberIdWith((id) => withScope((scope) => f(scope, id), strategy))
 
@@ -321,12 +321,12 @@ const emptyContext = C.empty()
 export function unsafeMake<E, A>(
   params: {
     readonly id: FiberId.FiberId
-    readonly initial: Effect.Effect<never, E, A>
+    readonly initial: Effect.Effect<A, E>
     readonly options?: RefSubjectOptions<A> | undefined
     readonly scope: Scope.CloseableScope
     readonly initialValue?: A
   }
-): Effect.Effect<never, never, RefSubject<never, E, A>> {
+): Effect.Effect<RefSubject<never, E, A>> {
   const { id, initial, options, scope } = params
   return Effect.suspend(() => {
     const core = unsafeMakeCore(initial, id, emptyContext, scope, options)
@@ -348,9 +348,9 @@ class RefSubjectImpl<R, E, A, R2> extends FxEffectBase<Exclude<R, R2> | Scope.Sc
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<never, never, number>
-  readonly interrupt: Effect.Effect<Exclude<R, R2>, never, void>
-  readonly subscriberCount: Effect.Effect<Exclude<R, R2>, never, number>
+  readonly version: Effect.Effect<number>
+  readonly interrupt: Effect.Effect<void, never, Exclude<R, R2>>
+  readonly subscriberCount: Effect.Effect<number, never, Exclude<R, R2>>
 
   private readonly getSetDelete: GetSetDelete<Exclude<R, R2>, E, A>
 
@@ -369,7 +369,7 @@ class RefSubjectImpl<R, E, A, R2> extends FxEffectBase<Exclude<R, R2> | Scope.Sc
     this.onFailure = this.onFailure.bind(this)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<Exclude<R, R2> | R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<unknown, never, Exclude<R, R2> | R3 | Scope.Scope> {
     return Effect.matchCauseEffect(getOrInitializeCore(this.core, true), {
       onFailure: (cause) => sink.onFailure(cause),
       onSuccess: () => Effect.provide(this.core.subject.run(sink), this.core.context)
@@ -377,20 +377,20 @@ class RefSubjectImpl<R, E, A, R2> extends FxEffectBase<Exclude<R, R2> | Scope.Sc
   }
 
   runUpdates<R3, E3, B>(
-    run: (ref: GetSetDelete<Exclude<R, R2>, E, A>) => Effect.Effect<R3, E3, B>
+    run: (ref: GetSetDelete<Exclude<R, R2>, E, A>) => Effect.Effect<B, E3, R3>
   ) {
     return this.core.semaphore.withPermits(1)(run(this.getSetDelete))
   }
 
-  onSuccess(value: A): Effect.Effect<Exclude<R, R2>, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, Exclude<R, R2>> {
     return setCore(this.core, value)
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<Exclude<R, R2>, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, Exclude<R, R2>> {
     return onFailureCore(this.core, cause)
   }
 
-  toEffect(): Effect.Effect<Exclude<R, R2>, E, A> {
+  toEffect(): Effect.Effect<A, E, Exclude<R, R2>> {
     return getOrInitializeCore(this.core, true)
   }
 }
@@ -398,7 +398,7 @@ class RefSubjectImpl<R, E, A, R2> extends FxEffectBase<Exclude<R, R2> | Scope.Sc
 class DerivedImpl<R, E, A, R2> extends RefSubjectImpl<R, E, A, R2> implements RefSubject.Derived<Exclude<R, R2>, E, A> {
   constructor(
     core: RefSubjectCore<R, E, A, R2>,
-    readonly persist: Effect.Effect<Exclude<R, R2>, never, void>
+    readonly persist: Effect.Effect<void, never, Exclude<R, R2>>
   ) {
     super(core)
   }
@@ -408,16 +408,16 @@ class DerivedImpl<R, E, A, R2> extends RefSubjectImpl<R, E, A, R2> implements Re
  * @since 1.20.0
  */
 export const set: {
-  <A>(value: A): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R, E, A>
-  <R, E, A>(ref: RefSubject<R, E, A>, a: A): Effect.Effect<R, E, A>
-} = dual(2, function set<R, E, A>(ref: RefSubject<R, E, A>, a: A): Effect.Effect<R, E, A> {
+  <A>(value: A): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<A, E, R>
+  <R, E, A>(ref: RefSubject<R, E, A>, a: A): Effect.Effect<A, E, R>
+} = dual(2, function set<R, E, A>(ref: RefSubject<R, E, A>, a: A): Effect.Effect<A, E, R> {
   return ref.runUpdates((ref) => ref.set(a))
 })
 
 /**
  * @since 1.20.0
  */
-export function reset<R, E, A>(ref: RefSubject<R, E, A>): Effect.Effect<R, E, Option.Option<A>> {
+export function reset<R, E, A>(ref: RefSubject<R, E, A>): Effect.Effect<Option.Option<A>, E, R> {
   return ref.runUpdates((ref) => ref.delete)
 }
 
@@ -438,15 +438,15 @@ export interface GetSetDelete<R, E, A> {
   /**
    * @since 1.20.0
    */
-  readonly get: Effect.Effect<R, E, A>
+  readonly get: Effect.Effect<A, E, R>
   /**
    * @since 1.20.0
    */
-  readonly set: (a: A) => Effect.Effect<R, never, A>
+  readonly set: (a: A) => Effect.Effect<A, never, R>
   /**
    * @since 1.20.0
    */
-  readonly delete: Effect.Effect<R, E, Option.Option<A>>
+  readonly delete: Effect.Effect<Option.Option<A>, E, R>
 }
 
 function getSetDelete<R, E, A, R2>(ref: RefSubjectCore<R, E, A, R2>): GetSetDelete<Exclude<R, R2>, E, A> {
@@ -462,15 +462,15 @@ function getSetDelete<R, E, A, R2>(ref: RefSubjectCore<R, E, A, R2>): GetSetDele
  */
 export const updateEffect: {
   <A, R2, E2>(
-    f: (value: A) => Effect.Effect<R2, E2, A>
-  ): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R | R2, E | E2, A>
+    f: (value: A) => Effect.Effect<A, E2, R2>
+  ): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<A, E | E2, R | R2>
   <R, E, A, R2, E2>(
     ref: RefSubject<R, E, A>,
-    f: (value: A) => Effect.Effect<R2, E2, A>
-  ): Effect.Effect<R | R2, E | E2, A>
+    f: (value: A) => Effect.Effect<A, E2, R2>
+  ): Effect.Effect<A, E | E2, R | R2>
 } = dual(2, function updateEffect<R, E, A, R2, E2>(
   ref: RefSubject<R, E, A>,
-  f: (value: A) => Effect.Effect<R2, E2, A>
+  f: (value: A) => Effect.Effect<A, E2, R2>
 ) {
   return ref.runUpdates((ref) => Effect.flatMap(Effect.flatMap(ref.get, f), ref.set))
 })
@@ -479,8 +479,8 @@ export const updateEffect: {
  * @since 1.20.0
  */
 export const update: {
-  <A>(f: (value: A) => A): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R, E, A>
-  <R, E, A>(ref: RefSubject<R, E, A>, f: (value: A) => A): Effect.Effect<R, E, A>
+  <A>(f: (value: A) => A): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<A, E, R>
+  <R, E, A>(ref: RefSubject<R, E, A>, f: (value: A) => A): Effect.Effect<A, E, R>
 } = dual(2, function update<R, E, A>(ref: RefSubject<R, E, A>, f: (value: A) => A) {
   return updateEffect(ref, (value) => Effect.succeed(f(value)))
 })
@@ -490,15 +490,15 @@ export const update: {
  */
 export const modifyEffect: {
   <A, R2, E2, B>(
-    f: (value: A) => Effect.Effect<R2, E2, readonly [B, A]>
-  ): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R | R2, E | E2, B>
+    f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>
+  ): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<B, E | E2, R | R2>
   <R, E, A, R2, E2, B>(
     ref: RefSubject<R, E, A>,
-    f: (value: A) => Effect.Effect<R2, E2, readonly [B, A]>
-  ): Effect.Effect<R | R2, E | E2, B>
+    f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>
+  ): Effect.Effect<B, E | E2, R | R2>
 } = dual(2, function modifyEffect<R, E, A, R2, E2, B>(
   ref: RefSubject<R, E, A>,
-  f: (value: A) => Effect.Effect<R2, E2, readonly [B, A]>
+  f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>
 ) {
   return ref.runUpdates(
     (ref) =>
@@ -513,8 +513,8 @@ export const modifyEffect: {
  * @since 1.20.0
  */
 export const modify: {
-  <A, B>(f: (value: A) => readonly [B, A]): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<R, E, B>
-  <R, E, A, B>(ref: RefSubject<R, E, A>, f: (value: A) => readonly [B, A]): Effect.Effect<R, E, B>
+  <A, B>(f: (value: A) => readonly [B, A]): <R, E>(ref: RefSubject<R, E, A>) => Effect.Effect<B, E, R>
+  <R, E, A, B>(ref: RefSubject<R, E, A>, f: (value: A) => readonly [B, A]): Effect.Effect<B, E, R>
 } = dual(2, function modify<R, E, A, B>(ref: RefSubject<R, E, A>, f: (value: A) => readonly [B, A]) {
   return modifyEffect(ref, (value) => Effect.succeed(f(value)))
 })
@@ -526,26 +526,26 @@ const isRefSubjectDataFirst = (args: IArguments) => isRefSubject(args[0])
  */
 export const runUpdates: {
   <R, E, A, R2, E2, B, R3 = never, E3 = never, C = never>(
-    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>,
+    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<B, E2, R2>,
     options?:
-      | { readonly onInterrupt: (value: A) => Effect.Effect<R3, E3, C>; readonly value?: "initial" | "current" }
+      | { readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>; readonly value?: "initial" | "current" }
       | undefined
-  ): (ref: RefSubject<R, E, A>) => Effect.Effect<R | R2 | R3, E | E2 | E3, B>
+  ): (ref: RefSubject<R, E, A>) => Effect.Effect<B, E | E2 | E3, R | R2 | R3>
 
   <R, E, A, R2, E2, B, R3 = never, E3 = never, C = never>(
     ref: RefSubject<R, E, A>,
-    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>,
+    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<B, E2, R2>,
     options?:
-      | { readonly onInterrupt: (value: A) => Effect.Effect<R3, E3, C>; readonly value?: "initial" | "current" }
+      | { readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>; readonly value?: "initial" | "current" }
       | undefined
-  ): Effect.Effect<R | R2 | R3, E | E2 | E3, B>
+  ): Effect.Effect<B, E | E2 | E3, R | R2 | R3>
 } = dual(
   isRefSubjectDataFirst,
   function runUpdates<R, E, A, R2, E2, B, R3 = never, E3 = never, C = never>(
     ref: RefSubject<R, E, A>,
-    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, B>,
+    f: (ref: GetSetDelete<R, E, A>) => Effect.Effect<B, E2, R2>,
     options?: {
-      readonly onInterrupt: (value: A) => Effect.Effect<R3, E3, C>
+      readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>
       readonly value?: "initial" | "current"
     }
   ) {
@@ -587,7 +587,7 @@ export const runUpdates: {
 
 class RefSubjectCore<R, E, A, R2> {
   constructor(
-    readonly initial: Effect.Effect<R, E, A>,
+    readonly initial: Effect.Effect<A, E, R>,
     readonly subject: Subject.Subject<R, E, A>,
     readonly context: C.Context<R2>,
     readonly scope: Scope.CloseableScope,
@@ -595,11 +595,11 @@ class RefSubjectCore<R, E, A, R2> {
     readonly semaphore: Effect.Semaphore
   ) {}
 
-  public _fiber: Fiber.Fiber<E, A> | undefined = undefined
+  public _fiber: Fiber.Fiber<A, E> | undefined = undefined
 }
 
 function makeCore<R, E, A>(
-  initial: Effect.Effect<R, E, A>,
+  initial: Effect.Effect<A, E, R>,
   options?: RefSubjectOptions<A>
 ) {
   return Effect.context<R | Scope.Scope>().pipe(
@@ -629,7 +629,7 @@ function makeCore<R, E, A>(
 }
 
 function unsafeMakeCore<R, E, A>(
-  initial: Effect.Effect<R, E, A>,
+  initial: Effect.Effect<A, E, R>,
   id: FiberId.FiberId,
   ctx: C.Context<R>,
   scope: Scope.CloseableScope,
@@ -648,7 +648,7 @@ function unsafeMakeCore<R, E, A>(
 function getOrInitializeCore<R, E, A, R2>(
   core: RefSubjectCore<R, E, A, R2>,
   lockInitialize: boolean
-): Effect.Effect<Exclude<R, R2>, E, A> {
+): Effect.Effect<A, E, Exclude<R, R2>> {
   return Effect.suspend(() => {
     if (core._fiber === undefined && Option.isNone(core.deferredRef.current)) {
       return initializeCoreAndTap(core, lockInitialize)
@@ -661,7 +661,7 @@ function getOrInitializeCore<R, E, A, R2>(
 function initializeCoreEffect<R, E, A, R2>(
   core: RefSubjectCore<R, E, A, R2>,
   lock: boolean
-): Effect.Effect<Exclude<R, R2>, never, Fiber.Fiber<E, A>> {
+): Effect.Effect<Fiber.Fiber<A, E>, never, Exclude<R, R2>> {
   const initialize = Effect.onExit(
     Effect.provide(core.initial, core.context),
     (exit) =>
@@ -683,8 +683,8 @@ function initializeCoreEffect<R, E, A, R2>(
 function initializeCore<R, E, A, R2>(
   core: RefSubjectCore<R, E, A, R2>,
   lock: boolean
-): Effect.Effect<Exclude<R, R2>, never, Fiber.Fiber<E, A>> {
-  type Z = Effect.Effect<Exclude<R, R2>, never, Fiber.Fiber<E, A>>
+): Effect.Effect<Fiber.Fiber<A, E>, never, Exclude<R, R2>> {
+  type Z = Effect.Effect<Fiber.Fiber<A, E>, never, Exclude<R, R2>>
 
   const onSuccess = (a: A): Z => {
     core.deferredRef.done(Exit.succeed(a))
@@ -713,14 +713,14 @@ function initializeCore<R, E, A, R2>(
 function initializeCoreAndTap<R, E, A, R2>(
   core: RefSubjectCore<R, E, A, R2>,
   lock: boolean
-): Effect.Effect<Exclude<R, R2>, E, A> {
+): Effect.Effect<A, E, Exclude<R, R2>> {
   return Effect.zipRight(
     initializeCore(core, lock),
     tapEventCore(core, core.deferredRef)
   )
 }
 
-function setCore<R, E, A, R2>(core: RefSubjectCore<R, E, A, R2>, a: A): Effect.Effect<Exclude<R, R2>, never, A> {
+function setCore<R, E, A, R2>(core: RefSubjectCore<R, E, A, R2>, a: A): Effect.Effect<A, never, Exclude<R, R2>> {
   const exit = Exit.succeed(a)
 
   return Effect.suspend(() => {
@@ -746,7 +746,7 @@ function onFailureCore<R, E, A, R2>(core: RefSubjectCore<R, E, A, R2>, cause: Ca
   })
 }
 
-function interruptCore<R, E, A, R2>(core: RefSubjectCore<R, E, A, R2>): Effect.Effect<R, never, void> {
+function interruptCore<R, E, A, R2>(core: RefSubjectCore<R, E, A, R2>): Effect.Effect<void, never, R> {
   return Effect.fiberIdWith((id) => {
     core.deferredRef.reset()
 
@@ -760,7 +760,7 @@ function interruptCore<R, E, A, R2>(core: RefSubjectCore<R, E, A, R2>): Effect.E
 
 function deleteCore<R, E, A, R2>(
   core: RefSubjectCore<R, E, A, R2>
-): Effect.Effect<Exclude<R, R2>, E, Option.Option<A>> {
+): Effect.Effect<Option.Option<A>, E, Exclude<R, R2>> {
   return Effect.suspend(() => {
     const current = core.deferredRef.current
     core.deferredRef.reset()
@@ -781,7 +781,7 @@ function deleteCore<R, E, A, R2>(
 
 function tapEventCore<R, E, A, R2, R3>(
   core: RefSubjectCore<R, E, A, R2>,
-  effect: Effect.Effect<R3, E, A>
+  effect: Effect.Effect<A, E, R3>
 ) {
   return effect.pipe(
     Effect.exit,
@@ -792,8 +792,8 @@ function tapEventCore<R, E, A, R2, R3>(
 
 function sendEvent<R, E, A, R2>(
   core: RefSubjectCore<R, E, A, R2>,
-  exit: Exit.Exit<E, A>
-): Effect.Effect<Exclude<R, R2>, never, unknown> {
+  exit: Exit.Exit<A, E>
+): Effect.Effect<unknown, never, Exclude<R, R2>> {
   if (Exit.isSuccess(exit)) {
     return Effect.provide(core.subject.onSuccess(exit.value), core.context)
   } else {
@@ -806,33 +806,33 @@ function sendEvent<R, E, A, R2>(
  */
 export const mapEffect: {
   <A, R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>
+    f: (a: A) => Effect.Effect<B, E2, R2>
   ): {
     <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A>): Computed<R | R2, E | E2, B>
     <R, E>(ref: Filtered<R, E, A>): Filtered<R | R2, E | E2, B>
     <R0, E0, R, E, R2, E2, C>(
       versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-      f: (a: A) => Effect.Effect<R2, E2, C>
+      f: (a: A) => Effect.Effect<C, E2, R2>
     ): Computed<R0 | R2, E0 | E | E2, C>
   }
 
   <R, E, A, R2, E2, B>(
     ref: RefSubject<R, E, A> | Computed<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>
+    f: (a: A) => Effect.Effect<B, E2, R2>
   ): Computed<R | R2, E | E2, B>
 
   <R, E, A, R2, E2, B>(
     ref: Filtered<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>
+    f: (a: A) => Effect.Effect<B, E2, R2>
   ): Filtered<R | R2, E | E2, B>
 
   <R0, E0, R, E, A, R2, E2, R3, E3, C>(
     versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    f: (a: A) => Effect.Effect<R3, E3, C>
+    f: (a: A) => Effect.Effect<C, E3, R3>
   ): Computed<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, C>
 } = dual(2, function mapEffect<R0, E0, R, E, A, R2, E2, R3, E3, C>(
   versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-  f: (a: A) => Effect.Effect<R3, E3, C>
+  f: (a: A) => Effect.Effect<C, E3, R3>
 ):
   | Computed<R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3, E0 | E | E2 | E3, C>
   | Filtered<R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3, E0 | E | E2 | E3, C>
@@ -882,27 +882,27 @@ export const map: {
  */
 export const filterMapEffect: {
   <A, R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
   ): {
     <R, E>(ref: RefSubject<R, E, A> | Computed<R, E, A>): Filtered<R | R2, E | E2, B>
     <R, E>(ref: Filtered<R, E, A>): Filtered<R | R2, E | E2, B>
     <R0, E0, R, E, R2, E2, B>(
       versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-      f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+      f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
     ): Filtered<R0 | R2, E0 | E | E2, B>
   }
 
   <R, E, A, R2, E2, B>(
     ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
   ): Filtered<R | R2, E | E2, B>
   <R0, E0, R, E, A, R2, E2, B, R3, E3>(
     versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    f: (a: A) => Effect.Effect<R3, E3, Option.Option<B>>
+    f: (a: A) => Effect.Effect<Option.Option<B>, E3, R3>
   ): Filtered<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, B>
 } = dual(2, function filterMapEffect<R0, E0, R, E, A, R2, E2, B, R3, E3>(
   versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-  f: (a: A) => Effect.Effect<R3, E3, Option.Option<B>>
+  f: (a: A) => Effect.Effect<Option.Option<B>, E3, R3>
 ): Filtered<R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3, E0 | E | E2 | E3, B> {
   return FilteredImpl.make(versioned, f)
 })
@@ -960,15 +960,15 @@ export const compact: {
 export const filterEffect: {
   <R, E, A, R2, E2>(
     ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
   ): Filtered<R | R2, E | E2, A>
   <R0, E0, R, E, A, R2, E2, R3, E3>(
     versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    f: (a: A) => Effect.Effect<R3, E3, boolean>
+    f: (a: A) => Effect.Effect<boolean, E3, R3>
   ): Filtered<R0 | R2 | R3 | Exclude<R, Scope.Scope>, E0 | E | E2 | E3, A>
 } = dual(2, function filterEffect<R0, E0, R, E, A, R2, E2, R3, E3>(
   versioned: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-  f: (a: A) => Effect.Effect<R3, E3, boolean>
+  f: (a: A) => Effect.Effect<boolean, E3, R3>
 ): Filtered<R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3, E0 | E | E2 | E3, A> {
   return FilteredImpl.make(versioned, (a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()))
 })
@@ -1017,7 +1017,7 @@ class ComputedImpl<R0, E0, R, E, A, R2, E2, R3, E3, C> extends Versioned.Version
 
   constructor(
     readonly input: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    readonly f: (a: A) => Effect.Effect<R3, E3, C>
+    readonly f: (a: A) => Effect.Effect<C, E3, R3>
   ) {
     super(
       input,
@@ -1028,7 +1028,7 @@ class ComputedImpl<R0, E0, R, E, A, R2, E2, R3, E3, C> extends Versioned.Version
 
   static make<R0, E0, R, E, A, R2, E2, R3, E3, C>(
     input: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    f: (a: A) => Effect.Effect<R3, E3, C>
+    f: (a: A) => Effect.Effect<C, E3, R3>
   ): Computed<R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3, E0 | E | E2 | E3, C> {
     return new ComputedImpl(input, f)
   }
@@ -1054,7 +1054,7 @@ class FilteredImpl<R0, E0, R, E, A, R2, E2, R3, E3, C> extends Versioned.Version
 
   constructor(
     readonly input: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    readonly f: (a: A) => Effect.Effect<R3, E3, Option.Option<C>>
+    readonly f: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>
   ) {
     super(
       input,
@@ -1065,7 +1065,7 @@ class FilteredImpl<R0, E0, R, E, A, R2, E2, R3, E3, C> extends Versioned.Version
 
   static make<R0, E0, R, E, A, R2, E2, R3, E3, C>(
     input: Versioned.Versioned<R0, E0, R, E, A, R2, E2, A>,
-    f: (a: A) => Effect.Effect<R3, E3, Option.Option<C>>
+    f: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>
   ): Filtered<
     R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3,
     E0 | E | Exclude<E2, Cause.NoSuchElementException> | E3,
@@ -1151,8 +1151,8 @@ export function transform<R, E, A, B>(
  */
 export function transformOrFail<R, E, R2, E2, A, R3, E3, B>(
   ref: RefSubject<R, E, A>,
-  from: (a: A) => Effect.Effect<R2, E2, B>,
-  to: (b: B) => Effect.Effect<R3, E3, A>
+  from: (a: A) => Effect.Effect<B, E2, R2>,
+  to: (b: B) => Effect.Effect<A, E3, R3>
 ): RefSubject<R | R2 | R3, E | E2 | E3, B> {
   return new RefSubjectTransformEffect(ref, from, to)
 }
@@ -1163,9 +1163,9 @@ class RefSubjectTransform<R, E, A, B> extends FxEffectBase<R | Scope.Scope, E, B
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<R, E, number>
-  readonly interrupt: Effect.Effect<R, never, void>
-  readonly subscriberCount: Effect.Effect<R, never, number>
+  readonly version: Effect.Effect<number, E, R>
+  readonly interrupt: Effect.Effect<void, never, R>
+  readonly subscriberCount: Effect.Effect<number, never, R>
 
   constructor(
     readonly ref: RefSubject<R, E, A>,
@@ -1179,12 +1179,12 @@ class RefSubjectTransform<R, E, A, B> extends FxEffectBase<R | Scope.Scope, E, B
     this.subscriberCount = ref.subscriberCount
   }
 
-  run<R2 = never>(sink: Sink.Sink<R2, E, B>): Effect.Effect<R | Scope.Scope | R2, never, unknown> {
+  run<R2 = never>(sink: Sink.Sink<R2, E, B>): Effect.Effect<unknown, never, R | Scope.Scope | R2> {
     return this.ref.run(Sink.map(sink, this.from))
   }
 
   runUpdates<R2, E2, C>(
-    run: (ref: GetSetDelete<R, E, B>) => Effect.Effect<R2, E2, C>
+    run: (ref: GetSetDelete<R, E, B>) => Effect.Effect<C, E2, R2>
   ) {
     return this.ref.runUpdates((ref) =>
       run({
@@ -1195,15 +1195,15 @@ class RefSubjectTransform<R, E, A, B> extends FxEffectBase<R | Scope.Scope, E, B
     )
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<R, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, R> {
     return this.ref.onFailure(cause)
   }
 
-  onSuccess(value: B): Effect.Effect<R, never, unknown> {
+  onSuccess(value: B): Effect.Effect<unknown, never, R> {
     return this.ref.onSuccess(this.to(value))
   }
 
-  toEffect(): Effect.Effect<R, E, B> {
+  toEffect(): Effect.Effect<B, E, R> {
     return Effect.map(this.ref, this.from)
   }
 }
@@ -1215,15 +1215,15 @@ class RefSubjectTransformEffect<R, E, A, R2, E2, B, R3, E3>
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<R, E, number>
-  readonly interrupt: Effect.Effect<R, never, void>
-  readonly subscriberCount: Effect.Effect<R, never, number>
+  readonly version: Effect.Effect<number, E, R>
+  readonly interrupt: Effect.Effect<void, never, R>
+  readonly subscriberCount: Effect.Effect<number, never, R>
   readonly subject: Subject.Subject<never, E | E2 | E3, B>
 
   constructor(
     readonly ref: RefSubject<R, E, A>,
-    readonly from: (a: A) => Effect.Effect<R2, E2, B>,
-    readonly to: (b: B) => Effect.Effect<R3, E3, A>
+    readonly from: (a: A) => Effect.Effect<B, E2, R2>,
+    readonly to: (b: B) => Effect.Effect<A, E3, R3>
   ) {
     super()
 
@@ -1233,12 +1233,12 @@ class RefSubjectTransformEffect<R, E, A, R2, E2, B, R3, E3>
     this.subject = Subject.unsafeMake()
   }
 
-  run<R4 = never>(sink: Sink.Sink<R4, E | E2 | E3, B>): Effect.Effect<R | R2 | R3 | Scope.Scope | R4, never, unknown> {
+  run<R4 = never>(sink: Sink.Sink<R4, E | E2 | E3, B>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope | R4> {
     return core.merge(core.mapEffect(this.ref, this.from), this.subject).run(sink)
   }
 
   runUpdates<R4, E4, C>(
-    run: (ref: GetSetDelete<R | R2 | R3, E | E2 | E3, B>) => Effect.Effect<R4, E4, C>
+    run: (ref: GetSetDelete<R | R2 | R3, E | E2 | E3, B>) => Effect.Effect<C, E4, R4>
   ) {
     return this.ref.runUpdates((ref) =>
       run({
@@ -1259,18 +1259,18 @@ class RefSubjectTransformEffect<R, E, A, R2, E2, B, R3, E3>
     )
   }
 
-  onFailure(cause: Cause.Cause<E | E2 | E3>): Effect.Effect<R, never, unknown> {
+  onFailure(cause: Cause.Cause<E | E2 | E3>): Effect.Effect<unknown, never, R> {
     return this.subject.onFailure(cause)
   }
 
-  onSuccess(value: B): Effect.Effect<R | R3, never, unknown> {
+  onSuccess(value: B): Effect.Effect<unknown, never, R | R3> {
     return Effect.matchCauseEffect(this.to(value), {
       onFailure: (cause) => this.subject.onFailure(cause),
       onSuccess: (a) => this.ref.onSuccess(a)
     })
   }
 
-  toEffect(): Effect.Effect<R | R2, E | E2, B> {
+  toEffect(): Effect.Effect<B, E | E2, R | R2> {
     return Effect.flatMap(this.ref, this.from)
   }
 }
@@ -1406,9 +1406,9 @@ class RefSubjectTuple<
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<Effect.Effect.Context<Refs[number]>, Effect.Effect.Error<Refs[number]>, number>
-  readonly interrupt: Effect.Effect<Effect.Effect.Context<Refs[number]>, never, void>
-  readonly subscriberCount: Effect.Effect<Effect.Effect.Context<Refs[number]>, never, number>
+  readonly version: Effect.Effect<number, Effect.Effect.Error<Refs[number]>, Effect.Effect.Context<Refs[number]>>
+  readonly interrupt: Effect.Effect<void, never, Effect.Effect.Context<Refs[number]>>
+  readonly subscriberCount: Effect.Effect<number, never, Effect.Effect.Context<Refs[number]>>
 
   private versioned: Versioned.Versioned<
     Effect.Effect.Context<Refs[number]>,
@@ -1459,14 +1459,14 @@ class RefSubjectTuple<
         readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>
       }
     >
-  ): Effect.Effect<Effect.Effect.Context<Refs[number]> | R2, never, unknown> {
+  ): Effect.Effect<unknown, never, Effect.Effect.Context<Refs[number]> | R2> {
     return this.versioned.run(sink)
   }
 
   toEffect(): Effect.Effect<
-    Effect.Effect.Context<Refs[number]>,
+    { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> },
     Effect.Effect.Error<Refs[number]>,
-    { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> }
+    Effect.Effect.Context<Refs[number]>
   > {
     return this.versioned
   }
@@ -1480,20 +1480,20 @@ class RefSubjectTuple<
           readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>
         }
       >
-    ) => Effect.Effect<R2, E2, C>
+    ) => Effect.Effect<C, E2, R2>
   ) {
     return run(this.getSetDelete)
   }
 
   onFailure(
     cause: Cause.Cause<Effect.Effect.Error<Refs[number]>>
-  ): Effect.Effect<Effect.Effect.Context<Refs[number]>, never, unknown> {
+  ): Effect.Effect<unknown, never, Effect.Effect.Context<Refs[number]>> {
     return Effect.all(this.refs.map((ref) => ref.onFailure(cause)))
   }
 
   onSuccess(
     value: { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> }
-  ): Effect.Effect<Effect.Effect.Context<Refs[number]>, never, unknown> {
+  ): Effect.Effect<unknown, never, Effect.Effect.Context<Refs[number]>> {
     return Effect.catchAllCause(this.getSetDelete.set(value), (c) => this.onFailure(c))
   }
 }
@@ -1559,12 +1559,12 @@ class RefSubjectStruct<
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
   readonly version: Effect.Effect<
-    Effect.Effect.Context<Refs[keyof Refs]>,
+    number,
     Effect.Effect.Error<Refs[keyof Refs]>,
-    number
+    Effect.Effect.Context<Refs[keyof Refs]>
   >
-  readonly interrupt: Effect.Effect<Effect.Effect.Context<Refs[keyof Refs]>, never, void>
-  readonly subscriberCount: Effect.Effect<Effect.Effect.Context<Refs[keyof Refs]>, never, number>
+  readonly interrupt: Effect.Effect<void, never, Effect.Effect.Context<Refs[keyof Refs]>>
+  readonly subscriberCount: Effect.Effect<number, never, Effect.Effect.Context<Refs[keyof Refs]>>
 
   private versioned: Versioned.Versioned<
     Effect.Effect.Context<Refs[keyof Refs]>,
@@ -1613,14 +1613,14 @@ class RefSubjectStruct<
       Effect.Effect.Error<Refs[keyof Refs]>,
       { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> }
     >
-  ): Effect.Effect<Effect.Effect.Context<Refs[keyof Refs]> | R3, never, unknown> {
+  ): Effect.Effect<unknown, never, Effect.Effect.Context<Refs[keyof Refs]> | R3> {
     return this.versioned.run(sink)
   }
 
   toEffect(): Effect.Effect<
-    Effect.Effect.Context<Refs[keyof Refs]>,
+    { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> },
     Effect.Effect.Error<Refs[keyof Refs]>,
-    { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> }
+    Effect.Effect.Context<Refs[keyof Refs]>
   > {
     return this.versioned
   }
@@ -1634,20 +1634,20 @@ class RefSubjectStruct<
           readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>
         }
       >
-    ) => Effect.Effect<R2, E2, C>
+    ) => Effect.Effect<C, E2, R2>
   ) {
     return run(this.getSetDelete)
   }
 
   onFailure(
     cause: Cause.Cause<Effect.Effect.Error<Refs[keyof Refs]>>
-  ): Effect.Effect<Effect.Effect.Context<Refs[keyof Refs]>, never, unknown> {
+  ): Effect.Effect<unknown, never, Effect.Effect.Context<Refs[keyof Refs]>> {
     return Effect.all(Object.values(this.refs).map((ref) => ref.onFailure(cause as any)))
   }
 
   onSuccess(
     value: { readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]> }
-  ): Effect.Effect<Effect.Effect.Context<Refs[keyof Refs]>, never, unknown> {
+  ): Effect.Effect<unknown, never, Effect.Effect.Context<Refs[keyof Refs]>> {
     return Effect.catchAllCause(this.getSetDelete.set(value), (c) => this.onFailure(c))
   }
 }
@@ -1741,9 +1741,9 @@ class RefSubjectTagged<I, E, A> extends FxEffectBase<
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<I, E, number>
-  readonly interrupt: Effect.Effect<I, never, void>
-  readonly subscriberCount: Effect.Effect<I, never, number>
+  readonly version: Effect.Effect<number, E, I>
+  readonly interrupt: Effect.Effect<void, never, I>
+  readonly subscriberCount: Effect.Effect<number, never, I>
 
   constructor(
     readonly tag: C.Tagged<I, RefSubject<never, E, A>>,
@@ -1762,32 +1762,32 @@ class RefSubjectTagged<I, E, A> extends FxEffectBase<
 
   run<R2 = never>(
     sink: Sink.Sink<R2, E, A>
-  ): Effect.Effect<I | R2 | Scope.Scope, never, unknown> {
+  ): Effect.Effect<unknown, never, I | R2 | Scope.Scope> {
     return this.tag.withEffect((ref) => ref.run(sink))
   }
 
-  toEffect(): Effect.Effect<I, E, A> {
+  toEffect(): Effect.Effect<A, E, I> {
     return this.tag.withEffect((ref) => ref)
   }
 
   runUpdates<R2, E2, C>(
-    run: (ref: GetSetDelete<I, E, A>) => Effect.Effect<R2, E2, C>
-  ): Effect.Effect<I | R2, E2, C> {
+    run: (ref: GetSetDelete<I, E, A>) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<C, E2, I | R2> {
     return this.tag.withEffect((ref) => ref.runUpdates(run))
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<I, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, I> {
     return this.tag.withEffect((ref) => ref.onFailure(cause))
   }
 
-  onSuccess(value: A): Effect.Effect<I, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, I> {
     return this.tag.withEffect((ref) => ref.onSuccess(value))
   }
 
   make = <R>(
-    fxOrEffect: Fx<R, E, A> | Effect.Effect<R, E, A>,
+    fxOrEffect: Fx<R, E, A> | Effect.Effect<A, E, R>,
     options?: RefSubjectOptions<A>
-  ): Layer.Layer<R, never, I> => this.tag.scoped(make(fxOrEffect, options))
+  ): Layer.Layer<I, never, R> => this.tag.scoped(make(fxOrEffect, options))
 }
 
 /**
@@ -1811,11 +1811,11 @@ class RefSubjectFromTag<I, S, R, E, A> extends FxEffectBase<
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<I | R, E, number>
-  readonly interrupt: Effect.Effect<I | R, never, void>
-  readonly subscriberCount: Effect.Effect<I | R, never, number>
+  readonly version: Effect.Effect<number, E, I | R>
+  readonly interrupt: Effect.Effect<void, never, I | R>
+  readonly subscriberCount: Effect.Effect<number, never, I | R>
 
-  private _get: Effect.Effect<I, never, RefSubject<R, E, A>>
+  private _get: Effect.Effect<RefSubject<R, E, A>, never, I>
   private _fx: Fx<I | R | Scope.Scope, E, A>
 
   constructor(
@@ -1832,25 +1832,25 @@ class RefSubjectFromTag<I, S, R, E, A> extends FxEffectBase<
     this.subscriberCount = Effect.flatMap(this._get, (ref) => ref.subscriberCount)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<I | R | R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<unknown, never, I | R | R3 | Scope.Scope> {
     return this._fx.run(sink)
   }
 
-  toEffect(): Effect.Effect<I | R, E, A> {
+  toEffect(): Effect.Effect<A, E, I | R> {
     return Effect.flatten(this._get)
   }
 
   runUpdates<R2, E2, C>(
-    run: (ref: GetSetDelete<I | R, E, A>) => Effect.Effect<R2, E2, C>
-  ): Effect.Effect<I | R | R2, E2, C> {
+    run: (ref: GetSetDelete<I | R, E, A>) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<C, E2, I | R | R2> {
     return Effect.flatMap(this._get, (ref) => ref.runUpdates(run))
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<I | R, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, I | R> {
     return Effect.flatMap(this._get, (ref) => ref.onFailure(cause))
   }
 
-  onSuccess(value: A): Effect.Effect<I | R, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, I | R> {
     return Effect.flatMap(this._get, (ref) => ref.onSuccess(value))
   }
 }
@@ -1919,9 +1919,9 @@ class ComputedFromTag<I, S, R, E, A> extends FxEffectBase<
 > implements Computed<I | R, E, A> {
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
 
-  readonly version: Effect.Effect<I | R, E, number>
+  readonly version: Effect.Effect<number, E, I | R>
 
-  private _get: Effect.Effect<I, never, Computed<R, E, A>>
+  private _get: Effect.Effect<Computed<R, E, A>, never, I>
 
   constructor(
     readonly tag: C.Tag<I, S>,
@@ -1933,11 +1933,11 @@ class ComputedFromTag<I, S, R, E, A> extends FxEffectBase<
     this.version = Effect.flatMap(this._get, (ref) => ref.version)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<I | R | Scope.Scope | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<unknown, never, I | R | Scope.Scope | R3> {
     return Effect.flatMap(this._get, (ref) => ref.run(sink))
   }
 
-  toEffect(): Effect.Effect<I | R, E, A> {
+  toEffect(): Effect.Effect<A, E, I | R> {
     return Effect.flatten(this._get)
   }
 }
@@ -1962,9 +1962,9 @@ class FilteredFromTag<I, S, R, E, A> extends FxEffectBase<
 > implements Filtered<I | R, E, A> {
   readonly [FilteredTypeId]: FilteredTypeId = FilteredTypeId
 
-  readonly version: Effect.Effect<I | R, E, number>
+  readonly version: Effect.Effect<number, E, I | R>
 
-  private _get: Effect.Effect<I, never, Filtered<R, E, A>>
+  private _get: Effect.Effect<Filtered<R, E, A>, never, I>
 
   constructor(
     readonly tag: C.Tag<I, S>,
@@ -1976,11 +1976,11 @@ class FilteredFromTag<I, S, R, E, A> extends FxEffectBase<
     this.version = Effect.flatMap(this._get, (ref) => ref.version)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<I | R | Scope.Scope | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<unknown, never, I | R | Scope.Scope | R3> {
     return Effect.flatMap(this._get, (ref) => ref.run(sink))
   }
 
-  toEffect(): Effect.Effect<I | R, E | Cause.NoSuchElementException, A> {
+  toEffect(): Effect.Effect<A, E | Cause.NoSuchElementException, I | R> {
     return Effect.flatten(this._get)
   }
 
@@ -1999,7 +1999,7 @@ export const provide: {
     <R, E, A>(ref: RefSubject<R, E, A>): RefSubject<Exclude<R, S>, E, A>
   }
 
-  <R2, S>(layer: Layer.Layer<R2, never, S>): {
+  <R2, S>(layer: Layer.Layer<S, never, R2>): {
     <R, E, A>(filtered: Filtered<R, E, A>): Filtered<Exclude<R, S> | R2, E, A>
     <R, E, A>(computed: Computed<R, E, A>): Computed<Exclude<R, S> | R2, E, A>
     <R, E, A>(ref: RefSubject<R, E, A>): RefSubject<Exclude<R, S> | R2, E, A>
@@ -2018,15 +2018,15 @@ export const provide: {
     context: C.Context<S> | Runtime.Runtime<S>
   ): RefSubject<Exclude<R, S>, E, A>
 
-  <R, E, A, R2, S>(filtered: Filtered<R, E, A>, layer: Layer.Layer<R2, never, S>): Filtered<Exclude<R, S> | R2, E, A>
-  <R, E, A, R2, S>(computed: Computed<R, E, A>, layer: Layer.Layer<R2, never, S>): Computed<Exclude<R, S> | R2, E, A>
-  <R, E, A, R2, S>(ref: RefSubject<R, E, A>, layer: Layer.Layer<R2, never, S>): RefSubject<Exclude<R, S> | R2, E, A>
+  <R, E, A, R2, S>(filtered: Filtered<R, E, A>, layer: Layer.Layer<S, never, R2>): Filtered<Exclude<R, S> | R2, E, A>
+  <R, E, A, R2, S>(computed: Computed<R, E, A>, layer: Layer.Layer<S, never, R2>): Computed<Exclude<R, S> | R2, E, A>
+  <R, E, A, R2, S>(ref: RefSubject<R, E, A>, layer: Layer.Layer<S, never, R2>): RefSubject<Exclude<R, S> | R2, E, A>
 } = dual(2, function provide<R, E, A, R2 = never, S = never>(
   ref: RefSubject<R, E, A> | Computed<R, E, A> | Filtered<R, E, A>,
-  providing: Layer.Layer<R2, never, S> | C.Context<S> | Runtime.Runtime<S>
+  providing: Layer.Layer<S, never, R2> | C.Context<S> | Runtime.Runtime<S>
 ) {
   const layer = Layer.isLayer(providing)
-    ? providing as Layer.Layer<R2, never, S>
+    ? providing as Layer.Layer<S, never, R2>
     : C.isContext(providing)
     ? Layer.succeedContext(providing)
     : runtimeToLayer(providing as Runtime.Runtime<S>)
@@ -2051,12 +2051,12 @@ class RefSubjectProvide<R, E, A, R2, S> extends FxEffectBase<
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly interrupt: Effect.Effect<Exclude<R, S> | R2, never, void>
-  readonly subscriberCount: Effect.Effect<Exclude<R, S> | R2, never, number>
+  readonly interrupt: Effect.Effect<void, never, Exclude<R, S> | R2>
+  readonly subscriberCount: Effect.Effect<number, never, Exclude<R, S> | R2>
 
   constructor(
     readonly ref: RefSubject<R, E, A>,
-    readonly layer: Layer.Layer<R2, never, S>
+    readonly layer: Layer.Layer<S, never, R2>
   ) {
     super()
 
@@ -2066,11 +2066,11 @@ class RefSubjectProvide<R, E, A, R2, S> extends FxEffectBase<
 
   run<R3>(
     sink: Sink.Sink<R3, E, A>
-  ): Effect.Effect<R2 | Scope.Scope | Exclude<Scope.Scope, S> | Exclude<R, S> | Exclude<R3, S>, never, unknown> {
+  ): Effect.Effect<unknown, never, R2 | Scope.Scope | Exclude<Scope.Scope, S> | Exclude<R, S> | Exclude<R3, S>> {
     return Effect.provide(this.ref.run(sink), this.layer)
   }
 
-  toEffect(): Effect.Effect<Exclude<R, S> | R2, E, A> {
+  toEffect(): Effect.Effect<A, E, Exclude<R, S> | R2> {
     return Effect.provide(this.ref, this.layer)
   }
 }
@@ -2079,7 +2079,7 @@ class RefSubjectProvide<R, E, A, R2, S> extends FxEffectBase<
  * Set the value to true
  * @since 1.18.0
  */
-export const asTrue: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean> = <R, E>(
+export const asTrue: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<boolean, E, R> = <R, E>(
   ref: RefSubject<R, E, boolean>
 ) => set(ref, true)
 
@@ -2087,7 +2087,7 @@ export const asTrue: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R,
  * Set the value to false
  * @since 1.18.0
  */
-export const asFalse: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean> = <R, E>(
+export const asFalse: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<boolean, E, R> = <R, E>(
   ref: RefSubject<R, E, boolean>
 ) => set(ref, false)
 
@@ -2095,7 +2095,7 @@ export const asFalse: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R,
  * Toggle the boolean value between true and false
  * @since 1.18.0
  */
-export const toggle: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<R, E, boolean> = <R, E>(
+export const toggle: <R, E>(ref: RefSubject<R, E, boolean>) => Effect.Effect<boolean, E, R> = <R, E>(
   ref: RefSubject<R, E, boolean>
 ) => update(ref, Boolean.not)
 
@@ -2105,7 +2105,7 @@ const add = (x: number): number => x + 1
  * Set the value to true
  * @since 1.18.0
  */
-export const increment: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<R, E, number> = <R, E>(
+export const increment: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<number, E, R> = <R, E>(
   ref: RefSubject<R, E, number>
 ) => update(ref, add)
 
@@ -2115,7 +2115,7 @@ const sub = (x: number): number => x - 1
  * Set the value to false
  * @since 1.18.0
  */
-export const decrement: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<R, E, number> = <R, E>(
+export const decrement: <R, E>(ref: RefSubject<R, E, number>) => Effect.Effect<number, E, R> = <R, E>(
   ref: RefSubject<R, E, number>
 ) => update(ref, sub)
 
@@ -2156,9 +2156,9 @@ class RefSubjectSlice<R, E, A> extends FxEffectBase<R | Scope.Scope, E, A, R, E,
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
-  readonly version: Effect.Effect<R, E, number>
-  readonly interrupt: Effect.Effect<R, never, void>
-  readonly subscriberCount: Effect.Effect<R, never, number>
+  readonly version: Effect.Effect<number, E, R>
+  readonly interrupt: Effect.Effect<void, never, R>
+  readonly subscriberCount: Effect.Effect<number, never, R>
   private _fx: Fx<Scope.Scope | R, E, A>
 
   constructor(
@@ -2175,25 +2175,25 @@ class RefSubjectSlice<R, E, A> extends FxEffectBase<R | Scope.Scope, E, A, R, E,
     this._effect = ref
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<unknown, never, R | R2 | Scope.Scope> {
     return this._fx.run(sink)
   }
 
-  toEffect(): Effect.Effect<R, E, A> {
+  toEffect(): Effect.Effect<A, E, R> {
     return this.ref
   }
 
   runUpdates<R2, E2, C>(
-    run: (ref: GetSetDelete<R, E, A>) => Effect.Effect<R2, E2, C>
-  ): Effect.Effect<R | R2, E2, C> {
+    run: (ref: GetSetDelete<R, E, A>) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<C, E2, R | R2> {
     return this.ref.runUpdates(run)
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<R, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, R> {
     return this.ref.onFailure(cause)
   }
 
-  onSuccess(value: A): Effect.Effect<R, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, R> {
     return this.ref.onSuccess(value)
   }
 }