@typed/fx 1.27.3 → 1.28.0

package/src/RefSubject.ts

@@ -4,27 +4,31 @@
  */
 
 import * as C from "@typed/context"
-import type { Equivalence, FiberId, Runtime } from "effect"
-import { Fiber, MutableRef, Unify } from "effect"
+import type { Tracer } from "effect"
+import * as Array from "effect/Array"
 import * as Boolean from "effect/Boolean"
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
-import * as Equal from "effect/Equal"
+import type * as Equivalence from "effect/Equivalence"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
 import { dual, identity } from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as MutableRef from "effect/MutableRef"
 import { sum } from "effect/Number"
 import * as Option from "effect/Option"
-import * as ReadonlyArray from "effect/ReadonlyArray"
+import type * as Runtime from "effect/Runtime"
 import * as Scope from "effect/Scope"
+import * as Unify from "effect/Unify"
 import { type Fx } from "./Fx.js"
-import * as core from "./internal/core.js"
+import * as internal from "./internal/core.js"
 import * as DeferredRef from "./internal/DeferredRef.js"
 import { getExitEquivalence, matchEffectPrimitive, withScope } from "./internal/helpers.js"
 import { FxEffectBase } from "./internal/protos.js"
 import { runtimeToLayer } from "./internal/provide.js"
-import * as share from "./internal/share.js"
+import { hold } from "./internal/share.js"
 import type { UnionToTuple } from "./internal/UnionToTuple.js"
 import * as Sink from "./Sink.js"
 import * as Subject from "./Subject.js"
@@ -33,6 +37,15 @@ import * as Versioned from "./Versioned.js"
 
 const UNBOUNDED = { concurrency: "unbounded" } as const
 
+// TODO: Kind of a Hack, but I don't really want to pollute the public API with this. What should we do with this?
+const CURRENT_ENVIRONMENT_TAG = C.Tagged<never, string>("@typed/environment/CurrentEnvironment")
+const checkIsDOM = (ctx: C.Context<any>) =>
+  C.getOption(ctx, CURRENT_ENVIRONMENT_TAG).pipe(
+    Option.map((s) => s === "dom" || s === "test:dom"),
+    // Default behavior should allow multiple updates via Fx interface
+    Option.getOrElse(() => true)
+  )
+
 /**
  * A Computed is essentially a readonly RefSubject.
  * @since 1.20.0
@@ -143,9 +156,16 @@ export namespace RefSubject {
      * @since 1.20.0
      */
     readonly make: <R>(
-      fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R>,
-      options?: RefSubjectOptions<A>
+      fxOrEffect: Fx<A, E, R | Scope.Scope> | Effect.Effect<A, E, R | Scope.Scope>,
+      options?: RefSubjectOptions<A> & { readonly drop?: number; readonly take?: number }
     ) => Layer.Layer<I, never, R>
+
+    /**
+     * @since 2.0.0
+     */
+    readonly layer: <E2, R2>(
+      make: Effect.Effect<RefSubject<A, E>, E2, R2 | Scope.Scope>
+    ) => Layer.Layer<I, E2, R2>
   }
 
   /**
@@ -213,7 +233,6 @@ export type Identifier<T> = RefSubject.Identifier<T>
  */
 export interface RefSubjectOptions<A> {
   readonly eq?: Equivalence.Equivalence<A>
-  readonly replay?: number
   readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy
 }
 
