@typed/fx 1.17.3 → 1.18.0

package/src/RefSubject.ts

@@ -1,800 +1,643 @@
-import * as Context from '@effect/data/Context'
-import * as Equal from '@effect/data/Equal'
-import * as Equivalence from '@effect/data/Equivalence'
-import { identity, pipe } from '@effect/data/Function'
-import * as Hash from '@effect/data/Hash'
-import * as MutableRef from '@effect/data/MutableRef'
-import * as Option from '@effect/data/Option'
-import { Pipeable, pipeArguments } from '@effect/data/Pipeable'
-import * as Deferred from '@effect/io/Deferred'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Scope from '@effect/io/Scope'
-import fastDeepEqual from 'fast-deep-equal'
-
-import { Computed, ComputedImpl, ComputedTypeId } from './Computed.js'
-import { FilteredImpl } from './Filtered.js'
-import { Fx, FxTypeId, Sink, isFx } from './Fx.js'
-import { RefTransform, RefTransformImpl } from './RefTransform.js'
-import { Subject } from './Subject.js'
-import { combineAll } from './combineAll.js'
-import { HoldFx } from './hold.js'
-import { merge } from './mergeAll.js'
-import { never } from './never.js'
-import { drain } from './observe.js'
-import { struct } from './struct.js'
-import { unit } from './succeed.js'
-import { switchMatchCauseEffect } from './switchMatch.js'
-
-const unboundedConcurrency = { concurrency: 'unbounded' } as const
-
-const refVariance = {
-  _R: identity,
-  _E: identity,
-  _A: identity,
-}
-
-export const RefSubjectTypeId = Symbol.for('@typed/fx/RefSubject')
-export type RefSubjectTypeId = typeof RefSubjectTypeId
-
-export interface RefSubject<in out E, in out A>
-  extends Subject<E, A>,
-    Computed<never, E, A>,
-    Pipeable {
+/**
+ * A RefSubject is the core abstraction for keeping state and subscribing to its
+ * changes over time.
+ *
+ * @since 1.18.0
+ */
+
+import type { Schema } from "@effect/schema"
+import * as C from "@typed/context"
+import type { Stream, SubscriptionRef } from "effect"
+import { Cause, Exit, identity } from "effect"
+import * as Effect from "effect/Effect"
+import { equals } from "effect/Equal"
+import type { Equivalence } from "effect/Equivalence"
+import { dual } from "effect/Function"
+import type * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
+import { Computed, fromTag } from "./Computed"
+import { Filtered } from "./Filtered"
+import type * as Fx from "./Fx"
+import { fromStream, provide, skipRepeatsWith } from "./internal/core"
+import * as coreRefSubject from "./internal/core-ref-subject"
+import { exit, fromFxEffect } from "./internal/fx"
+import { FxEffectBase } from "./internal/protos"
+import { fromRefSubject, toRefSubject } from "./internal/schema-ref-subject"
+import type * as Subject from "./Subject"
+import { ComputedTypeId, RefSubjectTypeId } from "./TypeId"
+import * as Versioned from "./Versioned"
+
+/**
+ * A RefSubject is a Subject that has a current value that can be read and updated.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefSubject<R, in out E, in out A> extends Computed<R, E, A>, Subject.Subject<R, E, A> {
   readonly [RefSubjectTypeId]: RefSubjectTypeId
 
-  readonly eq: Equivalence.Equivalence<A>
-
-  readonly modifyEffect: <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>,
-  ) => Effect.Effect<R2, E | E2, B>
+  /**
+   * Get the current value of this RefSubject. If the RefSubject has not been initialized
+   * then the initial value will be computed and returned. Concurrent calls to `get` will
+   * only compute the initial value once.
+   * @since 1.18.0
+   */
+  readonly get: Effect.Effect<R, E, A>
 
-  readonly modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<never, E, B>
+  /**
+   * Set the current value of this RefSubject.
+   * @since 1.18.0
+   */
+  readonly set: (a: A) => Effect.Effect<R, never, A>
 
-  readonly updateEffect: <R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, A>,
-  ) => Effect.Effect<R2, E | E2, A>
+  /**
+   * Modify the current value of this RefSubject using the provided function.
+   * @since 1.18.0
+   */
+  readonly update: (f: (a: A) => A) => Effect.Effect<R, E, A>
 
-  readonly update: (f: (a: A) => A) => Effect.Effect<never, E, A>
+  /**
+   * Modify the current value of this RefSubject and compute a new value.
+   * @since 1.18.0
+   */
+  readonly modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<R, E, B>
 
-  readonly set: (a: A) => Effect.Effect<never, never, A>
+  /**
+   * Delete the current value of this RefSubject. If it was not initialized the Option.none will be returned.
+   * Otherwise the current value will be returned as an Option.some and the RefSubject will be uninitialized.
+   * If there are existing subscribers to this RefSubject then the RefSubject will be re-initialized.
+   * @since 1.18.0
+   */
+  readonly delete: Effect.Effect<R, never, Option.Option<A>>
 
-  readonly delete: Effect.Effect<never, E, Option.Option<A>>
+  /**
+   * Modify the current value of this RefSubject and compute a new value using the provided effectful function.
+   * @since 1.18.0
+   */
+  readonly modifyEffect: <R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>
+  ) => Effect.Effect<R | R2, E | E2, B>
 
-  readonly multiUpdate: <R2, E2, B>(
-    f: (current: A, set: (a: A) => Effect.Effect<never, never, A>) => Effect.Effect<R2, E2, B>,
-  ) => Effect.Effect<R2, E | E2, B>
+  /**
+   * Modify the current value of this RefSubject using the provided effectful function.
+   * @since 1.18.0
+   */
+  readonly updateEffect: <R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) => Effect.Effect<R | R2, E | E2, A>
 
   /**
-   * The current version of the RefSubject, starting with 0, 1 when initialized,
-   * and incremented each time the value is updated.
+   * Modify the current value of this RefSubject and compute a new value using the provided effectful function.
+   * The key difference is it will allow running a workflow and setting the value multiple times. Optionally,
+   * another function can be provided to change the value
+   * @since 1.18.0
    */
-  readonly version: () => number
-}
+  readonly runUpdate: <R2, E2, B, R3 = never, E3 = never>(
+    updates: (
+      get: RefSubject<R, E, A>["get"],
+      set: RefSubject<R, E, A>["set"]
+    ) => Effect.Effect<R2, E2, B>,
+    onInterrupt?: (a: A) => Effect.Effect<R3, E3, A>
+  ) => Effect.Effect<R | R2 | R3, E | E2 | E3, B>
 
