@typed/fx 1.32.0 → 2.0.0-beta.1

package/src/RefSubject/RefSubject.ts

@@ -0,0 +1,2646 @@
+/** @effect-diagnostics missingEffectError:skip-file */
+/** @effect-diagnostics missingEffectContext:skip-file */
+
+import * as Array from "effect/Array";
+import type * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Semaphore from "effect/Semaphore";
+import { equals } from "effect/Equal";
+import type { Equivalence } from "effect/Equivalence";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+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 { pipeArguments } from "effect/Pipeable";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import * as Stream from "effect/Stream";
+import { compact as fxCompact } from "../Fx/combinators/compact.js";
+import { continueWith } from "../Fx/combinators/continueWith.js";
+import { filterMapEffect as fxFilterMapEffect } from "../Fx/combinators/filterMapEffect.js";
+import { mapEffect as fxMapEffect } from "../Fx/combinators/mapEffect.js";
+import { skipRepeats } from "../Fx/combinators/skipRepeats.js";
+import type { Bounds } from "../Fx/combinators/slice.js";
+import { slice as fxSlice } from "../Fx/combinators/slice.js";
+import { unwrap } from "../Fx/combinators/unwrap.js";
+import { fromEffect as fxFromEffect } from "../Fx/constructors/fromEffect.js";
+import { fromYieldable } from "../Fx/constructors/fromYieldable.js";
+import type { Error as FxError, Fx } from "../Fx/index.js";
+import * as DeferredRef from "../Fx/internal/DeferredRef.js";
+import { getExitEquivalence } from "../Fx/internal/equivalence.js";
+import type { UnionToTuple } from "../Fx/internal/UnionToTuple.js";
+import { YieldableFx } from "../Fx/internal/yieldable.js";
+import { FxTypeId, isFx } from "../Fx/TypeId.js";
+import * as Sink from "../Sink/Sink.js";
+import * as Subject from "../Subject/Subject.js";
+import * as Versioned from "../Versioned/Versioned.js";
+
+export const RefSubjectTypeId = Symbol.for("@typed/fx/RefSubject");
+export type RefSubjectTypeId = typeof RefSubjectTypeId;
+
+export const ComputedTypeId = Symbol.for("@typed/fx/Computed");
+export type ComputedTypeId = typeof ComputedTypeId;
+
+export const FilteredTypeId = Symbol.for("@typed/fx/Filtered");
+export type FilteredTypeId = typeof FilteredTypeId;
+
+/**
+ * A `Computed` is a read-only view of a value that can change over time.
+ * It is an `Fx` that emits the current value and subsequent updates.
+ * It is also an `Effect` that samples the current value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * // Create a RefSubject and derive a Computed from it
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   // Create a computed that doubles the count
+ *   const doubled = RefSubject.map(count, (n) => n * 2)
+ *
+ *   // Sample the computed value
+ *   const value = yield* doubled
+ *   console.log(value) // 0
+ *
+ *   // Update the source
+ *   yield* RefSubject.set(count, 5)
+ *
+ *   // The computed automatically reflects the change
+ *   const newValue = yield* doubled
+ *   console.log(newValue) // 10
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Computed<out A, out E = never, out R = never> extends Versioned.Versioned<
+  R,
+  E,
+  A,
+  E,
+  R | Scope.Scope,
+  A,
+  E,
+  R
+> {
+  readonly [ComputedTypeId]: ComputedTypeId;
+}
+
+export declare namespace Computed {
+  export type Any =
+    | Computed<any, any, any>
+    | Computed<never, any, any>
+    | Computed<any, never, any>
+    | Computed<never, never, any>;
+}
+
+/**
+ * A `Filtered` is a `Computed` that may not always have a value.
+ * It is essentially a `Computed<Option<A>>` with helper methods.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * // Create a RefSubject and filter it
+ * const program = Effect.gen(function* () {
+ *   const numbers = yield* RefSubject.make([1, 2, 3, 4, 5])
+ *
+ *   // Get the first even number (filtered)
+ *   const firstEven = RefSubject.filterMap(
+ *     numbers,
+ *     (arr) => Option.fromNullable(arr.find((n) => n % 2 === 0))
+ *   )
+ *
+ *   // Try to get the value (may fail with NoSuchElementError)
+ *   const value = yield* firstEven
+ *   console.log(value) // 2
+ *
+ *   // Or convert back to Option
+ *   const option = firstEven.asComputed()
+ *   const maybeValue = yield* option
+ *   console.log(Option.isSome(maybeValue)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Filtered<out A, out E = never, out R = never> extends Versioned.Versioned<
+  R,
+  E,
+  A,
+  E,
+  R | Scope.Scope,
+  A,
+  E | Cause.NoSuchElementError,
+  R
+> {
+  readonly [FilteredTypeId]: FilteredTypeId;
+
+  /**
+   * Converts the Filtered back to a Computed of Option.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Option } from "effect"
+   * import * as RefSubject from "@typed/fx/RefSubject"
+   *
+   * const program = Effect.gen(function* () {
+   *   const filtered = RefSubject.filterMap(
+   *     yield* RefSubject.make([1, 2, 3]),
+   *     (arr) => Option.fromNullable(arr.find((n) => n > 5))
+   *   )
+   *
+   *   // Convert to Computed<Option<number>>
+   *   const computed = filtered.asComputed()
+   *   const option = yield* computed
+   *   console.log(Option.isNone(option)) // true (no number > 5)
+   * })
+   * ```
+   */
+  asComputed(): Computed<Option.Option<A>, E, R>;
+}
+
+export declare namespace Filtered {
+  export type Any =
+    | Filtered<any, any, any>
+    | Filtered<never, any, any>
+    | Filtered<any, never, any>
+    | Filtered<never, never, any>;
+}
+
+/**
+ * Interface for basic RefSubject operations: get, set, delete.
+ * @since 1.0.0
+ * @category models
+ */
+export interface GetSetDelete<A, E = never, R = never> {
+  readonly get: Effect.Effect<A, E, R>;
+  readonly set: (a: A) => Effect.Effect<A, E, R>;
+  readonly delete: Effect.Effect<Option.Option<A>, E, R>;
+}
+
+/**
+ * A `RefSubject` is a mutable reference that can be observed as an Fx.
+ * It combines the capabilities of a `Ref` (get/set/update) with a `Subject` (subscribe).
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * // Create a RefSubject with an initial value
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   // Get the current value
+ *   const current = yield* count
+ *   console.log(current) // 0
+ *
+ *   // Update the value
+ *   yield* RefSubject.set(count, 5)
+ *   const updated = yield* count
+ *   console.log(updated) // 5
+ *
+ *   // Use as an Fx to observe changes
+ *   yield* Fx.observe(
+ *     count,
+ *     (value) => Effect.sync(() => console.log("Count changed:", value))
+ *   )
+ *
+ *   // Increment
+ *   yield* RefSubject.increment(count)
+ *   // Output: "Count changed: 6"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface RefSubject<A, E = never, R = never>
+  extends Computed<A, E, R>, Subject.Subject<A, E, R> {
+  readonly [RefSubjectTypeId]: RefSubjectTypeId;
+
+  /**
+   * Runs an effect that can modify the RefSubject transactionally.
+   * All operations within the transaction are atomic and serialized.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   * import * as RefSubject from "@typed/fx/RefSubject"
+   *
+   * const program = Effect.gen(function* () {
+   *   const balance = yield* RefSubject.make(100)
+   *
+   *   // Transfer money atomically
+   *   yield* balance.updates((ref) =>
+   *     Effect.gen(function* () {
+   *       const current = yield* ref.get
+   *       if (current >= 50) {
+   *         yield* ref.set(current - 50)
+   *         return "Transfer successful"
+   *       }
+   *       return "Insufficient funds"
+   *     })
+   *   )
+   * })
+   * ```
+   */
+  readonly updates: <B, E2, R2>(
+    f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>,
+  ) => Effect.Effect<B, E | E2, R | R2>;
+
+  /**
+   * Interrupts the RefSubject, stopping all subscriptions and cleaning up resources.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   * import * as RefSubject from "@typed/fx/RefSubject"
+   *
+   * const program = Effect.gen(function* () {
+   *   const ref = yield* RefSubject.make(0)
+   *
+   *   // Later, clean up
+   *   yield* ref.interrupt
+   * })
+   * ```
+   */
+  readonly interrupt: Effect.Effect<void, never, R>;
+}
+
+export declare namespace RefSubject {
+  export type Any =
+    | RefSubject<any, any, any>
+    | RefSubject<any, any>
+    | RefSubject<any, never, any>
+    | RefSubject<any>;
+
+  export interface Service<Self, Id extends string, A, E> extends RefSubject<A, E, Self> {
+    readonly id: Id;
+
+    readonly service: ServiceMap.Service<Self, RefSubject<A, E>>;
+
+    readonly make: <R = never>(
+      value: A | Effect.Effect<A, E, R> | Fx<A, E, R>,
+      options?: RefSubjectOptions<A> & { readonly skip?: number; readonly take?: number },
+    ) => Layer.Layer<Self, never, Exclude<R, Scope.Scope>>;
+
+    readonly layer: <E2, R2>(
+      make: Effect.Effect<RefSubject<A, E>, E2, R2 | Scope.Scope>,
+    ) => Layer.Layer<Self, E2, Exclude<R2, Scope.Scope>>;
+  }
+
+  export interface Class<Self, Id extends string, A, E> extends RefSubject.Service<Self, Id, A, E> {
+    new (): RefSubject.Service<Self, Id, A, E>;
+  }
+}
+export const CurrentComputedBehavior = ServiceMap.Reference("@typed/fx/CurrentComputedBehavior", {
+  defaultValue: (): "one" | "multiple" => "multiple",
+});
+
+const checkIsMultiple = (
+  ctx: ServiceMap.ServiceMap<any>,
+): ctx is ServiceMap.ServiceMap<"multiple"> =>
+  ServiceMap.getReferenceUnsafe(ctx, CurrentComputedBehavior) === "multiple";
+
+class ComputedImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
+  extends Versioned.VersionedTransform<
+    R0,
+    E0,
+    A,
+    E,
+    R,
+    A,
+    E2,
+    R2,
+    C,
+    E0 | E | E2 | E3,
+    R0 | Exclude<R, Scope.Scope> | R2 | R3 | Scope.Scope,
+    C,
+    E0 | E | E2 | E3,
+    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>;
+
+  override input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>;
+  readonly f: (a: A) => Effect.Effect<C, E3, R3>;
+
+  constructor(
+    input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+    f: (a: A) => Effect.Effect<C, E3, R3>,
+  ) {
+    super(input, (fx) => fxMapEffect(fx, f) as any, Effect.flatMap(f));
+
+    this.input = input;
+    this.f = f;
+
+    this._computed = Subject.hold(
+      unwrap(
+        Effect.map(Effect.services(), (ctx) => {
+          if (checkIsMultiple(ctx)) {
+            return fromYieldable(input).pipe(
+              continueWith(() => input),
+              skipRepeats,
+              fxMapEffect(f),
+            );
+          }
+
+          return fxFromEffect(Effect.flatMap(input.asEffect(), f));
+        }),
+      ),
+    );
+  }
+
+  override run<RSink>(sink: Sink.Sink<C, E0 | E | E2 | E3, RSink>) {
+    return this._computed.run(sink) as any;
+  }
+}
+
+export function makeComputed<R0, E0, A, E, R, E2, R2, C, E3, R3>(
+  input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+  f: (a: A) => Effect.Effect<C, E3, R3>,
+): Computed<C, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>> {
+  return new ComputedImpl(input, f);
+}
+
+export function makeFiltered<R0, E0, A, E, R, E2, R2, C, E3, R3>(
+  input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+  f: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>,
+): Filtered<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3> {
+  return new FilteredImpl(input, f);
+}
+
+class FilteredImpl<R0, E0, A, E, R, E2, R2, C, E3, R3>
+  extends Versioned.VersionedTransform<
+    R0,
+    E0,
+    A,
+    E,
+    R,
+    A,
+    E2,
+    R2,
+    C,
+    E0 | E | E2 | E3,
+    R0 | Exclude<R, Scope.Scope> | R2 | R3 | Scope.Scope,
+    C,
+    E0 | E | E2 | E3 | Cause.NoSuchElementError,
+    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 _computed: Fx<C, E0 | E | E2 | E3, R0 | R | Scope.Scope | R2 | R3>;
+
+  override input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>;
+  readonly f: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>;
+
+  constructor(
+    input: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+    f: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>,
+  ) {
+    super(
+      input,
+      (fx) => fxFilterMapEffect(fx, f) as any,
+      (effect) => Effect.flatMap(Effect.flatMap(effect, f), (option) => option.asEffect()),
+    );
+
+    this.input = input;
+    this.f = f;
+
+    this._computed = Subject.hold(
+      unwrap(
+        Effect.map(Effect.services(), (ctx) => {
+          if (checkIsMultiple(ctx)) {
+            return fromYieldable(input).pipe(
+              continueWith(() => input),
+              skipRepeats,
+              fxFilterMapEffect(f),
+            );
+          }
+
+          return fxCompact(fxFromEffect(Effect.flatMap(input.asEffect(), f)));
+        }),
+      ),
+    );
+  }
+
+  override run<RSink>(sink: Sink.Sink<C, E0 | E | E2 | E3, RSink>) {
+    return this._computed.run(sink) as any;
+  }
+
+  asComputed(): Computed<
+    Option.Option<C>,
+    E0 | E | E2 | E3,
+    R0 | R2 | R3 | Exclude<R, Scope.Scope>
+  > {
+    return new ComputedImpl(this.input, this.f);
+  }
+}
+
+class RefSubjectCore<A, E, R, R2> {
+  readonly initial: Effect.Effect<A, E, R>;
+  readonly subject: Subject.HoldSubjectImpl<A, E>;
+  readonly services: ServiceMap.ServiceMap<R2>;
+  readonly scope: Scope.Closeable;
+  readonly deferredRef: DeferredRef.DeferredRef<E, A>;
+  readonly semaphore: Semaphore.Semaphore;
+  constructor(
+    initial: Effect.Effect<A, E, R>,
+    subject: Subject.HoldSubjectImpl<A, E>,
+    services: ServiceMap.ServiceMap<R2>,
+    scope: Scope.Closeable,
+    deferredRef: DeferredRef.DeferredRef<E, A>,
+    semaphore: Semaphore.Semaphore,
+  ) {
+    this.initial = initial;
+    this.subject = subject;
+    this.services = services;
+    this.scope = scope;
+    this.deferredRef = deferredRef;
+    this.semaphore = semaphore;
+  }
+
+  public _fiber: Fiber.Fiber<A, E> | undefined = undefined;
+}
+
+export interface RefSubjectOptions<A> {
+  readonly eq?: Equivalence<A>;
+}
+
+function getSetDelete<A, E, R, R2>(
+  ref: RefSubjectCore<A, E, R, R2>,
+): GetSetDelete<A, E, Exclude<R, R2>> {
+  return {
+    get: getOrInitializeCore(ref, false),
+    set: (a) => setCore(ref, a),
+    delete: deleteCore(ref),
+  };
+}
+class RefSubjectImpl<A, E, R, R2>
+  extends YieldableFx<A, E, Exclude<R, R2> | Scope.Scope, A, E, Exclude<R, R2>>
+  implements RefSubject<A, E, Exclude<R, R2>>
+{
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId;
+  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId;
+
+  readonly version: Effect.Effect<number>;
+  readonly interrupt: Effect.Effect<void, never, Exclude<R, R2>>;
+  readonly subscriberCount: Effect.Effect<number, never, Exclude<R, R2>>;
+
+  readonly getSetDelete: GetSetDelete<A, E, Exclude<R, R2>>;
+
+  readonly core: RefSubjectCore<A, E, R, R2>;
+
+  constructor(core: RefSubjectCore<A, E, R, R2>) {
+    super();
+
+    this.core = core;
+    this.version = Effect.sync(() => core.deferredRef.version);
+    this.interrupt = Effect.provide(interruptCore(core), core.services);
+    this.subscriberCount = Effect.provide(core.subject.subscriberCount, core.services);
+    this.getSetDelete = getSetDelete(core);
+
+    this.updates = this.updates.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+    this.onFailure = this.onFailure.bind(this);
+  }
+
+  run<R3>(
+    sink: Sink.Sink<A, E, R3>,
+  ): 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.services),
+    });
+  }
+
+  updates<R3, E3, B>(run: (ref: GetSetDelete<A, E, Exclude<R, R2>>) => Effect.Effect<B, E3, R3>) {
+    return this.core.semaphore.withPermits(1)(run(this.getSetDelete));
+  }
+
+  onSuccess(value: A): Effect.Effect<unknown, never, Exclude<R, R2>> {
+    return setCore(this.core, value);
+  }
+
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, Exclude<R, R2>> {
+    return onFailureCore(this.core, cause);
+  }
+
+  toEffect(): Effect.Effect<A, E, Exclude<R, R2>> {
+    return getOrInitializeCore(this.core, true);
+  }
+}
+
+/**
+ * Creates a new `RefSubject` from a value, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * // From a plain value
+ * const program1 = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(42)
+ *   const value = yield* ref
+ *   console.log(value) // 42
+ * })
+ *
+ * // From an Effect
+ * const program2 = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(
+ *     Effect.succeed("Hello")
+ *   )
+ *   const value = yield* ref
+ *   console.log(value) // "Hello"
+ * })
+ *
+ * // From an Fx (tracks the latest value)
+ * const program3 = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(
+ *     Fx.fromIterable([1, 2, 3])
+ *   )
+ *   const value = yield* ref
+ *   console.log(value) // 3 (latest value)
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function make<A, E = never, R = never>(
+  effect: A | Effect.Effect<A, E, R> | Stream.Stream<A, E, R> | Fx<A, E, R>,
+  options?: RefSubjectOptions<A>,
+): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope> {
+  if (isFx(effect)) {
+    return fromFx(effect, options);
+  } else if (Effect.isEffect(effect)) {
+    return fromEffect(effect, options);
+  } else if (Stream.isStream(effect)) {
+    return fromStream(effect, options);
+  } else {
+    return fromEffect<A, E, R>(Effect.succeed(effect), options);
+  }
+}
+
+/**
+ * Creates a `RefSubject` from an `Effect`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromEffect(
+ *     Effect.succeed("Initial value")
+ *   )
+ *
+ *   const value = yield* ref
+ *   console.log(value) // "Initial value"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function fromEffect<A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  options?: RefSubjectOptions<A>,
+): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope> {
+  return Effect.map(makeCore(effect, options), (core) => new RefSubjectImpl(core));
+}
+
+/**
+ * Creates a `RefSubject` from an `Fx`, tracking the latest emitted value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ * import { Fx } from "@typed/fx"
+ *
+ * const program = Effect.gen(function* () {
+ *   // Create an Fx that emits multiple values
+ *   const numbers = Fx.fromIterable([1, 2, 3, 4, 5])
+ *
+ *   // Create a RefSubject that tracks the latest value
+ *   const ref = yield* RefSubject.fromFx(numbers)
+ *
+ *   // Get the latest value
+ *   const latest = yield* ref
+ *   console.log(latest) // 5
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function fromFx<A, E, R>(
+  fx: Fx<A, E, R>,
+  options?: RefSubjectOptions<A>,
+): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope> {
+  return Effect.gen(function* () {
+    const core = yield* makeDeferredCore<A, E, R>(options);
+    const ref = new RefSubjectImpl(core);
+    yield* Effect.forkIn(
+      fx.run(
+        Sink.make(
+          (cause) => onFailureCore(core, cause),
+          (value) => setCore(core, value),
+        ),
+      ),
+      core.scope,
+      { startImmediately: true },
+    );
+    return ref;
+  });
+}
+
+export function fromStream<A, E, R>(
+  stream: Stream.Stream<A, E, R>,
+  options?: RefSubjectOptions<A>,
+): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope> {
+  return Effect.gen(function* () {
+    const core = yield* makeDeferredCore<A, E, R>(options);
+    const ref = new RefSubjectImpl(core);
+    yield* Effect.forkIn(
+      stream.pipe(
+        redirectCause(core),
+        Stream.runForEach((value) => setCore(core, value)),
+      ),
+      core.scope,
+      { startImmediately: true },
+    );
+    return ref;
+  });
+}
+
+/**
+ * Creates a `RefSubject` from an `Option` value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromOption(Option.some(42))
+ *   const value = yield* ref
+ *   console.log(Option.isSome(value)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function fromOption<A>(
+  option: Option.Option<A>,
+  options?: RefSubjectOptions<Option.Option<A>>,
+): Effect.Effect<RefSubject<Option.Option<A>>, never, Scope.Scope> {
+  return make(option, options);
+}
+
+/**
+ * Creates a `RefSubject` from a nullable value (null/undefined become `Option.none()`).
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromNullable("hello")
+ *   const value = yield* ref
+ *   console.log(Option.isSome(value)) // true
+ *
+ *   const empty = yield* RefSubject.fromNullable(null)
+ *   const none = yield* empty
+ *   console.log(Option.isNone(none)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+function optionFromNullable<A>(value: A | null | undefined): Option.Option<NonNullable<A>> {
+  return value === null || value === undefined
+    ? Option.none()
+    : Option.some(value as NonNullable<A>);
+}
+
+export function fromNullable<A>(
+  value: A | null | undefined,
+  options?: RefSubjectOptions<Option.Option<NonNullable<A>>>,
+): Effect.Effect<RefSubject<Option.Option<NonNullable<A>>>, never, Scope.Scope> {
+  return make(optionFromNullable(value), options);
+}
+
+function redirectCause<A, E, R>(core: RefSubjectCore<A, E, R, R | Scope.Scope>) {
+  return Stream.catchCause((cause: Cause.Cause<E>) =>
+    Stream.unwrap(Effect.as(onFailureCore(core, cause), Stream.empty)),
+  );
+}
+
+function makeCore<A, E, R>(
+  initial: Effect.Effect<A, E, R>,
+  options?: RefSubjectOptions<A>,
+  deferredRef?: DeferredRef.DeferredRef<E, A>,
+) {
+  return Effect.gen(function* () {
+    const services = yield* Effect.services<R | Scope.Scope>();
+    const scope = yield* Scope.fork(ServiceMap.get(services, Scope.Scope));
+    const id = yield* Effect.withFiber((fiber) => Effect.succeed(fiber.id));
+    const subject = new Subject.HoldSubjectImpl<A, E>();
+    const core = new RefSubjectCore(
+      initial,
+      subject,
+      services,
+      scope,
+      deferredRef ??
+        DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? equals), subject.lastValue),
+      Semaphore.makeUnsafe(1),
+    );
+    yield* Scope.addFinalizer(scope, core.subject.interrupt);
+    return core;
+  });
+}
+
+function makeDeferredCore<A, E = never, R = never>(options?: RefSubjectOptions<A>) {
+  return Effect.gen(function* () {
+    const deferredRef = yield* DeferredRef.make<E, A>(getExitEquivalence(options?.eq ?? equals));
+    return yield* makeCore<A, E, R>(deferredRef.asEffect(), options, deferredRef);
+  });
+}
+
+function getOrInitializeCore<A, E, R, R2>(
+  core: RefSubjectCore<A, E, R, R2>,
+  lockInitialize: boolean,
+): Effect.Effect<A, E, Exclude<R, R2>> {
+  return Effect.suspend(() => {
+    if (core._fiber === undefined && Option.isNone(MutableRef.get(core.deferredRef.current))) {
+      return initializeCoreAndTap(core, lockInitialize);
+    } else {
+      return core.deferredRef.asEffect();
+    }
+  });
+}
+
+function initializeCoreEffect<A, E, R, R2>(
+  core: RefSubjectCore<A, E, R, R2>,
+  lock: boolean,
+): Effect.Effect<Fiber.Fiber<A, E>, never, Exclude<R, R2>> {
+  const initialize = Effect.onExit(Effect.provide(core.initial, core.services), (exit) =>
+    Effect.sync(() => {
+      core._fiber = undefined;
+      core.deferredRef.done(exit);
+    }),
+  );
+
+  return Effect.flatMap(
+    Effect.forkIn(lock ? core.semaphore.withPermits(1)(initialize) : initialize, core.scope),
+    (fiber) => Effect.sync(() => (core._fiber = fiber)),
+  );
+}
+
+function initializeCoreAndTap<A, E, R, R2>(
+  core: RefSubjectCore<A, E, R, R2>,
+  lock: boolean,
+): Effect.Effect<A, E, Exclude<R, R2>> {
+  return Effect.flatMapEager(initializeCoreEffect(core, lock), () =>
+    tapEventCore(core, core.deferredRef.asEffect()),
+  );
+}
+
+function setCore<A, E, R, R2>(
+  core: RefSubjectCore<A, E, R, R2>,
+  a: A,
+): Effect.Effect<A, never, Exclude<R, R2>> {
+  return Effect.suspend(() => {
+    const exit = Exit.succeed(a);
+
+    if (core.deferredRef.done(exit)) {
+      // If the value changed, send an event
+      return Effect.as(sendEvent(core, exit), a);
+    } else {
+      // Otherwise, just return the current value
+      return Effect.succeed(a);
+    }
+  });
+}
+
+function onFailureCore<A, E, R, R2>(core: RefSubjectCore<A, E, R, R2>, cause: Cause.Cause<E>) {
+  const exit = Exit.failCause(cause);
+
+  return Effect.suspend(() => {
+    if (core.deferredRef.done(exit)) {
+      return sendEvent(core, exit);
+    } else {
+      return Effect.void;
+    }
+  });
+}
+
+function interruptCore<A, E, R, R2>(
+  core: RefSubjectCore<A, E, R, R2>,
+): Effect.Effect<void, never, R> {
+  return Effect.withFiber((fiber) => {
+    core.deferredRef.reset();
+
+    const closeScope = Scope.close(core.scope, Exit.interrupt(fiber.id));
+    const interruptFiber = core._fiber ? Fiber.interrupt(core._fiber) : Effect.void;
+    const interruptSubject = core.subject.interrupt;
+
+    return Effect.all([closeScope, interruptFiber, interruptSubject], { discard: true });
+  });
+}
+
+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 = MutableRef.get(core.deferredRef.current);
+    core.deferredRef.reset();
+
+    if (Option.isNone(current)) {
+      return Effect.succeed(Option.none());
+    }
+
+    return core.subject.subscriberCount.pipe(
+      Effect.flatMap((count: number) =>
+        count > 0 && !core._fiber ? initializeCoreEffect(core, false) : Effect.void,
+      ),
+      Effect.flatMap(() => Effect.asSome(current.value)),
+    );
+  });
+}
+
+function tapEventCore<A, E, R, R2, R3>(
+  core: RefSubjectCore<A, E, R, R2>,
+  effect: Effect.Effect<A, E, R3>,
+) {
+  return effect.pipe(Effect.onExit((exit) => sendEvent(core, exit)));
+}
+
+function sendEvent<A, E, R, R2>(
+  core: RefSubjectCore<A, E, R, R2>,
+  exit: Exit.Exit<A, E>,
+): Effect.Effect<unknown, never, Exclude<R, R2>> {
+  if (Exit.isSuccess(exit)) {
+    return core.subject.onSuccess(exit.value);
+  } else {
+    return core.subject.onFailure(exit.cause);
+  }
+}
+
+/**
+ * Sets the value of a `RefSubject`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   // Set the value
+ *   yield* RefSubject.set(count, 10)
+ *   const value = yield* count
+ *   console.log(value) // 10
+ *
+ *   // Can also use pipe syntax
+ *   yield* count.pipe(RefSubject.set(20))
+ *   const newValue = yield* count
+ *   console.log(newValue) // 20
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const set: {
+  <A>(value: A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
+  <A, E, R>(ref: RefSubject<A, E, R>, a: A): Effect.Effect<A, E, R>;
+} = dual(2, function set<A, E, R>(ref: RefSubject<A, E, R>, a: A): Effect.Effect<A, E, R> {
+  return ref.updates((ref) => ref.set(a));
+});
+
+/**
+ * Resets a `RefSubject` to its initial value, returning the previous value if it existed.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   yield* RefSubject.set(count, 5)
+ *   const before = yield* count
+ *   console.log(before) // 5
+ *
+ *   // Reset to initial value
+ *   const previous = yield* RefSubject.reset(count)
+ *   console.log(Option.isSome(previous)) // true
+ *   console.log(previous.value) // 5
+ *
+ *   const after = yield* count
+ *   console.log(after) // 0
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function reset<A, E, R>(ref: RefSubject<A, E, R>): Effect.Effect<Option.Option<A>, E, R> {
+  return ref.updates((ref) => ref.delete);
+}
+
+export {
+  /**
+   * Deletes the current value of a `RefSubject`, resetting it to its initial state.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Option } from "effect"
+   * import * as RefSubject from "@typed/fx/RefSubject"
+   *
+   * const program = Effect.gen(function* () {
+   *   const ref = yield* RefSubject.make(10)
+   *   yield* RefSubject.set(ref, 20)
+   *
+   *   // Delete the current value
+   *   const deleted = yield* RefSubject.delete(ref)
+   *   console.log(Option.isSome(deleted)) // true
+   *   console.log(deleted.value) // 20
+   *
+   *   // Value is reset to initial
+   *   const current = yield* ref
+   *   console.log(current) // 10
+   * })
+   * ```
+   *
+   * @since 1.20.0
+   * @category combinators
+   */
+  reset as delete,
+};
+
+/**
+ * Updates a `RefSubject` using an `Effect`ful function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Update with an async operation
+ *   yield* RefSubject.updateEffect(count, (value) =>
+ *     Effect.succeed(value * 2)
+ *   )
+ *
+ *   const result = yield* count
+ *   console.log(result) // 10
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const updateEffect: {
+  <A, E2, R2>(
+    f: (value: A) => Effect.Effect<A, E2, R2>,
+  ): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(
+    ref: RefSubject<A, E, R>,
+    f: (value: A) => Effect.Effect<A, E2, R2>,
+  ): Effect.Effect<A, E | E2, R | R2>;
+} = dual(2, function updateEffect<
+  A,
+  E,
+  R,
+  E2,
+  R2,
+>(ref: RefSubject<A, E, R>, f: (value: A) => Effect.Effect<A, E2, R2>) {
+  return ref.updates((ref) => Effect.flatMap(Effect.flatMap(ref.get, f), ref.set));
+});
+
+/**
+ * Updates a `RefSubject` using a pure function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Increment by 1
+ *   yield* RefSubject.update(count, (n) => n + 1)
+ *   const value = yield* count
+ *   console.log(value) // 6
+ *
+ *   // Can also use pipe syntax
+ *   yield* count.pipe(RefSubject.update((n) => n * 2))
+ *   const doubled = yield* count
+ *   console.log(doubled) // 12
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const update: {
+  <A>(f: (value: A) => A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
+  <A, E, R>(ref: RefSubject<A, E, R>, f: (value: A) => A): Effect.Effect<A, E, R>;
+} = dual(2, function update<A, E, R>(ref: RefSubject<A, E, R>, f: (value: A) => A) {
+  return updateEffect(ref, (value) => Effect.succeed(f(value)));
+});
+
+/**
+ * Modifies a `RefSubject` using an `Effect`ful function that returns both a result and a new value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Get the old value and set a new one, returning the old value
+ *   const oldValue = yield* RefSubject.modifyEffect(count, (value) =>
+ *     Effect.succeed([value, value + 10] as const)
+ *   )
+ *
+ *   console.log(oldValue) // 5
+ *   const newValue = yield* count
+ *   console.log(newValue) // 15
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const modifyEffect: {
+  <A, B, E2, R2>(
+    f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>,
+  ): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<B, E | E2, R | R2>;
+  <A, E, R, B, E2, R2>(
+    ref: RefSubject<A, E, R>,
+    f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>,
+  ): Effect.Effect<B, E | E2, R | R2>;
+} = dual(2, function modifyEffect<
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+>(ref: RefSubject<A, E, R>, f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>) {
+  return ref.updates((ref) =>
+    Effect.flatMap(ref.get, (value) =>
+      Effect.flatMap(f(value), ([b, a]) => Effect.flatMap(ref.set(a), () => Effect.succeed(b))),
+    ),
+  );
+});
+
+/**
+ * Modifies a `RefSubject` using a pure function that returns both a result and a new value.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Get the old value and increment, returning the old value
+ *   const oldValue = yield* RefSubject.modify(count, (value) => [value, value + 1] as const)
+ *
+ *   console.log(oldValue) // 5
+ *   const newValue = yield* count
+ *   console.log(newValue) // 6
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const modify: {
+  <A, B>(
+    f: (value: A) => readonly [B, A],
+  ): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<B, E, R>;
+  <A, E, R, B>(ref: RefSubject<A, E, R>, f: (value: A) => readonly [B, A]): Effect.Effect<B, E, R>;
+} = dual(2, function modify<
+  A,
+  E,
+  R,
+  B,
+>(ref: RefSubject<A, E, R>, f: (value: A) => readonly [B, A]) {
+  return modifyEffect(ref, (value) => Effect.succeed(f(value)));
+});
+
+/**
+ * Checks if a value is a `RefSubject`.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.make(42)
+ *   const isRef = RefSubject.isRefSubject(ref)
+ *   console.log(isRef) // true
+ *
+ *   const notRef = { value: 42 }
+ *   const isNotRef = RefSubject.isRefSubject(notRef)
+ *   console.log(isNotRef) // false
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category guards
+ */
+export function isRefSubject(value: any): value is RefSubject<any, any, any> {
+  return value && typeof value === "object" && value[RefSubjectTypeId] === RefSubjectTypeId;
+}
+
+const isRefSubjectDataFirst = (args: IArguments) => isRefSubject(args[0]);
+
+/**
+ * Runs an effect that can modify a `RefSubject` transactionally, with optional interrupt handling.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const balance = yield* RefSubject.make(100)
+ *
+ *   // Transfer money atomically with interrupt handling
+ *   yield* RefSubject.runUpdates(
+ *     balance,
+ *     (ref) =>
+ *       Effect.gen(function* () {
+ *         const current = yield* ref.get
+ *         if (current >= 50) {
+ *           yield* ref.set(current - 50)
+ *           return "Transfer successful"
+ *         }
+ *         return "Insufficient funds"
+ *       }),
+ *     {
+ *       onInterrupt: (value) => Effect.sync(() => console.log(`Interrupted at balance: ${value}`)),
+ *       value: "initial"
+ *     }
+ *   )
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const runUpdates: {
+  <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(
+    f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>,
+    options?: {
+      readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+      readonly value?: "initial" | "current";
+    },
+  ): (ref: RefSubject<A, E, R>) => Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
+
+  <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(
+    ref: RefSubject<A, E, R>,
+    f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>,
+    options?:
+      | {
+          readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+          readonly value?: "initial" | "current";
+        }
+      | undefined,
+  ): Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
+} = dual(
+  isRefSubjectDataFirst,
+  function runUpdates<A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(
+    ref: RefSubject<A, E, R>,
+    f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>,
+    options?: {
+      readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+      readonly value?: "initial" | "current";
+    },
+  ) {
+    if (options === undefined) {
+      return ref.updates(f);
+    } else if (options.value === "initial") {
+      return ref.updates((ref) =>
+        Effect.flatMap(ref.get, (initial) =>
+          f(ref).pipe(Effect.onInterrupt(() => options.onInterrupt(initial))),
+        ),
+      );
+    } else {
+      return ref.updates((ref) =>
+        f(ref).pipe(Effect.onInterrupt(() => Effect.flatMap(ref.get, options.onInterrupt))),
+      );
+    }
+  },
+);
+
+/**
+ * Increments a numeric `RefSubject` by 1.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(0)
+ *
+ *   yield* RefSubject.increment(count)
+ *   const value = yield* count
+ *   console.log(value) // 1
+ *
+ *   yield* RefSubject.increment(count)
+ *   const newValue = yield* count
+ *   console.log(newValue) // 2
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function increment<E, R>(ref: RefSubject<number, E, R>): Effect.Effect<number, E, R> {
+  return update(ref, (value) => value + 1);
+}
+
+/**
+ * Decrements a numeric `RefSubject` by 1.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(10)
+ *
+ *   yield* RefSubject.decrement(count)
+ *   const value = yield* count
+ *   console.log(value) // 9
+ *
+ *   yield* RefSubject.decrement(count)
+ *   const newValue = yield* count
+ *   console.log(newValue) // 8
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function decrement<E, R>(ref: RefSubject<number, E, R>): Effect.Effect<number, E, R> {
+  return update(ref, (value) => value - 1);
+}
+
+const Variance: Fx.Variance<any, any, any> = {
+  _A: identity,
+  _E: identity,
+  _R: identity,
+};
+
+export function Service<Self, A, E = never>() {
+  return <const Id extends string>(id: Id): RefSubject.Class<Self, Id, A, E> => {
+    const service = ServiceMap.Service<Self, RefSubject<A, E>>(id);
+
+    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+    return class RefSubjectService {
+      /// Service
+
+      static readonly id = id;
+      static readonly service = service;
+
+      static readonly layer = <E2, R2>(
+        make: Effect.Effect<RefSubject<A, E>, E2, R2 | Scope.Scope>,
+      ) => Layer.effect(service, make);
+
+      static readonly make = <R = never>(
+        value: A | Effect.Effect<A, E, R> | Fx<A, E, R>,
+        options?: RefSubjectOptions<A> & Partial<Bounds>,
+      ): Layer.Layer<Self, never, R> => {
+        const bounds = getDefaultBounds(options);
+        return make(value, options).pipe(
+          Effect.map((ref) => (bounds ? slice(ref, bounds.skip, bounds.take) : ref)),
+          this.layer,
+        );
+      };
+
+      // Fx
+      static readonly [FxTypeId]: Fx.Variance<A, E, Self> = Variance;
+      static readonly run = <RSink>(sink: Sink.Sink<A, E, RSink>) =>
+        Effect.flatMap(service.asEffect(), (ref) => ref.run(sink));
+
+      // Sink
+      static readonly onSuccess = (value: A) =>
+        Effect.flatMap(service.asEffect(), (ref) => ref.onSuccess(value));
+      static readonly onFailure = (cause: Cause.Cause<E>) =>
+        Effect.flatMap(service.asEffect(), (ref) => ref.onFailure(cause));
+
+      /// Computed
+      static readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId;
+      static readonly version = Effect.flatMap(service.asEffect(), (ref) => ref.version);
+
+      // Subject
+      static readonly subscriberCount = Effect.flatMap(
+        service.asEffect(),
+        (ref) => ref.subscriberCount,
+      );
+      static readonly interrupt = Effect.flatMap(service.asEffect(), (ref) => ref.interrupt);
+
+      // RefSubject
+      static readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId;
+      static readonly updates = <B, E2, R2>(
+        f: (ref: GetSetDelete<A, E, never>) => Effect.Effect<B, E2, R2>,
+      ) => Effect.flatMap(service.asEffect(), (ref) => ref.updates(f));
+
+      // Yieldable
+      static readonly asEffect = () => Effect.flatMap(service.asEffect(), Effect.fromYieldable);
+      static readonly [Symbol.iterator] = function* () {
+        const ref = yield* service;
+        return yield* ref;
+      };
+      static readonly pipe: RefSubject.Service<Self, Id, A, E>["pipe"] = function pipe(
+        this: RefSubject.Service<Self, Id, A, E>,
+      ) {
+        return pipeArguments(this, arguments);
+      };
+
+      constructor() {
+        return RefSubjectService;
+      }
+    } as unknown as RefSubject.Class<Self, Id, A, E>;
+  };
+}
+
+function getDefaultBounds(options?: Partial<Bounds>): Bounds | undefined {
+  if (options === undefined || (options.skip === undefined && options.take === undefined)) {
+    return { skip: 0, take: Infinity };
+  }
+
+  return { skip: options.skip ?? 0, take: options.take ?? Infinity };
+}
+
+/**
+ * Extract all values from an object using a Proxy.
+ * Allows accessing nested properties of a `Computed` or `Filtered` object/array as individual computed values.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const user = yield* RefSubject.make({ name: "Alice", age: 30 })
+ *
+ *   // Create a proxy to access nested properties
+ *   const proxied = RefSubject.proxy(user)
+ *
+ *   // Access individual properties as Computed values
+ *   const name = yield* proxied.name
+ *   console.log(name) // "Alice"
+ *
+ *   const age = yield* proxied.age
+ *   console.log(age) // 30
+ *
+ *   // Update the source
+ *   yield* RefSubject.set(user, { name: "Bob", age: 25 })
+ *
+ *   // Proxied values automatically update
+ *   const newName = yield* proxied.name
+ *   console.log(newName) // "Bob"
+ * })
+ * ```
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+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]));
+    },
+  });
+};
+
+export type Services<T> =
+  T extends RefSubject<infer _A, infer _E, infer R>
+    ? R
+    : T extends Computed<infer _A, infer _E, infer R>
+      ? R
+      : T extends Filtered<infer _A, infer _E, infer R>
+        ? R
+        : never;
+
+export type Error<T> =
+  T extends RefSubject<infer _A, infer E, infer _R>
+    ? E
+    : T extends Computed<infer _A, infer E, infer _R>
+      ? E
+      : T extends Filtered<infer _A, infer E, infer _R>
+        ? E
+        : never;
+
+export type Success<T> =
+  T extends RefSubject<infer A, infer _E, infer _R>
+    ? A
+    : T extends Computed<infer A, infer _E, infer _R>
+      ? A
+      : T extends Filtered<infer A, infer _E, infer _R>
+        ? A
+        : never;
+
+export type Identifier<T> =
+  T extends RefSubject.Service<infer R, infer _Id, infer _A, infer _E> ? R : never;
+
+/**
+ * Transforms a `RefSubject`, `Computed`, or `Filtered` using an `Effect`ful function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Transform with an async operation
+ *   const doubled = RefSubject.mapEffect(count, (n) =>
+ *     Effect.succeed(n * 2)
+ *   )
+ *
+ *   const value = yield* doubled
+ *   console.log(value) // 10
+ *
+ *   // Update source
+ *   yield* RefSubject.set(count, 7)
+ *
+ *   // Computed automatically updates
+ *   const newValue = yield* doubled
+ *   console.log(newValue) // 14
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <T extends RefSubject.Any | Computed.Any | Filtered.Any, B, E2, R2>(
+    f: (a: Success<T>) => Effect.Effect<B, E2, R2>,
+  ): (
+    ref: T,
+  ) => T extends Filtered.Any
+    ? Filtered<B, Error<T> | E2, Services<T> | R2>
+    : Computed<B, Error<T> | E2, Services<T> | R2>;
+
+  <A, E, R, B, E2, R2>(
+    ref: RefSubject<A, E, R> | Computed<A, E, R>,
+    f: (a: A) => Effect.Effect<B, E2, R2>,
+  ): Computed<B, E | E2, R | R2>;
+
+  <A, E, R, B, E2, R2>(
+    ref: Filtered<A, E, R>,
+    f: (a: A) => Effect.Effect<B, E2, R2>,
+  ): Filtered<B, E | E2, R | R2>;
+
+  <R0, E0, A, E, R, E2, R2, C, E3, R3>(
+    versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+    f: (a: A) => Effect.Effect<C, E3, R3>,
+  ): Computed<C, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
+} = dual(2, function mapEffect<
+  R0,
+  E0,
+  A,
+  E,
+  R,
+  E2,
+  R2,
+  C,
+  E3,
+  R3,
+>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<C, E3, R3>):
+  | Computed<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3>
+  | Filtered<C, E0 | E | E2 | E3, R0 | Exclude<R, Scope.Scope> | R2 | R3> {
+  return FilteredTypeId in versioned
+    ? new FilteredImpl(versioned, (a) => Effect.asSome(f(a)))
+    : new ComputedImpl(versioned, f);
+});
+
+/**
+ * Transforms a `RefSubject`, `Computed`, or `Filtered` using a pure function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Create a computed that doubles the count
+ *   const doubled = RefSubject.map(count, (n) => n * 2)
+ *
+ *   const value = yield* doubled
+ *   console.log(value) // 10
+ *
+ *   // Update source
+ *   yield* RefSubject.set(count, 7)
+ *
+ *   // Computed automatically updates
+ *   const newValue = yield* doubled
+ *   console.log(newValue) // 14
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const map: {
+  <T extends RefSubject.Any | Computed.Any | Filtered.Any, B>(
+    f: (a: Success<T>) => B,
+  ): (
+    ref: T,
+  ) => T extends Filtered.Any
+    ? Filtered<B, Error<T>, Services<T>>
+    : Computed<B, Error<T>, Services<T>>;
+
+  <A, E, R, B>(ref: RefSubject<A, E, R> | Computed<A, E, R>, f: (a: A) => B): Computed<B, E, R>;
+  <A, E, R, B>(filtered: Filtered<A, E, R>, f: (a: A) => B): Filtered<B, E, R>;
+
+  <R0, E0, A, E, R, B, E2, R2>(
+    versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+    f: (a: A) => B,
+  ):
+    | Computed<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>
+    | Filtered<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>;
+} = dual(2, function map<
+  R0,
+  E0,
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => B):
+  | Computed<B, E0 | E | E2, R0 | Exclude<R, Scope.Scope> | R2>
+  | Filtered<B, E0 | E | E2, R0 | Exclude<R, Scope.Scope> | R2> {
+  return mapEffect(versioned, (a) => Effect.succeed(f(a)));
+});
+
+/**
+ * Filters and transforms a `RefSubject`, `Computed`, or `Filtered` using an `Effect`ful function that returns an `Option`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const numbers = yield* RefSubject.make([1, 2, 3, 4, 5])
+ *
+ *   // Find the first even number
+ *   const firstEven = RefSubject.filterMapEffect(numbers, (arr) =>
+ *     Effect.succeed(Option.fromNullable(arr.find((n) => n % 2 === 0)))
+ *   )
+ *
+ *   const value = yield* firstEven
+ *   console.log(value) // 2
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const filterMapEffect: {
+  <A, B, E2, R2>(
+    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
+  ): {
+    <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Filtered<B, E | E2, R | R2>;
+    <E, R>(ref: Filtered<A, E, R>): Filtered<B, E | E2, R | R2>;
+    <R0, E0, B, E, R, E2, R2>(
+      versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+      f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
+    ): Filtered<B, E0 | E | E2, R0 | R2>;
+  };
+
+  <A, E, R, B, E2, R2>(
+    ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>,
+    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
+  ): Filtered<B, E | E2, R | R2>;
+  <R0, E0, A, E, R, B, E2, R2, R3, E3>(
+    versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+    f: (a: A) => Effect.Effect<Option.Option<B>, E3, R3>,
+  ): Filtered<B, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
+} = dual(2, function filterMapEffect<
+  R0,
+  E0,
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+  R3,
+  E3,
+>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<Option.Option<B>, E3, R3>): Filtered<
+  B,
+  E0 | E | E2 | E3,
+  R0 | Exclude<R, Scope.Scope> | R2 | R3
+> {
+  return new FilteredImpl(versioned, f);
+});
+
+/**
+ * Filters and transforms a `RefSubject`, `Computed`, or `Filtered` using a pure function that returns an `Option`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const numbers = yield* RefSubject.make([1, 2, 3, 4, 5])
+ *
+ *   // Get the first even number
+ *   const firstEven = RefSubject.filterMap(numbers, (arr) =>
+ *     Option.fromNullable(arr.find((n) => n % 2 === 0))
+ *   )
+ *
+ *   const value = yield* firstEven
+ *   console.log(value) // 2
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const filterMap: {
+  <A, B>(
+    f: (a: A) => Option.Option<B>,
+  ): {
+    <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Filtered<B, E, R>;
+    <R0, E0, B, E, R, E2, R2>(
+      versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+      f: (a: A) => Option.Option<B>,
+    ): Filtered<B, E0 | E | E2, R0 | R2>;
+  };
+
+  <R0, E0, A, E, R, B, E2, R2>(
+    versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>,
+    f: (a: A) => Option.Option<B>,
+  ): Filtered<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>;
+
+  <A, E, R, B>(
+    ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>,
+    f: (a: A) => Option.Option<B>,
+  ): Filtered<B, E, R>;
+} = dual(2, function filterMap<
+  R0,
+  E0,
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Option.Option<B>): Filtered<
+  B,
+  E0 | E | E2,
+  R0 | Exclude<R, Scope.Scope> | R2
+> {
+  return new FilteredImpl(versioned, (a) => Effect.succeed(f(a)));
+});
+
+/**
+ * Converts a `Computed` or `Filtered` of `Option<A>` into a `Filtered<A>`, filtering out `None` values.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const maybeValue = yield* RefSubject.make(Option.some(42))
+ *
+ *   // Compact the Option
+ *   const filtered = RefSubject.compact(maybeValue)
+ *
+ *   const value = yield* filtered
+ *   console.log(value) // 42
+ *
+ *   // If the Option becomes None, the Filtered will fail
+ *   yield* RefSubject.set(maybeValue, Option.none())
+ *   // yield* filtered would fail with NoSuchElementError
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const compact: {
+  <A, E, R>(ref: Computed<Option.Option<A>, E, R>): Filtered<A>;
+  <A, E, R>(ref: Filtered<Option.Option<A>, E, R>): Filtered<A>;
+
+  <R0, E0, A, E, R, E2, R2>(
+    versioned: Versioned.Versioned<R0, E0, Option.Option<A>, E, R, Option.Option<A>, E2, R2>,
+  ): Filtered<
+    A,
+    E0 | E | Exclude<E, Cause.NoSuchElementError> | Exclude<E2, Cause.NoSuchElementError>,
+    R0 | R2 | Exclude<R, Scope.Scope>
+  >;
+} = function compact<R0, E0, A, E, R, E2, R2>(
+  versioned: Versioned.Versioned<R0, E0, Option.Option<A>, E, R, Option.Option<A>, E2, R2>,
+): any {
+  return new FilteredImpl(versioned, Effect.succeed);
+};
+
+/**
+ * Returns a `Computed` that yields the value inside the `Option`, or the fallback when `None`.
+ * Works with `Computed<Option<A>>` (e.g. from `fromOption` / `fromNullable`) and with `Filtered<A>`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromOption(Option.some(42))
+ *   const withDefault = RefSubject.getOrElse(ref, () => 0)
+ *   expect(yield* withDefault).toBe(42)
+ *
+ *   const empty = yield* RefSubject.fromNullable(null)
+ *   const fallback = RefSubject.getOrElse(empty, () => 99)
+ *   expect(yield* fallback).toBe(99)
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getOrElse: {
+  <A>(
+    fallback: () => A,
+  ): <E, R>(ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>) => Computed<A, E, R>;
+  <A, E, R>(
+    ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>,
+    fallback: () => A,
+  ): Computed<A, E, R>;
+} = dual(2, function getOrElse<
+  A,
+  E,
+  R,
+>(ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>, fallback: () => A): Computed<A, E, R> {
+  const computed = FilteredTypeId in ref ? (ref as Filtered<A, E, R>).asComputed() : ref;
+  return map(computed, (opt) => Option.getOrElse(opt, fallback));
+});
+
+class RefSubjectSimpleTransform<A, E, R, R2, R3>
+  extends YieldableFx<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 | R2>;
+
+  readonly ref: RefSubject<A, E, R>;
+  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>;
+
+  constructor(
+    ref: RefSubject<A, E, R>,
+    transformFx: (fx: Fx<A, E, Scope.Scope | R>) => Fx<A, E, Scope.Scope | R | R2>,
+    transformEffect: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | R3>,
+  ) {
+    super();
+
+    this.ref = ref;
+    this.transformFx = transformFx;
+    this.transformEffect = transformEffect;
+    this.version = ref.version;
+    this.interrupt = ref.interrupt;
+    this.subscriberCount = ref.subscriberCount;
+
+    this._fx = transformFx(ref);
+  }
+
+  run<R4>(sink: Sink.Sink<A, E, R4>) {
+    return this._fx.run(sink);
+  }
+
+  toEffect(): Effect.Effect<A, E, R | R3> {
+    return this.transformEffect(this.ref.asEffect());
+  }
+
+  updates<E2, R2, C>(
+    run: (ref: GetSetDelete<A, E, R>) => Effect.Effect<C, E2, R2>,
+  ): Effect.Effect<C, E | E2, R | R2> {
+    return this.ref.updates(run);
+  }
+
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, R> {
+    return this.ref.onFailure(cause);
+  }
+
+  onSuccess(value: A): Effect.Effect<unknown, never, R> {
+    return this.ref.onSuccess(value);
+  }
+}
+
+export const slice: {
+  (skip: number, take: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
+  <A, E, R>(ref: RefSubject<A, E, R>, skip: number, take: number): RefSubject<A, E, R>;
+} = dual(3, function slice<
+  A,
+  E,
+  R,
+>(ref: RefSubject<A, E, R>, skip: number, take: number): RefSubject<A, E, R> {
+  return new RefSubjectSimpleTransform(ref, (_) => fxSlice(_, { skip, take }), identity);
+});
+
+class RefSubjectTransform<A, B, E, R>
+  extends YieldableFx<B, E, R | Scope.Scope, B, E, R>
+  implements RefSubject<B, E, R>
+{
+  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<B, E, Scope.Scope | R>;
+
+  readonly ref: RefSubject<A, E, R>;
+  readonly toB: (a: A) => B;
+  readonly toA: (b: B) => A;
+
+  constructor(ref: RefSubject<A, E, R>, toB: (a: A) => B, toA: (b: B) => A) {
+    super();
+
+    this.ref = ref;
+    this.toB = toB;
+    this.toA = toA;
+    this.version = ref.version;
+    this.interrupt = ref.interrupt;
+    this.subscriberCount = ref.subscriberCount;
+
+    this._fx = fxMapEffect(ref, (a) => Effect.succeed(toB(a)));
+  }
+
+  run<R2>(sink: Sink.Sink<B, E, R2>) {
+    return this._fx.run(sink);
+  }
+
+  toEffect(): Effect.Effect<B, E, R> {
+    return Effect.map(this.ref.asEffect(), this.toB);
+  }
+
+  updates<E2, R2, C>(
+    run: (ref: GetSetDelete<B, E, R>) => Effect.Effect<C, E2, R2>,
+  ): Effect.Effect<C, E | E2, R | R2> {
+    return this.ref.updates((innerRef) => {
+      const getSetDelete: GetSetDelete<B, E, R> = {
+        get: Effect.map(innerRef.get, this.toB),
+        set: (b: B) => Effect.map(innerRef.set(this.toA(b)), this.toB),
+        delete: Effect.map(innerRef.delete, Option.map(this.toB)),
+      };
+      return run(getSetDelete);
+    });
+  }
+
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, R> {
+    return this.ref.onFailure(cause);
+  }
+
+  onSuccess(value: B): Effect.Effect<unknown, never, R> {
+    return this.ref.onSuccess(this.toA(value));
+  }
+}
+
+/**
+ * Transforms a `RefSubject` invariantly using bidirectional mapping functions.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const count = yield* RefSubject.make(5)
+ *
+ *   // Transform to string and back
+ *   const countStr = RefSubject.transform(
+ *     count,
+ *     (n) => n.toString(),
+ *     (s) => parseInt(s, 10)
+ *   )
+ *
+ *   const value = yield* countStr
+ *   console.log(value) // "5"
+ *
+ *   // Set using the transformed type
+ *   yield* RefSubject.set(countStr, "10")
+ *
+ *   // Original reflects the change
+ *   const original = yield* count
+ *   console.log(original) // 10
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const transform: {
+  <A, B>(
+    toB: (a: A) => B,
+    toA: (b: B) => A,
+  ): <E, R>(ref: RefSubject<A, E, R>) => RefSubject<B, E, R>;
+  <A, E, R, B>(ref: RefSubject<A, E, R>, toB: (a: A) => B, toA: (b: B) => A): RefSubject<B, E, R>;
+} = dual(3, function transform<
+  A,
+  E,
+  R,
+  B,
+>(ref: RefSubject<A, E, R>, toB: (a: A) => B, toA: (b: B) => A): RefSubject<B, E, R> {
+  return new RefSubjectTransform(ref, toB, toA);
+});
+
+type RefKind = "r" | "c" | "f";
+
+const join = (a: RefKind, b: RefKind) => {
+  if (a === "r") return b;
+  if (b === "r") return a;
+  if (a === "f") return a;
+  if (b === "f") return b;
+  return "c";
+};
+
+function getRefKind<
+  const Refs extends ReadonlyArray<
+    RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>
+  >,
+>(refs: Refs): RefKind {
+  let kind: RefKind = "r";
+
+  for (const ref of refs) {
+    if (FilteredTypeId in ref) {
+      kind = "f";
+      break;
+    } else if (!(RefSubjectTypeId in ref)) {
+      kind = join(kind, "c");
+    }
+  }
+
+  return kind;
+}
+
+type StructFrom<
+  Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>,
+> = {
+  c: [ComputedStructFrom<Refs>] extends [Computed<infer A, infer E, infer R>]
+    ? Computed<A, E, R>
+    : never;
+  f: [FilteredStructFrom<Refs>] extends [Filtered<infer A, infer E, infer R>]
+    ? Filtered<A, E, R>
+    : never;
+  r: [RefSubjectStructFrom<Refs>] extends [RefSubject<infer A, infer E, infer R>]
+    ? RefSubject<A, E, R>
+    : never;
+}[GetStructKind<Refs>];
+
+type GetStructKind<
+  Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>,
+> = MergeKinds<
+  UnionToTuple<
+    {
+      [K in keyof Refs]: MatchKind<Refs[K]>;
+    }[keyof Refs]
+  >
+>;
+
+type Ref = RefSubject.Any | Computed.Any | Filtered.Any;
+
+type MatchKind<T extends Ref> = [T] extends [Filtered.Any]
+  ? "f"
+  : [T] extends [RefSubject.Any]
+    ? "r"
+    : "c";
+
+type MergeKind<A extends RefKind, B extends RefKind> = A extends "f"
+  ? A
+  : B extends "f"
+    ? B
+    : A extends "r"
+      ? B
+      : B extends "r"
+        ? A
+        : "c";
+
+type MergeKinds<Kinds extends ReadonlyArray<any>> = Kinds extends readonly [
+  infer Head extends RefKind,
+  ...infer Tail extends ReadonlyArray<RefKind>,
+]
+  ? MergeKind<Head, MergeKinds<Tail>>
+  : "r";
+
+type FilteredStructFrom<
+  Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>,
+> = Filtered<
+  {
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+  },
+  FxError<Refs[keyof Refs]>,
+  Effect.Services<Refs[keyof Refs]>
+>;
+
+type ComputedStructFrom<
+  Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>,
+> = Computed<
+  {
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+  },
+  Effect.Error<Refs[keyof Refs]>,
+  Effect.Services<Refs[keyof Refs]>
+>;
+
+type RefSubjectStructFrom<
+  Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>,
+> = RefSubject<
+  {
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+  },
+  Effect.Error<Refs[keyof Refs]>,
+  Effect.Services<Refs[keyof Refs]>
+>;
+
+type TupleFrom<
+  Refs extends ReadonlyArray<
+    RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>
+  >,
+> = {
+  c: [ComputedTupleFrom<Refs>] extends [Computed<infer A, infer E, infer R>]
+    ? Computed<A, E, R>
+    : never;
+  f: [FilteredTupleFrom<Refs>] extends [Filtered<infer A, infer E, infer R>]
+    ? Filtered<A, E, R>
+    : never;
+  r: [RefSubjectTupleFrom<Refs>] extends [RefSubject<infer A, infer E, infer R>]
+    ? RefSubject<A, E, R>
+    : never;
+}[GetTupleKind<Refs>];
+
+type GetTupleKind<
+  Refs extends ReadonlyArray<Ref>,
+  Kind extends RefKind = "r",
+> = Refs extends readonly [infer Head extends Ref, ...infer Tail extends ReadonlyArray<Ref>]
+  ? GetTupleKind<Tail, MergeKind<Kind, MatchKind<Head>>>
+  : Kind;
+
+type FilteredTupleFrom<
+  Refs extends ReadonlyArray<
+    RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>
+  >,
+> = Filtered<
+  {
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+  },
+  FxError<Refs[number]>,
+  Effect.Services<Refs[number]>
+>;
+
+type ComputedTupleFrom<
+  Refs extends ReadonlyArray<
+    RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>
+  >,
+> = Computed<
+  {
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+  },
+  Effect.Error<Refs[number]>,
+  Effect.Services<Refs[number]>
+>;
+
+type RefSubjectTupleFrom<
+  Refs extends ReadonlyArray<
+    RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>
+  >,
+> = RefSubject<
+  {
+    readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+  },
+  Effect.Error<Refs[number]>,
+  Effect.Services<Refs[number]>
+>;
+
+/**
+ * Combines multiple `RefSubject`, `Computed`, or `Filtered` instances into a single struct.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const firstName = yield* RefSubject.make("Alice")
+ *   const lastName = yield* RefSubject.make("Smith")
+ *   const age = yield* RefSubject.make(30)
+ *
+ *   // Combine into a struct
+ *   const person = RefSubject.struct({
+ *     firstName,
+ *     lastName,
+ *     age
+ *   })
+ *
+ *   const fullPerson = yield* person
+ *   console.log(fullPerson) // { firstName: "Alice", lastName: "Smith", age: 30 }
+ *
+ *   // Update one field
+ *   yield* RefSubject.set(firstName, "Bob")
+ *
+ *   // Struct automatically updates
+ *   const updated = yield* person
+ *   console.log(updated.firstName) // "Bob"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function struct<
+  const Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>,
+>(refs: Refs): StructFrom<Refs> {
+  const kind = getRefKind(Object.values(refs));
+  switch (kind) {
+    case "r":
+      return makeStructRef(refs as any) as StructFrom<Refs>;
+    case "c":
+      return makeStructComputed(refs as any) as StructFrom<Refs>;
+    case "f":
+      return makeStructFiltered(refs as any) as any as StructFrom<Refs>;
+  }
+}
+/**
+ * Combines multiple `RefSubject`, `Computed`, or `Filtered` instances into a single tuple.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const x = yield* RefSubject.make(10)
+ *   const y = yield* RefSubject.make(20)
+ *   const z = yield* RefSubject.make(30)
+ *
+ *   // Combine into a tuple
+ *   const point = RefSubject.tuple([x, y, z])
+ *
+ *   const coords = yield* point
+ *   console.log(coords) // [10, 20, 30]
+ *
+ *   // Update one value
+ *   yield* RefSubject.set(x, 15)
+ *
+ *   // Tuple automatically updates
+ *   const updated = yield* point
+ *   console.log(updated) // [15, 20, 30]
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function tuple<const Refs extends ReadonlyArray<Ref>>(refs: Refs): TupleFrom<Refs> {
+  const kind = getRefKind(refs);
+  switch (kind) {
+    case "r":
+      return makeTupleRef(refs as any) as TupleFrom<Refs>;
+    case "c":
+      return makeTupleComputed(refs as any) as TupleFrom<Refs>;
+    case "f":
+      return makeTupleFiltered(refs as any) as any as TupleFrom<Refs>;
+  }
+}
+
+function makeTupleRef<const Refs extends ReadonlyArray<RefSubject<any, any, any>>>(
+  refs: Refs,
+): RefSubjectTupleFrom<Refs> {
+  return new RefSubjectTuple(refs);
+}
+
+const UNBOUNDED = { concurrency: "unbounded" } as const;
+
+class RefSubjectTuple<const Refs extends ReadonlyArray<RefSubject<any, any, any>>>
+  extends YieldableFx<
+    {
+      readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+    },
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>,
+    {
+      readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+    },
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>
+  >
+  implements RefSubjectTupleFrom<Refs>
+{
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId;
+  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId;
+
+  readonly version: Effect.Effect<
+    number,
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>
+  >;
+  readonly interrupt: Effect.Effect<void, never, Effect.Services<Refs[number]>>;
+  readonly subscriberCount: Effect.Effect<number, never, Effect.Services<Refs[number]>>;
+
+  private versioned: Versioned.Versioned<
+    Effect.Services<Refs[number]>,
+    Effect.Error<Refs[number]>,
+    { readonly [K in keyof Refs]: Effect.Success<Refs[K]> },
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>,
+    { readonly [K in keyof Refs]: Effect.Success<Refs[K]> },
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>
+  >;
+
+  private getSetDelete: GetSetDelete<
+    { readonly [K in keyof Refs]: Effect.Success<Refs[K]> },
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>
+  >;
+
+  readonly refs: Refs;
+
+  constructor(refs: Refs) {
+    super();
+
+    this.refs = refs;
+    this.versioned = Versioned.hold(Versioned.tuple(refs)) as any;
+    this.version = this.versioned.version;
+    this.interrupt = Effect.all(
+      refs.map((r) => r.interrupt),
+      UNBOUNDED,
+    );
+    this.subscriberCount = Effect.map(
+      Effect.all(
+        refs.map((r) => r.subscriberCount),
+        UNBOUNDED,
+      ),
+      Array.reduce(0, sum),
+    );
+
+    this.getSetDelete = {
+      get: this.versioned.asEffect(),
+      set: (a) =>
+        Effect.all(
+          refs.map((r, i) => set(r, a[i])),
+          UNBOUNDED,
+        ) as any,
+      delete: Effect.map(
+        Effect.all(
+          refs.map((r) => reset(r)),
+          UNBOUNDED,
+        ),
+        Option.all,
+      ) as any,
+    };
+
+    this.updates = this.updates.bind(this);
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  run<R2 = never>(
+    sink: Sink.Sink<
+      {
+        readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+      },
+      Effect.Error<Refs[number]>,
+      R2
+    >,
+  ): Effect.Effect<unknown, never, Effect.Services<Refs[number]> | R2> {
+    return this.versioned.run(sink);
+  }
+
+  override toEffect(): Effect.Effect<
+    { readonly [K in keyof Refs]: Effect.Success<Refs[K]> },
+    Effect.Error<Refs[number]>,
+    Effect.Services<Refs[number]>
+  > {
+    return this.versioned.asEffect();
+  }
+
+  updates<E2, R2, C>(
+    run: (
+      ref: GetSetDelete<
+        {
+          readonly [K in keyof Refs]: Effect.Success<Refs[K]>;
+        },
+        Effect.Error<Refs[number]>,
+        Effect.Services<Refs[number]>
+      >,
+    ) => Effect.Effect<C, E2, R2>,
+  ) {
+    return run(this.getSetDelete);
+  }
+
+  onFailure(
+    cause: Cause.Cause<Effect.Error<Refs[number]>>,
+  ): Effect.Effect<unknown, never, Effect.Services<Refs[number]>> {
+    return Effect.all(this.refs.map((ref) => ref.onFailure(cause)));
+  }
+
+  onSuccess(value: { readonly [K in keyof Refs]: Effect.Success<Refs[K]> }): Effect.Effect<
+    unknown,
+    never,
+    Effect.Services<Refs[number]>
+  > {
+    return Effect.catchCause(this.getSetDelete.set(value), (c) => this.onFailure(c));
+  }
+}
+
+function makeTupleComputed<const Refs extends ReadonlyArray<Computed<any, any, any>>>(
+  refs: Refs,
+): ComputedTupleFrom<Refs> {
+  return new ComputedImpl(Versioned.tuple(refs) as any, Effect.succeed) as any;
+}
+
+function makeTupleFiltered<
+  const Refs extends ReadonlyArray<Computed<any, any, any> | Filtered<any, any, any>>,
+>(refs: Refs): FilteredTupleFrom<Refs> {
+  return new FilteredImpl(Versioned.tuple(refs) as any, Effect.succeedSome) as any;
+}
+
+function makeStructRef<const Refs extends Readonly<Record<string, RefSubject.Any>>>(
+  refs: Refs,
+): RefSubjectStructFrom<Refs> {
+  return new RefSubjectStruct(refs) as any;
+}
+
+class RefSubjectStruct<const Refs extends Readonly<Record<string, RefSubject.Any>>>
+  extends YieldableFx<
+    {
+      readonly [K in keyof Refs]: Success<Refs[K]>;
+    },
+    Error<Refs[keyof Refs]>,
+    Services<Refs[keyof Refs]> | Scope.Scope,
+    {
+      readonly [K in keyof Refs]: Success<Refs[K]>;
+    },
+    Error<Refs[keyof Refs]>,
+    Services<Refs[keyof Refs]>
+  >
+  implements
+    RefSubject<
+      {
+        readonly [K in keyof Refs]: Success<Refs[K]>;
+      },
+      Error<Refs[keyof Refs]>,
+      Services<Refs[keyof Refs]>
+    >
+{
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId;
+  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId;
+
+  readonly version: Effect.Effect<number, Error<Refs[keyof Refs]>, Services<Refs[keyof Refs]>>;
+  readonly interrupt: Effect.Effect<void, never, Services<Refs[keyof Refs]>>;
+  readonly subscriberCount: Effect.Effect<number, never, Services<Refs[keyof Refs]>>;
+
+  private versioned: Versioned.Versioned<
+    Services<Refs[keyof Refs]>,
+    Error<Refs[keyof Refs]>,
+    { readonly [K in keyof Refs]: Success<Refs[K]> },
+    Error<Refs[keyof Refs]>,
+    Services<Refs[keyof Refs]>,
+    { readonly [K in keyof Refs]: Success<Refs[K]> },
+    Error<Refs[keyof Refs]>,
+    Services<Refs[keyof Refs]>
+  >;
+
+  private getSetDelete: GetSetDelete<
+    { readonly [K in keyof Refs]: Success<Refs[K]> },
+    Error<Refs[keyof Refs]>,
+    Services<Refs[keyof Refs]>
+  >;
+
+  readonly refs: Refs;
+
+  constructor(refs: Refs) {
+    super();
+
+    this.refs = refs;
+    this.versioned = Versioned.hold(Versioned.struct(refs)) as any;
+    this.version = this.versioned.version;
+    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,
+      ),
+      Array.reduce(0, sum),
+    );
+
+    this.getSetDelete = {
+      get: this.versioned.asEffect(),
+      set: (a) =>
+        Effect.all(
+          Object.keys(refs).map((k) => set(refs[k] as any, a[k])),
+          UNBOUNDED,
+        ) as any,
+      delete: Effect.map(
+        Effect.all(
+          Object.values(refs).map((r) => reset(r as any)),
+          UNBOUNDED,
+        ),
+        Option.all,
+      ) as any,
+    };
+
+    this.updates = this.updates.bind(this);
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  run<R3 = never>(
+    sink: Sink.Sink<{ readonly [K in keyof Refs]: Success<Refs[K]> }, Error<Refs[keyof Refs]>, R3>,
+  ): Effect.Effect<unknown, never, Services<Refs[keyof Refs]> | Scope.Scope | R3> {
+    return this.versioned.run(sink as any) as any;
+  }
+
+  toEffect() {
+    return this.versioned.asEffect();
+  }
+
+  updates<E2, R2, C>(
+    run: (
+      ref: GetSetDelete<
+        {
+          readonly [K in keyof Refs]: Success<Refs[K]>;
+        },
+        Error<Refs[keyof Refs]>,
+        Services<Refs[keyof Refs]>
+      >,
+    ) => Effect.Effect<C, E2, R2>,
+  ) {
+    return run(this.getSetDelete);
+  }
+
+  onFailure(
+    cause: Cause.Cause<Error<Refs[keyof Refs]>>,
+  ): Effect.Effect<unknown, never, Services<Refs[keyof Refs]>> {
+    return Effect.all(Object.values(this.refs).map((ref) => ref.onFailure(cause as any)));
+  }
+
+  onSuccess(value: { readonly [K in keyof Refs]: Success<Refs[K]> }): Effect.Effect<
+    unknown,
+    never,
+    Services<Refs[keyof Refs]>
+  > {
+    return Effect.catchCause(this.getSetDelete.set(value), (c) => this.onFailure(c));
+  }
+}
+
+function makeStructComputed<const Refs extends Readonly<Record<string, Computed<any, any, any>>>>(
+  refs: Refs,
+): ComputedStructFrom<Refs> {
+  return new ComputedImpl(Versioned.struct(refs) as any, Effect.succeed) as any;
+}
+
+function makeStructFiltered<
+  const Refs extends Readonly<Record<string, Computed<any, any, any> | Filtered<any, any, any>>>,
+>(refs: Refs): FilteredStructFrom<Refs> {
+  return new FilteredImpl(Versioned.struct(refs) as any, Effect.succeedSome) as any;
+}
+
+export function computedFromService<R, A, E, R2>(
+  effect: Effect.Effect<Computed<A, E, R2>, never, R>,
+): Computed<A, E, R | R2> {
+  return new ComputedFromService(effect);
+}
+
+class ComputedFromService<R, A, E, R2>
+  extends YieldableFx<A, E, R | R2 | Scope.Scope, A, E, R | R2>
+  implements Computed<A, E, R | R2>
+{
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId;
+
+  private readonly effect: Effect.Effect<Computed<A, E, R2>, never, R>;
+  readonly version: Effect.Effect<number, E, R | R2>;
+  readonly interrupt: Effect.Effect<void, never, R | R2>;
+
+  constructor(effect: Effect.Effect<Computed<A, E, R2>, never, R>) {
+    super();
+    this.effect = effect;
+    this.version = Effect.flatMap(this.effect, (c) => c.version);
+    this.interrupt = Effect.flatMap(this.effect, (c) => c.interrupt);
+  }
+
+  run<RSink>(
+    sink: Sink.Sink<A, E, RSink>,
+  ): Effect.Effect<unknown, never, R | R2 | RSink | Scope.Scope> {
+    return Effect.flatMap(this.effect, (c) => c.run(sink));
+  }
+
+  toEffect(): Effect.Effect<A, E, R | R2> {
+    return Effect.flatMap(this.effect, (c) => c.asEffect());
+  }
+}
+
+export function filteredFromService<R, A, E, R2>(
+  effect: Effect.Effect<Filtered<A, E, R2>, never, R>,
+): Filtered<A, E, R | R2> {
+  return new FilteredFromService(effect);
+}
+
+class FilteredFromService<R, A, E, R2>
+  extends YieldableFx<A, E, R | R2 | Scope.Scope, A, E | Cause.NoSuchElementError, R | R2>
+  implements Filtered<A, E, R | R2>
+{
+  readonly [FilteredTypeId]: FilteredTypeId = FilteredTypeId;
+
+  private readonly effect: Effect.Effect<Filtered<A, E, R2>, never, R>;
+  readonly version: Effect.Effect<number, E, R | R2>;
+  readonly interrupt: Effect.Effect<void, never, R | R2>;
+
+  constructor(effect: Effect.Effect<Filtered<A, E, R2>, never, R>) {
+    super();
+    this.effect = effect;
+    this.version = Effect.flatMap(this.effect, (c) => c.version);
+    this.interrupt = Effect.flatMap(this.effect, (c) => c.interrupt);
+  }
+
+  run<RSink>(
+    sink: Sink.Sink<A, E, RSink>,
+  ): Effect.Effect<unknown, never, R | R2 | RSink | Scope.Scope> {
+    return Effect.flatMap(this.effect, (c) => c.run(sink));
+  }
+
+  toEffect(): Effect.Effect<A, E | Cause.NoSuchElementError, R | R2> {
+    return Effect.flatMap(this.effect, (c) => c.asEffect());
+  }
+
+  asComputed(): Computed<Option.Option<A>, E, R | R2> {
+    return computedFromService<R, Option.Option<A>, E, R2>(
+      Effect.map(this.effect, (c) => c.asComputed()),
+    );
+  }
+}