@@ -234,15 +253,17 @@ export function fromFx<A, E, R>(
   fx: Fx<A, E, R>,
   options?: RefSubjectOptions<A>
 ): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope> {
-  return DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? Equal.equals)).pipe(
+  return DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? internal.deepEquals)).pipe(
     Effect.bindTo("deferredRef"),
     Effect.bind("core", ({ deferredRef }) => makeCore(deferredRef, options)),
     Effect.tap(({ core, deferredRef }) =>
       Effect.forkIn(
         fx.run(Sink.make(
           (cause) =>
-            Effect.flatMap(Effect.sync(() => deferredRef.done(Exit.failCause(cause))), () =>
-              core.subject.onFailure(cause)),
+            Effect.flatMap(
+              Effect.sync(() => deferredRef.done(Exit.failCause(cause))),
+              () => core.subject.onFailure(cause)
+            ),
           (value) =>
             Effect.flatMap(Effect.sync(() => deferredRef.done(Exit.succeed(value))), () => setCore(core, value))
         )),
@@ -260,7 +281,7 @@ export function fromRefSubject<A, E, R>(
   ref: RefSubject<A, E, R>,
   options?: RefSubjectOptions<A>
 ): Effect.Effect<RefSubject.Derived<A, E, R>, never, R | Scope.Scope> {
-  return DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? Equal.equals)).pipe(
+  return DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? internal.deepEquals)).pipe(
     Effect.bindTo("deferredRef"),
     Effect.bind("core", ({ deferredRef }) => makeCore<A, E, R>(deferredRef, options)),
     Effect.tap(({ core, deferredRef }) =>
@@ -358,15 +379,21 @@ export function unsafeMake<E, A>(
   const { id, initial, options, scope } = params
   return Effect.flatMap(Effect.runtime(), (runtime) => {
     const core = unsafeMakeCore(initial, id, runtime, scope, options)
+    const current = MutableRef.get(core.deferredRef.current)
 
     // Sometimes we might be instantiating directly from a known value
     // Here we seed the value and ensure the subject has it as well for re-broadcasting
-    if ("initialValue" in params) {
+    if ("initialValue" in params && Option.isNone(current)) {
       core.deferredRef.done(Exit.succeed(params.initialValue))
       return Effect.map(core.subject.onSuccess(params.initialValue), () => new RefSubjectImpl(core))
+    } else if (Option.isSome(current)) {
+      return Effect.map(
+        Effect.matchCauseEffect(current.value, core.subject),
+        () => new RefSubjectImpl(core)
+      )
+    } else {
+      return Effect.succeed(new RefSubjectImpl(core))
     }
-
-    return Effect.succeed(new RefSubjectImpl(core))
   })
 }
 
@@ -411,7 +438,7 @@ class RefSubjectImpl<A, E, R, R2> extends FxEffectBase<A, E, Exclude<R, R2> | Sc
   }
 
   unsafeGet: () => Exit.Exit<A, E> = () =>
-    Option.getOrThrowWith(this.core.deferredRef.current, () => new Cause.NoSuchElementException())
+    Option.getOrThrowWith(MutableRef.get(this.core.deferredRef.current), () => new Cause.NoSuchElementException())
 
   onSuccess(value: A): Effect.Effect<unknown, never, Exclude<R, R2>> {
     return setCore(this.core, value)
@@ -593,7 +620,7 @@ export const runUpdates: {
                 Effect.tapErrorCause(Unify.unify((cause) =>
                   Cause.isInterruptedOnly(cause)
                     ? options.onInterrupt(initial)
-                    : Effect.unit
+                    : Effect.void
                 ))
               )
           )
@@ -607,7 +634,7 @@ export const runUpdates: {
             Effect.tapErrorCause(Unify.unify((cause) =>
               Cause.isInterruptedOnly(cause)
                 ? Effect.flatMap(ref.get, options.onInterrupt)
-                : Effect.unit
+                : Effect.void
             ))
           )
         )
@@ -619,12 +646,13 @@ export const runUpdates: {
 class RefSubjectCore<A, E, R, R2> {
   constructor(
     readonly initial: Effect.Effect<A, E, R>,
-    readonly subject: Subject.Subject<A, E, R>,
+    readonly subject: Subject.HoldSubjectImpl<A, E>,
     readonly runtime: Runtime.Runtime<R2>,
     readonly scope: Scope.CloseableScope,
     readonly deferredRef: DeferredRef.DeferredRef<E, A>,
     readonly semaphore: Effect.Semaphore
-  ) {}
+  ) {
+  }
 
   public _fiber: Fiber.Fiber<A, E> | undefined = undefined
 }
@@ -640,22 +668,9 @@ function makeCore<A, E, R>(
       "scope",
       ({ executionStrategy, runtime }) => Scope.fork(C.get(runtime.context, Scope.Scope), executionStrategy)
     ),
-    Effect.bind(
-      "deferredRef",
-      () => DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? Equal.equals))
-    ),
-    Effect.let("subject", () => Subject.unsafeMake<A, E>(Math.max(1, options?.replay ?? 1))),
-    Effect.tap(({ scope, subject }) => Scope.addFinalizer(scope, subject.interrupt)),
-    Effect.map(({ deferredRef, runtime, scope, subject }) =>
-      new RefSubjectCore(
-        initial,
-        subject,
-        runtime,
-        scope,
-        deferredRef,
-        Effect.unsafeMakeSemaphore(1)
-      )
-    )
+    Effect.bind("id", () => Effect.fiberId),
+    Effect.map(({ id, runtime, scope }) => unsafeMakeCore(initial, id, runtime, scope, options)),
+    Effect.tap((core) => Scope.addFinalizer(core.scope, Effect.provide(core.subject.interrupt, core.runtime.context)))
   )
 }
 