-type Lock = <R2, E2, B>(effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R2, E2, B>
-
-export function makeRef<R, E, A>(
-  effect: Effect.Effect<R, E, A>,
-  eq?: Equivalence.Equivalence<A>,
-): Effect.Effect<R | Scope.Scope, never, RefSubject<E, A>> {
-  return Effect.contextWithEffect((context) =>
-    Effect.suspend(() => {
-      const ref = RefSubject.unsafeMake(
-        Effect.provideContext(effect, context),
-        Context.get(context, Scope.Scope),
-        eq,
-      )
-
-      return Effect.as(
-        Effect.addFinalizer(() => ref.end()),
-        ref,
-      )
-    }),
-  )
+  /**
+   * Interrupt the current Fibers.
+   */
+  readonly interrupt: Effect.Effect<R, never, void>
 }
 
+/**
+ * @since 1.18.0
+ */
 export namespace RefSubject {
-  export type Any = RefSubject<any, any> | RefSubject<never, any>
-
-  export function unsafeMake<E, A>(
-    initial: Effect.Effect<never, E, A>,
-    scope: Scope.Scope,
-    eq: Equivalence.Equivalence<A> = fastDeepEqual,
-  ): RefSubject<E, A> {
-    return makeRefFromPrimitive(unsafeMakeRefPrimitive(initial, scope, eq))
-  }
-
-  export function tuple<const Refs extends readonly Any[]>(
-    ...refs: Refs
-  ): RefSubject<
-    Fx.Error<Refs[number]>,
-    {
-      readonly [K in keyof Refs]: Fx.Success<Refs[K]>
-    }
-  > {
-    return makeRefFromPrimitive<
-      Fx.Error<Refs[number]>,
-      {
-        readonly [K in keyof Refs]: Fx.Success<Refs[K]>
-      }
-    >(tupleRefPrimitive<Refs>(refs))
-  }
-
-  export function struct<const Refs extends Readonly<Record<string, Any>>>(
-    refs: Refs,
-  ): RefSubject<
-    Fx.Error<Refs[string]>,
-    {
-      readonly [K in keyof Refs]: Fx.Success<Refs[K]>
-    }
-  > {
-    return makeRefFromPrimitive(structRefPrimitive<Refs>(refs))
-  }
-
-  export function all<S extends ReadonlyArray<Any>>(
-    subjects: S,
-  ): RefSubject<
-    Fx.Error<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.Success<S[K]>
-    }
-  >
-
-  export function all<S extends ReadonlyArray<Any>>(
-    ...subjects: S
-  ): RefSubject<
-    Fx.Error<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.Success<S[K]>
-    }
-  >
-
-  export function all<S extends Readonly<Record<string, Any>>>(
-    subjects: S,
-  ): RefSubject<
-    Fx.Error<S[string]>,
-    {
-      readonly [K in keyof S]: Fx.Success<S[K]>
-    }
-  >
-
-  export function all(...subjects: any): any {
-    /// MUST be a tuple if more than one argument
-    if (subjects.length > 1) {
-      return tuple(...subjects)
-    }
-
-    // Otherwise a single param is either a tuple or a struct
-    const singleParam = subjects[0]
-
-    if (Array.isArray(singleParam)) {
-      return tuple(...singleParam)
-    }
-
-    return struct(singleParam)
-  }
-}
-
-export function isRefSubject<E, A>(u: unknown): u is RefSubject<E, A> {
-  return isFx<never, E, A>(u) && RefSubjectTypeId in u
-}
-
-// Internals for RefSubject
-
-function makeGetFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['get'] {
-  return Effect.suspend(() => {
-    const current = MutableRef.get(ctx.currentRef)
-
-    if (Option.isSome(current)) {
-      return Effect.succeed(current.value)
-    }
-
-    const fiber = MutableRef.get(ctx.initializingFiberRef)
-
-    if (Option.isSome(fiber)) {
-      return Fiber.join(fiber.value)
-    }
-
-    return Effect.tap(ctx.lock(initializeFromContext(ctx)), (a) => ctx.hold.event(a))
-  })
-}
-
-function initializeFromContext<E, A>(ctx: RefSubjectContext<E, A>): Effect.Effect<never, E, A> {
-  return Effect.uninterruptibleMask((restore) =>
-    Effect.flatMap(Effect.forkIn(restore(ctx.initial), ctx.scope), (fiber) => {
-      MutableRef.set(ctx.initializingFiberRef, Option.some(fiber))
-
-      return Fiber.join(fiber).pipe(
-        Effect.tap((a) =>
-          Effect.sync(() => {
-            MutableRef.increment(ctx.version)
-            MutableRef.set(ctx.currentRef, Option.some(a))
-          }),
-        ),
-        Effect.ensuring(Effect.sync(() => MutableRef.set(ctx.initializingFiberRef, Option.none()))),
-      )
-    }),
-  )
-}
-
-function makeRefMethods<E, A>(
-  primitive: RefPrimitive<E, A>,
-): Pick<RefSubject<E, A>, 'modify' | 'updateEffect' | 'update'> {
-  const modify = makeModify<E, A>(primitive.modifyEffect)
-  const updateEffect = makeUpdateEffect<E, A>(primitive.modifyEffect)
-  const update = makeUpdate<E, A>(updateEffect)
-
-  return {
-    modify,
-    updateEffect,
-    update,
-  } as const
-}
-
-function makeModifyEffectFromContext<E, A>(
-  get: RefSubject<E, A>['get'],
-  ctx: RefSubjectContext<E, A>,
-): RefSubject<E, A>['modifyEffect'] {
-  return (f) =>
-    Effect.flatMap(get, (a1) =>
-      ctx.lock(
-        Effect.flatMap(f(a1), ([b, a2]) =>
-          Effect.suspend(() => {
-            MutableRef.set(ctx.currentRef, Option.some(a2))
-
-            if (ctx.eq(a1, a2)) {
-              return Effect.succeed(b)
-            }
-
-            MutableRef.increment(ctx.version)
-
-            return Effect.as(ctx.hold.event(a2), b)
-          }),
-        ),
-      ),
-    )
-}
-
-function makeMultiUpdateFromContext<E, A>(
-  get: RefSubject<E, A>['get'],
-  set: RefSubject<E, A>['set'],
-  lock: RefSubjectContext<E, A>['lock'],
-): RefSubject<E, A>['multiUpdate'] {
-  return (f) => get.pipe(Effect.flatMap((current) => lock(f(current, set))))
-}
-
-function makeModify<E, A>(
-  modifyEffect: RefSubject<E, A>['modifyEffect'],
-): RefSubject<E, A>['modify'] {
-  return (f) => modifyEffect((a) => Effect.sync(() => f(a)))
-}
-
-function makeUpdateEffect<E, A>(
-  modifyEffect: RefSubject<E, A>['modifyEffect'],
-): RefSubject<E, A>['updateEffect'] {
-  return (f) => modifyEffect((a) => Effect.map(f(a), (a) => [a, a]))
-}
-
-function makeUpdate<E, A>(
-  updateEffect: RefSubject<E, A>['updateEffect'],
-): RefSubject<E, A>['update'] {
-  return (f) => updateEffect((a) => Effect.sync(() => f(a)))
-}
-
-function makeSetFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['set'] {
-  return (a: A) =>
-    Effect.suspend(() => {
-      const fiber = MutableRef.get(ctx.initializingFiberRef)
-
-      return pipe(
-        fiber,
-        Option.match({ onNone: () => Effect.unit, onSome: Fiber.await }),
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        Effect.flatMap((_: unknown) => {
-          const current = MutableRef.get(ctx.currentRef)
-
-          MutableRef.set(ctx.currentRef, Option.some(a))
-
-          // Only emit if the value has changed
-          if (Option.isNone(current) || (Option.isSome(current) && !ctx.eq(current.value, a))) {
-            // Increment the version
-            MutableRef.increment(ctx.version)
-            return Effect.as(ctx.hold.event(a), a)
-          }
-
-          return Effect.succeed(a)
-        }),
-      )
-    })
-}
-
-function makeDeleteFromContext<E, A>(
-  ctx: RefSubjectContext<E, A>,
-  get: RefSubject<E, A>['get'],
-): RefSubject<E, A>['delete'] {
-  return Effect.suspend(() => {
-    const current = MutableRef.get(ctx.currentRef)
-
-    if (Option.isSome(current)) {
-      MutableRef.set(ctx.version, 0)
-      MutableRef.set(ctx.currentRef, Option.none())
-
-      // Attempt to reinitialize the subject if there are observers
-      if (ctx.hold.observers.length > 0) {
-        return Effect.forkDaemon(get).pipe(Effect.as(current))
-      }
-    }
-
-    return Effect.succeed(current)
-  })
-}
-
-function makeEndFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['end'] {
-  return () =>
-    Effect.suspend(() => {
-      MutableRef.set(ctx.version, 0)
-
-      const fibers = [
-        ctx.hold.fiber || Fiber.unit,
-        Option.getOrElse(MutableRef.get(ctx.initializingFiberRef), () => Fiber.unit),
-      ]
-
-      return Fiber.interruptAll(fibers)
-    })
-}
-
-function makeFiltered<E, A>(
-  f: () => RefSubject<E, A>,
-): Pick<
-  RefSubject<E, A>,
-  'filterMapEffect' | 'filterMap' | 'filterEffect' | 'filter' | 'filterNotEffect' | 'filterNot'
-> {
-  const get = makeMemoizedGet(f)
-
-  function filterMapEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>) {
-    return new FilteredImpl(get(), f)
-  }
+  /**
+   * @since 1.18.0
+   */
+  export type Any =
+    | RefSubject<any, any, any>
+    | RefSubject<never, any, any>
+    | RefSubject<any, never, any>
+    | RefSubject<never, never, any>
 
-  function filterMap<B>(f: (a: A) => Option.Option<B>) {
-    return filterMapEffect((a) => Effect.sync(() => f(a)))
+  /**
+   * A Contextual wrapper around a RefSubject
+   * @since 1.18.0
+   * @category models
+   */
+  export interface Tagged<I, E, A> extends RefSubject<I, E, A> {
+    readonly tag: C.Tagged<I, RefSubject<never, E, A>>
+
+    /**
+     * Make a layer initializing a RefSubject
+     * @since 1.18.0
+     */
+    readonly make: <R = never>(
+      fx: Exclude<Fx.FxInput<R, E, A>, Iterable<A>>,
+      eq?: Equivalence<A>
+    ) => Layer.Layer<R, never, I>
+
+    /**
+     * Make a layer initializing a RefSubject
+     * @since 1.18.0
+     */
+    readonly of: (value: A, eq?: Equivalence<A>) => Layer.Layer<never, never, I>
+
+    /**
+     * Provide an implementation of this RefSubject
+     * @since 1.18.0
+     */
+    readonly provide: <R2>(fx: Fx.FxInput<R2, E, A>, eq?: Equivalence<A>) => <R3, E3, C>(
+      effect: Effect.Effect<R3, E3, C>
+    ) => Effect.Effect<R2 | Exclude<R3, I> | Scope.Scope, E | E3, C>
+
+    /**
+     * Provide an implementation of this RefSubject
+     * @since 1.18.0
+     */
+    readonly provideFx: <R2>(fx: Fx.FxInput<R2, E, A>, eq?: Equivalence<A>) => <R3, E3, C>(
+      effect: Fx.Fx<R3, E3, C>
+    ) => Fx.Fx<R2 | Exclude<R3, I> | Scope.Scope, E | E3, C>
   }
 
-  function filterEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>) {
-    return filterMapEffect((a) => Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())))
+  /**
+   * A Contextual wrapper around a RefSubject
+   * @since 1.18.0
+   * @category models
+   */
+  export interface Derived<R0, R, E, A> extends RefSubject<R, E, A> {
+    readonly persist: Effect.Effect<R0, never, void>
   }
 
-  function filter(f: (a: A) => boolean) {
-    return filterEffect((a) => Effect.sync(() => f(a)))
-  }
+  /**
+   * Extract the Identifier from a RefSubject
+   * @since 1.18.0
+   */
+  export type Context<T> = T extends RefSubject<infer I, infer _, infer __> ? I : never
 
-  function filterNotEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>) {
-    return filterEffect((a) => Effect.map(f(a), (b) => !b))
-  }
+  /**
+   * Extract the Error from a RefSubject
+   * @since 1.18.0
+   */
+  export type Error<T> = T extends RefSubject<infer _, infer E, infer __> ? E : never
 