@@ -666,14 +681,33 @@ function unsafeMakeCore<A, E, R>(
   scope: Scope.CloseableScope,
   options?: RefSubjectOptions<A>
 ) {
-  return new RefSubjectCore(
+  const subject = new Subject.HoldSubjectImpl<A, E>()
+  const core = new RefSubjectCore(
     initial,
-    Subject.unsafeMake<A, E>(Math.max(1, options?.replay ?? 1)),
+    subject,
     runtime,
     scope,
-    DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? Equal.equals)),
+    DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? internal.deepEquals), subject.lastValue),
     Effect.unsafeMakeSemaphore(1)
   )
+
+  const onSuccess = (a: A) => core.deferredRef.done(Exit.succeed(a))
+  const onCause = (cause: Cause.Cause<E>) => core.deferredRef.done(Exit.failCause(cause))
+  const onError = (e: E) => onCause(Cause.fail(e))
+
+  // Initialize the core with the initial value if it is synchronous
+  matchEffectPrimitive(initial, {
+    Success: onSuccess,
+    Failure: onCause,
+    Some: onSuccess,
+    None: onError,
+    Left: onError,
+    Right: onSuccess,
+    Sync: (f) => onSuccess(f()),
+    Otherwise: () => false
+  })
+
+  return core
 }
 
 function getOrInitializeCore<A, E, R, R2>(
@@ -681,7 +715,7 @@ function getOrInitializeCore<A, E, R, R2>(
   lockInitialize: boolean
 ): Effect.Effect<A, E, Exclude<R, R2>> {
   return Effect.suspend(() => {
-    if (core._fiber === undefined && Option.isNone(core.deferredRef.current)) {
+    if (core._fiber === undefined && Option.isNone(MutableRef.get(core.deferredRef.current))) {
       return initializeCoreAndTap(core, lockInitialize)
     } else {
       return core.deferredRef
@@ -704,7 +738,7 @@ function initializeCoreEffect<A, E, R, R2>(
 
   return Effect.flatMap(
     Effect.forkIn(
-      lock && core.semaphore ? core.semaphore.withPermits(1)(initialize) : initialize,
+      lock ? core.semaphore.withPermits(1)(initialize) : initialize,
       core.scope
     ),
     (fiber) => Effect.sync(() => core._fiber = fiber)
@@ -736,7 +770,7 @@ function initializeCore<A, E, R, R2>(
     None: onError,
     Left: onError,
     Right: onSuccess,
-    Sync: (f) => onSuccess(f()),
+    Sync: (f) => Effect.suspend(() => onSuccess(f())),
     Otherwise: () => initializeCoreEffect(core, lock)
   })
 }
@@ -772,7 +806,7 @@ function onFailureCore<A, E, R, R2>(core: RefSubjectCore<A, E, R, R2>, cause: Ca
     if (core.deferredRef.done(exit)) {
       return sendEvent(core, exit)
     } else {
-      return Effect.unit
+      return Effect.void
     }
   })
 }
@@ -782,7 +816,7 @@ function interruptCore<A, E, R, R2>(core: RefSubjectCore<A, E, R, R2>): Effect.E
     core.deferredRef.reset()
 
     const closeScope = Scope.close(core.scope, Exit.interrupt(id))
-    const interruptFiber = core._fiber ? Fiber.interrupt(core._fiber) : Effect.unit
+    const interruptFiber = core._fiber ? Fiber.interrupt(core._fiber) : Effect.void
     const interruptSubject = core.subject.interrupt
 
     return Effect.all([closeScope, interruptFiber, interruptSubject], { discard: true })
@@ -793,7 +827,7 @@ function deleteCore<A, E, R, R2>(
   core: RefSubjectCore<A, E, R, R2>
 ): Effect.Effect<Option.Option<A>, E, Exclude<R, R2>> {
   return Effect.suspend(() => {
-    const current = core.deferredRef.current
+    const current = MutableRef.get(core.deferredRef.current)
     core.deferredRef.reset()
 
     if (Option.isNone(current)) {
@@ -803,7 +837,7 @@ function deleteCore<A, E, R, R2>(
     return core.subject.subscriberCount.pipe(
       Effect.provide(core.runtime.context),
       Effect.flatMap(
-        (count: number) => count > 0 && !core._fiber ? initializeCore(core, false) : Effect.unit
+        (count: number) => count > 0 && !core._fiber ? initializeCore(core, false) : Effect.void
       ),
       Effect.zipRight(Effect.asSome(current.value))
     )
@@ -1039,6 +1073,7 @@ class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3> extends Versioned.Version
   R0 | Exclude<R, Scope.Scope> | R2 | R3
 > implements Computed<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3> {
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
+  private _computed: Fx<C, E0 | E | E2 | E3, R0 | R | Scope.Scope | R2 | R3>
 
   constructor(
     readonly input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
@@ -1046,9 +1081,28 @@ class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3> extends Versioned.Version
   ) {
     super(
       input,
-      (fx) => share.hold(core.mapEffect(fx, f)) as any,
+      (fx) => internal.mapEffect(fx, f) as any,
       Effect.flatMap(f)
     )
+
+    this._computed = hold(internal.fromFxEffect(
+      Effect.contextWith((ctx: C.Context<R0 | R | Scope.Scope | R2 | R3>) => {
+        if (checkIsDOM(ctx)) {
+          return internal.fromEffect(input).pipe(
+            (_) => internal.continueWith(_, () => input),
+            internal.skipRepeats,
+            (_) => internal.mapEffect(_, f),
+            internal.skipRepeats
+          )
+        }
+
+        return internal.fromEffect(Effect.flatMap(input, f))
+      })
+    ))
+  }
+
+  run<R4>(sink: Sink.Sink<C, E0 | E | E2 | E3, R4>) {
+    return this._computed.run(sink) as any
   }
 
   unsafeGet: () => Exit.Exit<C, E0 | E | E2 | E3> = () =>
@@ -1073,12 +1127,13 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3> extends Versioned.Version
   R2,
   C,
   E0 | E | E2 | E3,
-  Exclude<R, Scope.Scope> | R2 | R3 | Scope.Scope,
+  R0 | Exclude<R, Scope.Scope> | R2 | R3 | Scope.Scope,
   C,
   E0 | E | E2 | E3 | Cause.NoSuchElementException,
-  R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3
-> implements Filtered<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3 | R2 | R3> {
+  R0 | Exclude<R, Scope.Scope> | R2 | R3
+> implements Filtered<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3> {
   readonly [FilteredTypeId]: FilteredTypeId = FilteredTypeId
+  private _filtered: Fx<C, E | E2 | E3, Scope.Scope | R0 | R | R2 | R3 | Exclude<R, Scope.Scope>>
 
   constructor(
     readonly input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
@@ -1086,9 +1141,27 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3> extends Versioned.Version
   ) {
     super(
       input,
-      (fx) => share.hold(core.filterMapEffect(fx, f)) as any,
+      (fx) => internal.filterMapEffect(fx, f) as any,
       (effect) => Effect.flatten(Effect.flatMap(effect, f))
     )
+
+    this._filtered = hold(internal.fromFxEffect(
+      Effect.contextWith((ctx: C.Context<R0 | Exclude<R, Scope.Scope> | R2 | R3 | Scope.Scope>) => {
+        if (checkIsDOM(ctx)) {
+          return internal.fromEffect(input).pipe(
+            (_) => internal.continueWith(_, () => input),
+            internal.skipRepeats,
+            (_) => internal.filterMapEffect(_, f),
+            internal.skipRepeats
+          )
+        }
+
+        return Effect.flatMap(input, f).pipe(
+          internal.fromEffect,
+          (_) => internal.filterMap(_, identity)
+        )
+      })
+    ))
   }
 
   static make<R0, E0, A, E, R, E2, R2, C, E3, R3>(
@@ -1106,6 +1179,10 @@ class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3> extends Versioned.Version
     return ComputedImpl.make(this.input, this.f)
   }
 
+  run<R4>(sink: Sink.Sink<C, E0 | E | E2 | E3, R4>) {
+    return this._filtered.run(sink) as any
+  }
+
   unsafeGet: () => Exit.Exit<C, Cause.NoSuchElementException | E0 | E | E2 | E3> = () =>
     Option.getOrThrowWith(this._currentValue, () => new Cause.NoSuchElementException())
 }
@@ -1136,7 +1213,7 @@ export const skipRepeatsWith: {
   ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>,
   eq: Equivalence.Equivalence<A>
 ): Computed<A, E, R> | Filtered<A, E, R> {
-  const versioned = Versioned.transform(ref, (fx) => core.skipRepeatsWith(fx, eq), identity)
+  const versioned = Versioned.transform(ref, (fx) => internal.skipRepeatsWith(fx, eq), identity)
 
   if (FilteredTypeId in ref) {
     return FilteredImpl.make(versioned, Effect.succeedSome)
@@ -1163,7 +1240,7 @@ export function skipRepeats<A, E, R>(
 export function skipRepeats<A, E, R>(
   ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>
 ): Computed<A, E, R> | Filtered<A, E, R> {
-  return skipRepeatsWith(ref, Equal.equals)
+  return skipRepeatsWith(ref, internal.deepEquals)
 }
 
 /**
@@ -1270,8 +1347,8 @@ class RefSubjectTransformEffect<A, E, R, B, E2, R2, R3, E3>
   }
 
   run<R4 = never>(sink: Sink.Sink<B, E | E2 | E3, R4>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope | R4> {
-    return core.skipRepeats(
-      core.merge(core.tapEffect(core.mapEffect(this.ref, this.from), this.subject.onSuccess), this.subject)
+    return internal.skipRepeats(
+      internal.merge(internal.tapEffect(internal.mapEffect(this.ref, this.from), this.subject.onSuccess), this.subject)
     ).run(
       sink
     )
@@ -1481,7 +1558,7 @@ class RefSubjectTuple<
     this.interrupt = Effect.all(refs.map((r) => r.interrupt), UNBOUNDED)
     this.subscriberCount = Effect.map(
       Effect.all(refs.map((r) => r.subscriberCount), UNBOUNDED),
-      ReadonlyArray.reduce(0, sum)
+      Array.reduce(0, sum)
     )
 
     this.getSetDelete = {
@@ -1652,7 +1729,7 @@ class RefSubjectStruct<
     this.interrupt = Effect.all(Object.values(refs).map((r) => r.interrupt), UNBOUNDED)
     this.subscriberCount = Effect.map(
       Effect.all(Object.values(refs).map((r) => r.subscriberCount), UNBOUNDED),
-      ReadonlyArray.reduce(0, sum)
+      Array.reduce(0, sum)
     )
 
     this.getSetDelete = {
@@ -1865,10 +1942,23 @@ class RefSubjectTagged<I, E, A> extends FxEffectBase<
     return this.tag.withEffect((ref) => ref.onSuccess(value))
   }
 
+  layer = <E2, R2>(make: Effect.Effect<RefSubject<A, E>, E2, R2 | Scope.Scope>): Layer.Layer<I, E2, R2> =>
+    this.tag.scoped(make)
+
   make = <R>(
-    fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R>,
-    options?: RefSubjectOptions<A>
-  ): Layer.Layer<I, never, R> => this.tag.scoped(make(fxOrEffect, options))
+    fxOrEffect: Fx<A, E, R | Scope.Scope> | Effect.Effect<A, E, R | Scope.Scope>,
+    options?: RefSubjectOptions<A> & { readonly drop?: number; readonly take?: number }
+  ): Layer.Layer<I, never, R> => {
+    return this.tag.scoped(Effect.gen(function*(_) {
+      let ref = yield* make(fxOrEffect, options)
+
+      if (options?.drop || options?.take) {
+        ref = slice(ref, options.drop ?? 0, options.take ?? Infinity)
+      }
+
+      return ref
+    }))
+  }
 }
 
 /**
@@ -1906,7 +1996,7 @@ class RefSubjectFromTag<I, S, A, E, R> extends FxEffectBase<
     super()
 
     this._get = Effect.map(tag, f)
-    this._fx = core.fromFxEffect(this._get)
+    this._fx = internal.fromFxEffect(this._get)
 
     this.version = Effect.flatMap(this._get, (ref) => ref.version)
     this.interrupt = Effect.flatMap(this._get, (ref) => ref.interrupt)
@@ -2221,7 +2311,7 @@ export const slice: {
 } = dual(
   3,
   function slice<A, E, R>(ref: RefSubject<A, E, R>, drop: number, take: number): RefSubject<A, E, R> {
-    return new RefSubjectSlice(ref, drop, take)
+    return new RefSubjectSimpleTransform(ref, (_) => internal.slice(_, drop, take), identity)
   }
 )
 
@@ -2245,35 +2335,121 @@ export const take: {
   return slice(ref, 0, take)
 })
 
-class RefSubjectSlice<A, E, R> extends FxEffectBase<A, E, R | Scope.Scope, A, E, R> implements RefSubject<A, E, R> {
+/**
+ * Get the current value of the RefSubject. If it has not been set yet, a Fiber will be used to wait for the value to be set.
+ *
+ * @since 1.25.0
+ */
+export const get: {
+  <A, E = never, R = never>(ref: RefSubject<A, E, R>): Effect.Effect<A, E, R>
+  <A, E = never, R = never>(ref: Computed<A, E, R>): Effect.Effect<A, E, R>
+  <A, E = never, R = never>(ref: Filtered<A, E, R>): Effect.Effect<A, E | Cause.NoSuchElementException, R>
+} = <A, E, R>(
+  ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>
+): Effect.Effect<A, E | Cause.NoSuchElementException, R> => ref
+
+/**
+ * Synchronously get the current Exit value of the RefSubject. If it has not been set yet, a Cause.NoSuchElementException will be thrown.
+ *
+ * Note: This is unimplemented for RefSubject.tagged and RefSubject.fromTag because they require the Effect context by definition.
+ * It will throw immediately.
+ *
+ * @since 1.25.0
+ */
+export const unsafeGetExit = <A, E = never, R = never>(ref: RefSubject<A, E, R>): Exit.Exit<A, E> => ref.unsafeGet()
+
+/**
+ * Synchronously get the current value of the RefSubject.
+ *
+ * @since 1.25.0
+ */
+export const unsafeGet = <A, E = never, R = never>(ref: RefSubject<A, E, R>): A => Effect.runSync(unsafeGetExit(ref))
+
+/**
+ * Extract all values from an object using a Proxy
+ *
+ * @since 2.0.0
+ */
+export const proxy: {
+  <A extends ReadonlyArray<any> | Readonly<Record<PropertyKey, any>>, E, R>(
+    source: Computed<A, E, R>
+  ): { readonly [K in keyof A]: Computed<A[K], E, R> }
+
+  <A extends ReadonlyArray<any> | Readonly<Record<PropertyKey, any>>, E, R>(
+    source: Filtered<A, E, R>
+  ): { readonly [K in keyof A]: Filtered<A[K], E, R> }
+} = <
+  A extends Readonly<Record<PropertyKey, any>> | ReadonlyArray<any>,
+  E,
+  R
+>(
+  source: Computed<A, E, R> | Filtered<A, E, R>
+): any => {
+  const target: any = {}
+  return new Proxy(target, {
+    get(self, prop) {
+      if (prop in self) return self[prop]
+      return self[prop] = map(source, (a) => a[prop as keyof A])
+    }
+  })
+}
+
+/**
+ * @since 2.0.0
+ */
+export const withSpan: {
+  (name: string, options?: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly context?: C.Context<never>
+  }): <A, E, R>(self: RefSubject<A, E, R>) => RefSubject<A, E, R>
+
+  <A, E, R>(self: RefSubject<A, E, R>, name: string, options?: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly context?: C.Context<never>
+  }): RefSubject<A, E, R>
+} = dual(
+  isRefSubjectDataFirst,
+  (ref, name, options) =>
+    new RefSubjectSimpleTransform(ref, (fx) => internal.withSpan(fx, name, options), Effect.withSpan(name, options))
+)
+
+class RefSubjectSimpleTransform<A, E, R, R2, R3> extends FxEffectBase<A, E, R | R2 | Scope.Scope, A, E, R | R3>
+  implements RefSubject<A, E, R | R2 | R3>
+{
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
 
   readonly version: Effect.Effect<number, E, R>
   readonly interrupt: Effect.Effect<void, never, R>
   readonly subscriberCount: Effect.Effect<number, never, R>
-  private _fx: Fx<A, E, Scope.Scope | R>
+  private _fx: Fx<A, E, Scope.Scope | R | R2>
 
   constructor(
     readonly ref: RefSubject<A, E, R>,
-    readonly drop: number,
-    readonly take: number
+    readonly transformFx: (fx: Fx<A, E, Scope.Scope | R>) => Fx<A, E, Scope.Scope | R | R2>,
+    readonly transformEffect: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | R3>
   ) {
     super()
 
     this.version = ref.version
     this.interrupt = ref.interrupt
     this.subscriberCount = ref.subscriberCount
-    this._fx = share.hold(core.slice(ref, drop, take))
-    this._effect = ref
+
+    this._fx = transformFx(ref)
   }
 
-  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2 | Scope.Scope> {
+  run<R4>(sink: Sink.Sink<A, E, R4>) {
     return this._fx.run(sink)
   }
 
-  toEffect(): Effect.Effect<A, E, R> {
-    return this.ref
+  toEffect(): Effect.Effect<A, E, R | R3> {
+    return this.transformEffect(this.ref)
   }
 
   runUpdates<E2, R2, C>(
@@ -2294,31 +2470,19 @@ class RefSubjectSlice<A, E, R> extends FxEffectBase<A, E, R | Scope.Scope, A, E,
 }
 
 /**
- * Get the current value of the RefSubject. If it has not been set yet, a Fiber will be used to wait for the value to be set.
- *
- * @since 1.25.0
- */
-export const get: {
-  <A, E = never, R = never>(ref: RefSubject<A, E, R>): Effect.Effect<A, E, R>
-  <A, E = never, R = never>(ref: Computed<A, E, R>): Effect.Effect<A, E, R>
-  <A, E = never, R = never>(ref: Filtered<A, E, R>): Effect.Effect<A, E | Cause.NoSuchElementException, R>
-} = <A, E, R>(
-  ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>
-): Effect.Effect<A, E | Cause.NoSuchElementException, R> => ref
-
-/**
- * Synchronously get the current Exit value of the RefSubject. If it has not been set yet, a Cause.NoSuchElementException will be thrown.
- *
- * Note: This is unimplemented for RefSubject.tagged and RefSubject.fromTag because they require the Effect context by definition.
- * It will throw immediately.
- *
- * @since 1.25.0
+ * @since 2.0.0
  */
-export const unsafeGetExit = <A, E = never, R = never>(ref: RefSubject<A, E, R>): Exit.Exit<A, E> => ref.unsafeGet()
+export const when: {
+  <B, C>(options: { onTrue: B; onFalse: C }): {
+    <E, R>(ref: Filtered<boolean, E, R>): Filtered<B | C, E, R>
+    <E, R>(ref: Computed<boolean, E, R>): Computed<B | C, E, R>
+  }
 
-/**
- * Synchronously get the current value of the RefSubject.
- *
- * @since 1.25.0
- */
-export const unsafeGet = <A, E = never, R = never>(ref: RefSubject<A, E, R>): A => Effect.runSync(unsafeGetExit(ref))
+  <E, R, B, C>(ref: Filtered<boolean, E, R>, options: { onTrue: B; onFalse: C }): Filtered<B | C, E, R>
+  <E, R, B, C>(ref: Computed<boolean, E, R>, options: { onTrue: B; onFalse: C }): Computed<B | C, E, R>
+} = dual(2, function when<E, R, B, C>(ref: Computed<boolean, E, R> | Filtered<boolean, E, R>, options: {
+  onTrue: B
+  onFalse: C
+}): any {
+  return map(ref, (a) => a ? options.onTrue : options.onFalse)
+})