-  function filterNot(f: (a: A) => boolean) {
-    return filterNotEffect((a) => Effect.sync(() => f(a)))
+  /**
+   * Extract the State from a RefSubject
+   * @since 1.18.0
+   */
+  export type Success<T> = T extends RefSubject<infer _, infer __, infer S> ? S : never
+}
+
+/**
+ * Extract the Identifier from a RefSubject
+ * @since 1.18.0
+ */
+export type Context<T> = RefSubject.Context<T>
+
+/**
+ * Extract the Error from a RefSubject
+ * @since 1.18.0
+ */
+export type Error<T> = RefSubject.Error<T>
+
+/**
+ * Extract the State from a RefSubject
+ * @since 1.18.0
+ */
+export type Success<T> = RefSubject.Success<T>
+
+/**
+ * Construct a RefSubject with a lazily initialized value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function fromEffect<R, E, A>(
+  initial: Effect.Effect<R, E, A>,
+  eq?: Equivalence<A>
+): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>> {
+  return coreRefSubject.fromEffect(initial, eq)
+}
+
+/**
+ * Construct a RefSubject from a synchronous value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function of<A, E = never>(
+  initial: A,
+  eq?: Equivalence<A>
+): Effect.Effect<Scope.Scope, never, RefSubject<never, E, A>> {
+  return fromEffect<never, E, A>(Effect.succeed(initial), eq)
+}
+
+/**
+ * Construct a RefSubject from a synchronous value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function sync<A, E = never>(
+  initial: () => A,
+  eq?: Equivalence<A>
+): Effect.Effect<Scope.Scope, never, RefSubject<never, E, A>> {
+  return fromEffect<never, E, A>(Effect.sync(initial), eq)
+}
+
+/**
+ * Construct a RefSubject from any Fx value.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<R, E, A>(
+  fx: Effect.Effect<R, E, A>,
+  eq?: Equivalence<A>
+): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>
+export function make<R, E, A>(
+  fx: Fx.FxInput<R, E, A>,
+  eq?: Equivalence<A>
+): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>>
+
+export function make<R, E, A>(
+  fx: Fx.FxInput<R, E, A>,
+  eq?: Equivalence<A>
+): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A>> {
+  return coreRefSubject.make(fx, eq)
+}
+
+/**
+ * Create a contextual wrapper around a RefSubject while maintaing the full API of
+ * a Ref Subject.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function tagged<A>(defaultEq?: Equivalence<A>): {
+  <const I extends C.IdentifierConstructor<any>>(
+    identifier: (id: typeof C.id) => I
+  ): RefSubject.Tagged<C.IdentifierOf<I>, never, A>
+  <const I>(identifier: I | string): RefSubject.Tagged<C.IdentifierOf<I>, never, A>
+}
+export function tagged<E, A>(defaultEq?: Equivalence<A>): {
+  <const I extends C.IdentifierConstructor<any>>(
+    identifier: (id: typeof C.id) => I
+  ): RefSubject.Tagged<C.IdentifierOf<I>, E, A>
+  <const I>(identifier: I | string): RefSubject.Tagged<C.IdentifierOf<I>, E, A>
+}
+
+export function tagged(defaultEq?: Equivalence<any>): {
+  <const I extends C.IdentifierConstructor<any>>(
+    identifier: (id: typeof C.id) => I
+  ): RefSubject.Tagged<C.IdentifierOf<I>, any, any> | RefSubject.Tagged<C.IdentifierOf<I>, never, any>
+  <const I>(
+    identifier: I | string
+  ): RefSubject.Tagged<C.IdentifierOf<I>, any, any> | RefSubject.Tagged<C.IdentifierOf<I>, never, any>
+} {
+  function makeTagged<const I extends C.IdentifierFactory<any>>(
+    identifier: I
+  ): RefSubject.Tagged<C.IdentifierOf<I>, any, any>
+  function makeTagged<const I>(identifier: I): RefSubject.Tagged<C.IdentifierOf<I>, any, any>
+  function makeTagged<const I>(identifier: I): RefSubject.Tagged<C.IdentifierOf<I>, any, any> {
+    return new ContextImpl(C.Tagged<I, RefSubject<never, any, any>>(identifier), defaultEq) as any
   }
 
-  return {
-    filterMapEffect,
-    filterMap,
-    filterEffect,
-    filter,
-    filterNotEffect,
-    filterNot,
-  } as const
+  return makeTagged
 }
 
-function makeComputedMethods<E, A>(
-  f: () => RefSubject<E, A>,
-): Pick<RefSubject<E, A>, 'mapEffect' | 'map'> {
-  const get = makeMemoizedGet(f)
-
-  function mapEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): Computed<R2, E | E2, B> {
-    return new ComputedImpl(get(), f)
-  }
-
-  function map<B>(f: (a: A) => B): Computed<never, E, B> {
-    return mapEffect((a) => Effect.sync(() => f(a)))
-  }
+class ContextImpl<I, E, A> extends FxEffectBase<I, E, A, I, E, A> implements RefSubject<I, E, A> {
+  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
 
-  return {
-    mapEffect,
-    map,
-  } as const
-}
+  readonly version: RefSubject<I, E, A>["version"]
+  readonly subscriberCount: RefSubject<I, E, A>["subscriberCount"]
+  readonly get: RefSubject<I, E, A>["get"]
+  readonly delete: RefSubject<I, E, A>["delete"]
+  readonly interrupt: RefSubject<I, E, A>["interrupt"]
 
-function makeTransformMethods<E, A>(
-  f: () => RefSubject<E, A>,
-): Pick<RefSubject<E, A>, 'transformBoth' | 'transform' | 'transformGet'> {
-  const get = makeMemoizedGet(f)
+  constructor(readonly tag: C.Tagged<I, RefSubject<never, E, A>>, readonly defaultEq?: Equivalence<A>) {
+    super()
 
-  function transformBoth<R3, E3, C, R4, E4, D>(
-    f: (fx: Fx<never, E, A>) => Fx<R3, E3, C>,
-    g: (effect: Effect.Effect<never, E, A>) => Effect.Effect<R4, E4, D>,
-  ): RefTransform<R3, E3, C, R4, E4, D> {
-    return new RefTransformImpl(get(), f, g)
+    this.version = tag.withEffect((ref) => ref.version)
+    this.subscriberCount = tag.withEffect((ref) => ref.subscriberCount)
+    this.get = tag.withEffect((ref) => ref.get)
+    this.delete = tag.withEffect((ref) => ref.delete)
+    this.interrupt = tag.withEffect((r) => r.interrupt)
   }
 
-  function transform<R3, E3, C>(
-    f: (fx: Fx<never, E, A>) => Fx<R3, E3, C>,
-  ): RefTransform<R3, E3, C, never, E, A> {
-    return transformBoth(f, identity)
+  protected toFx(): Fx.Fx<I, E, A> {
+    return fromFxEffect(this.tag)
   }
 
-  function transformGet<R3, E3, C>(
-    f: (effect: Effect.Effect<never, E, A>) => Effect.Effect<R3, E3, C>,
-  ): RefTransform<never, E, A, R3, E3, C> {
-    return transformBoth(identity, f)
+  protected toEffect(): Effect.Effect<I, E, A> {
+    return this.get
   }
 
-  return {
-    transformBoth,
-    transform,
-    transformGet,
-  } as const
-}
-
-const placeholders = {
-  _tag: 'Commit',
-  [Effect.EffectTypeId]: refVariance,
-  i0: undefined,
-  i1: undefined,
-  i2: undefined,
-  [Equal.symbol](that: unknown) {
-    return this === that
-  },
-  [Hash.symbol]() {
-    return Hash.random(this)
-  },
-  pipe() {
-    // eslint-disable-next-line prefer-rest-params
-    return pipeArguments(this, arguments)
-  },
-}
-
-function makeEffectMethods<E, A>(
-  get: RefSubject<E, A>['get'],
-): Pick<RefSubject<E, A>, Extract<keyof Effect.Effect<never, E, A>, keyof RefSubject<E, A>>> {
-  return Object.assign(
-    {
-      commit() {
-        return get
-      },
-    } as const,
-    placeholders,
-  ) as any
-}
+  runUpdate: RefSubject<I, E, A>["runUpdate"] = (
+    f,
+    onInterrupt
+  ) => this.tag.withEffect((ref) => ref.runUpdate(f, onInterrupt))
 
-function makeMemoizedGet<A>(f: () => A) {
-  let memoized: Option.Option<A> = Option.none()
+  modifyEffect: <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) => Effect.Effect<I | R2, E | E2, B> = (
+    f
+  ) => this.tag.withEffect((ref) => ref.modifyEffect(f))
+
+  modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<I, E, B> = (f) =>
+    this.tag.withEffect((ref) => ref.modify(f))
+
+  updateEffect: <R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) => Effect.Effect<I | R2, E | E2, A> = (f) =>
+    this.tag.withEffect((ref) => ref.updateEffect(f))
 
-  return () => {
-    if (Option.isNone(memoized)) {
-      memoized = Option.some(f())
-    }
+  update: (f: (a: A) => A) => Effect.Effect<I, E, A> = (f) => this.tag.withEffect((ref) => ref.update(f))
 
-    return (memoized as Option.Some<A>).value
-  }
-}
+  set: (a: A) => Effect.Effect<I, never, A> = (a) => this.tag.withEffect((ref) => ref.set(a))
+
+  mapEffect: <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) => Computed<R2, E | E2, B> = (f) =>
+    Computed(this as any, f)
+
+  map: <B>(f: (a: A) => B) => Computed<I, E, B> = (f) => Computed(this as any, (a: A) => Effect.sync(() => f(a)))
+
+  filterMapEffect: <R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+  ) => Filtered<R2, E | E2, B> = (f) => Filtered(this as any, f)
+
+  filterMap: <B>(f: (a: A) => Option.Option<B>) => Filtered<never, E, B> = (f) =>
+    Filtered(this as any, (a: A) => Effect.sync(() => f(a)))
+
+  filter: (f: (a: A) => boolean) => Filtered<I, E, A> = (f) =>
+    this.filterMap((a) => f(a) ? Option.some(a) : Option.none())
+
+  filterEffect: <R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>) => Filtered<I | R2, E | E2, A> = (f) =>
+    this.filterMapEffect((a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()))
+
+  skipRepeats: (eq?: Equivalence<A> | undefined) => Computed<I, E, A> = (eq = equals) =>
+    fromTag(this.tag, (s) => s.skipRepeats(eq))
+
+  onFailure: (cause: Cause.Cause<E>) => Effect.Effect<I, never, unknown> = (cause) =>
+    this.tag.withEffect((ref) => ref.onFailure(cause))
+
+  onSuccess: (value: A) => Effect.Effect<I, never, unknown> = (a) => this.tag.withEffect((ref) => ref.onSuccess(a))
+
+  make = <R>(fx: Fx.Fx<R, E, A>, eq?: Equivalence<A>): Layer.Layer<R, never, I> =>
+    this.tag.scoped(make(fx, eq || this.defaultEq))
+
+  of = (value: A, eq?: Equivalence<A>): Layer.Layer<never, never, I> => this.tag.scoped(of(value, eq))
+
+  provide = <R2>(fx: Fx.Fx<R2, E, A>, eq?: Equivalence<A>) => Effect.provide(this.make(fx, eq || this.defaultEq))
+
+  provideFx = <R2>(fx: Fx.Fx<R2, E, A>, eq?: Equivalence<A>) => provide(this.make(fx, eq || this.defaultEq))
+}
+
+/**
+ * Construct a RefSubject from any Fx value.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function makeWithExtension<R, E, A, B>(
+  fx: Effect.Effect<R, E, A>,
+  f: (ref: RefSubject<never, E, A>) => B,
+  eq?: Equivalence<A>
+): Effect.Effect<R, never, RefSubject<never, E, A> & B>
+export function makeWithExtension<R, E, A, B>(
+  fx: Fx.FxInput<R, E, A>,
+  f: (ref: RefSubject<never, E, A>) => B,
+  eq?: Equivalence<A>
+): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A> & B>
+
+export function makeWithExtension<R, E, A, B>(
+  fx: Fx.FxInput<R, E, A>,
+  f: (ref: RefSubject<never, E, A>) => B,
+  eq?: Equivalence<A>
+): Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, A> & B> {
+  return coreRefSubject.makeWithExtension(fx, f, eq)
+}
+
+/**
+ * Construct a RefSubject with an initial value and the specified subject.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const unsafeMake: <R, E, A>(
+  initial: Effect.Effect<R, E, A>,
+  subject: Subject.Subject<R, E, A>,
+  eq?: Equivalence<A>
+) => RefSubject<R, E, A> = coreRefSubject.unsafeMake
+
+/**
+ * Flatten an RefSubject of an Option into a Filtered.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const compact = <R, E, A>(refSubject: RefSubject<R, E, Option.Option<A>>): Filtered<R, E, A> =>
+  refSubject.filterMap(identity)
+
+/**
+ * Split a RefSubject's into 2 Filtered values that track its errors and
+ * success values separately.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const split = <R, E, A>(
+  refSubject: RefSubject<R, E, A>
+): readonly [Filtered<R, never, E>, Filtered<R, never, A>] => {
+  const versioned = Versioned.transform(refSubject, exit, Effect.exit)
+  const left = Filtered(versioned, getLeft)
+  const right = Filtered(versioned, getRight)
+
+  return [left, right] as const
+}
+
+const getLeft = <E, A>(exit: Exit.Exit<E, A>) =>
+  Effect.succeed(
+    Exit.match(exit, {
+      onFailure: (cause) => Cause.failureOption(cause),
+      onSuccess: () => Option.none()
+    })
+  )
 
-type RefSubjectContext<E, A> = {
-  initial: Effect.Effect<never, E, A>
-  currentRef: MutableRef.MutableRef<Option.Option<A>>
-  initializingFiberRef: MutableRef.MutableRef<Option.Option<Fiber.RuntimeFiber<E, A>>>
-  lock: Lock
-  scope: Scope.Scope
-  eq: Equivalence.Equivalence<A>
-  hold: HoldFx<never, E, A>
-  version: MutableRef.MutableRef<number>
-}
+const getRight = <E, A>(exit: Exit.Exit<E, A>) =>
+  Effect.succeed(
+    Exit.match(exit, {
+      onFailure: Option.none,
+      onSuccess: Option.some
+    })
+  )
 
-function makeRefSubjectContext<E, A>(
-  initial: Effect.Effect<never, E, A>,
-  scope: Scope.Scope,
-  eq: Equivalence.Equivalence<A> = fastDeepEqual,
-) {
-  const hold = new HoldFx(never<E, A>())
-  const ctx: RefSubjectContext<E, A> = {
-    initial,
-    currentRef: hold.current,
-    initializingFiberRef: MutableRef.make(Option.none()),
-    lock: Effect.unsafeMakeSemaphore(1).withPermits(1),
-    scope,
-    eq,
-    hold,
-    version: MutableRef.make(0),
+/**
+ * MakeRefSubject is a RefSubject factory function dervied from a Schema.
+ * @since 1.18.0
+ */
+export type MakeRefSubject<O> = {
+  <R, E>(
+    input: RefSubject<R, E, O>,
+    eq?: Equivalence<O>
+  ): Effect.Effect<R | Scope.Scope, never, ToDerived<R, E, O>>
+
+  <R, E>(input: Effect.Effect<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>
+
+  <R, E>(
+    input: Stream.Stream<R, E, O>,
+    eq?: Equivalence<O>
+  ): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>
+
+  <R, E>(input: Fx.Fx<R, E, O>, eq?: Equivalence<O>): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>
+
+  <E>(input: Cause.Cause<E>, eq?: Equivalence<O>): Effect.Effect<Scope.Scope, never, ToRefSubject<E, O>>
+
+  <R, E>(
+    input: Fx.FxInput<R, E, O>,
+    eq?: Equivalence<O>
+  ): Effect.Effect<R | Scope.Scope, never, ToRefSubject<E, O>>
+}
+
+/**
+ * Converts an error `E` and an output `O` into a RefSubject or a Record of RefSubjects if
+ * the ouput value is a Record as well.
+ * @since 1.18.0
+ */
+export type ToRefSubject<E, O> = O extends Readonly<Record<PropertyKey, any>> ? {
+    readonly [K in keyof O]: ToRefSubject<E, O[K]>
+  } :
+  RefSubject<never, E, O> // TODO: We should apply ParseErrors here too somehow
+
+/**
+ * Converts an error `E` and an output `O` into a RefSubject or a Record of RefSubjects if
+ * the ouput value is a Record as well.
+ * @since 1.18.0
+ */
+export type ToDerived<R, E, O> = ToRefSubject<E, O> & {
+  readonly persist: Effect.Effect<R, E, O>
+}
+
+/**
+ * Derive a RefSubjectSchema using the "from" or "encoded" value represented by a Schema.
+ * @since 1.18.0
+ */
+export function deriveFromSchema<I, O>(schema: Schema.Schema<I, O>): MakeRefSubject<I> {
+  return fromRefSubject(schema)
+}
+
+/**
+ * Derive a RefSubjectSchema using the "to" or "decoded" value represented by a Schema.
+ * @since 1.18.0
+ */
+export function deriveToSchema<I, O>(schema: Schema.Schema<I, O>): MakeRefSubject<O> {
+  return toRefSubject(schema)
+}
+
+/**
+ * @since 1.18.0
+ */
+export const tuple: <const REFS extends ReadonlyArray<RefSubject.Any>>(
+  ...refs: REFS
+) => RefSubject<
+  RefSubject.Context<REFS[number]>,
+  RefSubject.Error<REFS[number]>,
+  { readonly [K in keyof REFS]: RefSubject.Success<REFS[K]> }
+> = coreRefSubject.tuple
+
+/**
+ * @since 1.18.0
+ */
+export const struct: <const REFS extends Readonly<Record<PropertyKey, RefSubject.Any>>>(
+  refs: REFS
+) => RefSubject<
+  RefSubject.Context<REFS[string]>,
+  RefSubject.Error<REFS[string]>,
+  { readonly [K in keyof REFS]: RefSubject.Success<REFS[K]> }
+> = coreRefSubject.struct
+
+/**
+ * @since 1.18.0
+ */
+export function fromSubscriptionRef<A>(
+  subscriptionRef: SubscriptionRef.SubscriptionRef<A>
+): Effect.Effect<Scope.Scope, never, RefSubject<never, never, A>> {
+  return coreRefSubject.make(fromStream(subscriptionRef.changes))
+}
+
+/**
+ * @since 1.18.0
+ */
+export const transform: {
+  <A, B>(from: (a: A) => B, to: (b: B) => A): <R, E>(ref: RefSubject<R, E, A>) => RefSubject<R, E, B>
+  <R, E, A, B>(ref: RefSubject<R, E, A>, from: (a: A) => B, to: (b: B) => A): RefSubject<R, E, B>
+} = dual(3, function transform<R, E, A, B>(
+  ref: RefSubject<R, E, A>,
+  from: (a: A) => B,
+  to: (b: B) => A
+): RefSubject<R, E, B> {
+  return new TransformImpl(ref, from, to)
+})
+
+class TransformImpl<R, E, A, B> extends FxEffectBase<R, E, B, R, E, B> implements RefSubject<R, E, B> {
+  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
+
+  readonly version: RefSubject<R, E, B>["version"]
+  readonly subscriberCount: RefSubject<R, E, B>["subscriberCount"]
+  readonly get: RefSubject<R, E, B>["get"]
+  readonly delete: RefSubject<R, E, B>["delete"]
+  readonly interrupt: RefSubject<R, E, B>["interrupt"]
+
+  constructor(
+    readonly ref: RefSubject<R, E, A>,
+    readonly from: (a: A) => B,
+    readonly to: (b: B) => A
+  ) {
+    super()
+
+    this.version = ref.version
+    this.subscriberCount = ref.subscriberCount
+    this.get = Effect.map(ref.get, from)
+    this.delete = Effect.map(ref.delete, Option.map(from))
+    this.interrupt = ref.interrupt
   }
 
-  return ctx
-}
-
-function unsafeMakeRefPrimitive<E, A>(
-  initial: Effect.Effect<never, E, A>,
-  scope: Scope.Scope,
-  eq: Equivalence.Equivalence<A>,
-): RefPrimitive<E, A> {
-  const ctx = makeRefSubjectContext(initial, scope, eq)
-  const get = makeGetFromContext(ctx)
-  const set = makeSetFromContext(ctx)
-  const multiUpdate = makeMultiUpdateFromContext(get, set, ctx.lock)
-
-  function run<R2>(sink: Sink<R2, E, A>) {
-    return Effect.suspend(() => {
-      const current = MutableRef.get(ctx.hold.current)
-
-      if (Option.isNone(current)) {
-        return pipe(
-          primitive.get,
-          Effect.catchAllCause(sink.error),
-          Effect.flatMap(() => ctx.hold.run(sink)),
-        )
-      }
-
-      return ctx.hold.run(sink)
-    })
+  protected toFx(): Fx.Fx<R, E, B> {
+    return this.ref.map(this.from)
   }
 
-  const primitive: RefPrimitive<E, A> = {
-    delete: makeDeleteFromContext(ctx, get),
-    end: makeEndFromContext(ctx),
-    eq,
-    error: (cause) => ctx.hold.error(cause),
-    event: set,
-    get,
-    modifyEffect: makeModifyEffectFromContext(get, ctx),
-    run,
-    set,
-    multiUpdate,
-    version: ctx.version,
+  protected toEffect(): Effect.Effect<R, E, B> {
+    return this.ref.map(this.from)
   }
 
-  return primitive
-}
+  set: RefSubject<R, E, B>["set"] = (b) => Effect.map(this.ref.set(this.to(b)), this.from)
+  update: RefSubject<R, E, B>["update"] = (f) => Effect.map(this.ref.update((a) => this.to(f(this.from(a)))), this.from)
 
-function makeRefFromPrimitive<E, A>(primitive: RefPrimitive<E, A>): RefSubject<E, A> {
-  const ref: RefSubject<E, A> = {
-    [FxTypeId]: refVariance,
-    [RefSubjectTypeId]: RefSubjectTypeId,
-    [ComputedTypeId]: ComputedTypeId,
-    ...primitive,
-    ...makeRefMethods(primitive),
-    ...makeEffectMethods(primitive.get),
-    ...makeFiltered(() => ref),
-    ...makeComputedMethods(() => ref),
-    ...makeTransformMethods(() => ref),
-    version() {
-      return MutableRef.get(primitive.version)
-    },
-  }
+  updateEffect: RefSubject<R, E, B>["updateEffect"] = (f) =>
+    Effect.map(this.ref.updateEffect((a) => Effect.map(f(this.from(a)), this.to)), this.from)
 
-  return ref
-}
+  modifyEffect: RefSubject<R, E, B>["modifyEffect"] = (f) =>
+    this.ref.modifyEffect((a) => Effect.map(f(this.from(a)), ([c, b]) => [c, this.to(b)] as const))
 
-// Base Ref which provides all functionality that can otherwise be derived
-// using makeRefFromPrimitive
-interface RefPrimitive<E, A> {
-  // Fx
-  run: RefSubject<E, A>['run']
-
-  // Subject
-  event: RefSubject<E, A>['event']
-  error: RefSubject<E, A>['error']
-  end: RefSubject<E, A>['end']
-
-  // Ref
-  eq: RefSubject<E, A>['eq']
-  get: RefSubject<E, A>['get']
-  modifyEffect: RefSubject<E, A>['modifyEffect']
-  set: RefSubject<E, A>['set']
-  delete: RefSubject<E, A>['delete']
-  multiUpdate: RefSubject<E, A>['multiUpdate']
-
-  // Primitive
-  version: MutableRef.MutableRef<number>
-}
+  modify: RefSubject<R, E, B>["modify"] = (f) =>
+    this.ref.modify((a) => {
+      const [c, b] = f(this.from(a))
+      return [c, this.to(b)] as const
+    })
 
-// Internals for RefSubject.tuple
-
-function tupleRefPrimitive<const Refs extends ReadonlyArray<RefSubject.Any>>(
-  refs: Refs,
-): RefPrimitive<Fx.Error<Refs[number]>, { readonly [K in keyof Refs]: Fx.Success<Refs[K]> }> {
-  type _E = Fx.Error<Refs[number]>
-  type _A = { readonly [K in keyof Refs]: Fx.Success<Refs[K]> }
-
-  const hold = new HoldFx(combineAll(...refs) as any as Fx<never, _E, _A>)
-  const eq = Equivalence.tuple(...refs.map((ref) => ref.eq))
-  const get = Effect.all(
-    refs.map((ref) => ref.get),
-    unboundedConcurrency,
-  ) as Effect.Effect<never, _E, _A>
-  const set = (value: { readonly [K in keyof Refs]: Fx.Success<Refs[K]> }) =>
-    Effect.all(
-      value.map((v, i) => refs[i].set(v)),
-      unboundedConcurrency,
-    ) as Effect.Effect<never, never, _A>
-  const multiUpdate = makeMultiUpdateFromContext(get, set, identity)
-
-  const primitive: RefPrimitive<_E, _A> = {
-    multiUpdate,
-    delete: Effect.map(
-      Effect.all(
-        refs.map((ref) => ref.delete),
-        unboundedConcurrency,
-      ),
-      (values) => Option.all(values),
-    ) as Effect.Effect<never, _E, Option.Option<_A>>,
-    end: () =>
-      Effect.all(
-        refs.map((ref) => ref.end()),
-        unboundedConcurrency,
-      ),
-    eq,
-    error: (error) => hold.error(error),
-    event: (value) =>
-      Effect.all(
-        value.map((v, i) => refs[i].event(v)),
-        unboundedConcurrency,
-      ),
-    get,
-    modifyEffect: makeModifyEffectTuple(refs, get, eq),
-    run: (sink) => hold.run(sink),
-    set,
-    version: MutableRef.make(0),
-  }
+  runUpdate: RefSubject<R, E, B>["runUpdate"] = (f) =>
+    this.ref.runUpdate((get, set) => f(Effect.map(get, this.from), (b) => Effect.map(set(this.to(b)), this.from)))
 
-  return primitive
-}
+  mapEffect: RefSubject<R, E, B>["mapEffect"] = (f) => Computed(this, f)
 
-function makeModifyEffectTuple<
-  const Refs extends ReadonlyArray<RefSubject.Any>,
-  E,
-  A extends readonly any[],
->(
-  refs: Refs,
-  get: Effect.Effect<never, E, A>,
-  eq: Equivalence.Equivalence<A>,
-): RefSubject<E, A>['modifyEffect'] {
-  return <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) => {
-    return Effect.gen(function* ($) {
-      const current = yield* $(get)
-      const [b, a] = yield* $(f(current))
-
-      if (eq(a, current)) {
-        return b
-      }
-
-      yield* $(
-        Effect.all(
-          refs.map((ref, i) => ref.set(a[i])),
-          unboundedConcurrency,
-        ),
-      )
-
-      return b
-    })
-  }
-}
-
-function structRefPrimitive<const Refs extends Readonly<Record<string, RefSubject.Any>>>(
-  refs: Refs,
-): RefPrimitive<Fx.Error<Refs[string]>, { readonly [K in keyof Refs]: Fx.Success<Refs[K]> }> {
-  type _E = Fx.Error<Refs[string]>
-  type _A = { readonly [K in keyof Refs]: Fx.Success<Refs[K]> }
-
-  const hold = new HoldFx(struct(refs)) as HoldFx<never, _E, _A>
-  const eq = Equivalence.struct(mapRecord(refs, (ref) => ref.eq))
-  const get = Effect.all(
-    mapRecord(refs, (ref) => ref.get),
-    unboundedConcurrency,
-  ) as Effect.Effect<never, _E, _A>
-  const set = (value: { readonly [K in keyof Refs]: Fx.Success<Refs[K]> }) =>
-    Effect.all(
-      mapRecord(value, (v, i) => refs[i].set(v)),
-      unboundedConcurrency,
-    ) as Effect.Effect<never, never, _A>
-  const multiUpdate = makeMultiUpdateFromContext(get, set, identity)
-
-  const primitive: RefPrimitive<_E, _A> = {
-    multiUpdate,
-    delete: Effect.map(
-      Effect.all(
-        mapRecord(refs, (ref) => ref.delete),
-        unboundedConcurrency,
-      ),
-      (values) => Option.all(values),
-    ) as Effect.Effect<never, _E, Option.Option<_A>>,
-    end: () =>
-      Effect.all(
-        mapRecord(refs, (ref) => ref.end()),
-        unboundedConcurrency,
-      ),
-    eq,
-    error: (error) => hold.error(error),
-    event: (value) =>
-      Effect.all(
-        mapRecord(value, (v, i) => refs[i].event(v)),
-        unboundedConcurrency,
-      ),
-    get,
-    modifyEffect: makeModifyEffectStruct(refs, get, eq),
-    run: (sink) => hold.run(sink),
-    set: (value) =>
-      Effect.all(
-        mapRecord(value, (v, i) => refs[i].set(v)),
-        unboundedConcurrency,
-      ) as Effect.Effect<never, never, _A>,
-    version: MutableRef.make(0),
-  }
+  map: RefSubject<R, E, B>["map"] = (f) => this.mapEffect((b) => Effect.sync(() => f(b)))
 
-  return primitive
-}
+  filterMapEffect: RefSubject<R, E, B>["filterMapEffect"] = (f) => Filtered(this, f)
 
-function makeModifyEffectStruct<
-  const Refs extends Readonly<Record<string, RefSubject.Any>>,
-  E,
-  A extends Readonly<Record<string, any>>,
->(
-  refs: Refs,
-  get: Effect.Effect<never, E, A>,
-  eq: Equivalence.Equivalence<A>,
-): RefSubject<E, A>['modifyEffect'] {
-  return <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) => {
-    return Effect.gen(function* ($) {
-      const current = yield* $(get)
-      const [b, a] = yield* $(f(current))
-
-      if (eq(a, current)) {
-        return b
-      }
-
-      yield* $(
-        Effect.all(
-          mapRecord(refs, (ref, i) => ref.set(a[i])),
-          unboundedConcurrency,
-        ),
-      )
-
-      return b
-    })
-  }
-}
+  filterMap: RefSubject<R, E, B>["filterMap"] = (f) => Filtered(this, (a) => Effect.sync(() => f(a)))
 
-function mapRecord<K extends string, A, B>(
-  record: Readonly<Record<K, A>>,
-  f: (a: A, k: K) => B,
-): { readonly [_ in K]: B } {
-  const result: Record<K, B> = {} as any
+  filter: RefSubject<R, E, B>["filter"] = (f) => this.filterMap((a) => f(a) ? Option.some(a) : Option.none())
 
-  for (const k in record) {
-    result[k] = f(record[k], k)
-  }
+  filterEffect: RefSubject<R, E, B>["filterEffect"] = (f) =>
+    this.filterMapEffect((a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()))
 
-  return result
-}
+  onSuccess: RefSubject<R, E, B>["onSuccess"] = (b) => this.ref.onSuccess(this.to(b))
 
-export interface AsRefParams<A, R2 = never, E2 = never> {
-  readonly eq?: Equivalence.Equivalence<A>
-  readonly onValue?: (value: A) => Effect.Effect<R2, E2, unknown>
-}
+  onFailure: RefSubject<R, E, B>["onFailure"] = (b) => this.ref.onFailure(b)
 
-export function asRef<R, E, A, R2 = never, E2 = never>(
-  fx: Fx<R, E, A>,
-  params: AsRefParams<A, R2, E2> = {},
-) {
-  return Effect.flatMap(Deferred.make<E | E2, A>(), (deferred) =>
-    Effect.flatMap(makeRef(Deferred.await(deferred), params.eq), (ref) => {
-      const event = (value: A) =>
-        Effect.flatMap(Deferred.succeed(deferred, value), (closed) =>
-          closed ? Effect.unit : ref.set(value),
-        )
-
-      const to = switchMatchCauseEffect(fx, ref.error, event)
-      const from = params.onValue ? switchMatchCauseEffect(ref, ref.error, params.onValue) : unit
-      const both = merge(from, to)
-
-      return Effect.as(Effect.forkScoped(Effect.catchAllCause(drain(both), ref.error)), ref)
-    }),
-  )
+  skipRepeats: (eq?: Equivalence<B> | undefined) => Computed<R, E, B> = (eq = equals) =>
+    Computed<R, E, B, never, never, B>(
+      Versioned.transformFx<R, never, R, E, B, R, E, B, R, E, B>(
+        this,
+        skipRepeatsWith(eq)
+      ),
+      Effect.succeed
+    )
 }