@typed/fx 1.32.0 → 2.0.0-beta.0

package/dist/RefSubject/RefSubject.js

@@ -0,0 +1,1310 @@
+/** @effect-diagnostics missingEffectError:skip-file */
+/** @effect-diagnostics missingEffectContext:skip-file */
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import { equals } from "effect/Equal";
+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 { 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 * as DeferredRef from "../Fx/internal/DeferredRef.js";
+import { getExitEquivalence } from "../Fx/internal/equivalence.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 const ComputedTypeId = Symbol.for("@typed/fx/Computed");
+export const FilteredTypeId = Symbol.for("@typed/fx/Filtered");
+export const CurrentComputedBehavior = ServiceMap.Reference("@typed/fx/CurrentComputedBehavior", {
+    defaultValue: () => "multiple",
+});
+const checkIsMultiple = (ctx) => ServiceMap.getReferenceUnsafe(ctx, CurrentComputedBehavior) === "multiple";
+class ComputedImpl extends Versioned.VersionedTransform {
+    [ComputedTypeId] = ComputedTypeId;
+    _computed;
+    input;
+    f;
+    constructor(input, f) {
+        super(input, (fx) => fxMapEffect(fx, f), 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));
+        })));
+    }
+    run(sink) {
+        return this._computed.run(sink);
+    }
+}
+export function makeComputed(input, f) {
+    return new ComputedImpl(input, f);
+}
+export function makeFiltered(input, f) {
+    return new FilteredImpl(input, f);
+}
+class FilteredImpl extends Versioned.VersionedTransform {
+    [FilteredTypeId] = FilteredTypeId;
+    _computed;
+    input;
+    f;
+    constructor(input, f) {
+        super(input, (fx) => fxFilterMapEffect(fx, f), (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)));
+        })));
+    }
+    run(sink) {
+        return this._computed.run(sink);
+    }
+    asComputed() {
+        return new ComputedImpl(this.input, this.f);
+    }
+}
+class RefSubjectCore {
+    initial;
+    subject;
+    services;
+    scope;
+    deferredRef;
+    semaphore;
+    constructor(initial, subject, services, scope, deferredRef, semaphore) {
+        this.initial = initial;
+        this.subject = subject;
+        this.services = services;
+        this.scope = scope;
+        this.deferredRef = deferredRef;
+        this.semaphore = semaphore;
+    }
+    _fiber = undefined;
+}
+function getSetDelete(ref) {
+    return {
+        get: getOrInitializeCore(ref, false),
+        set: (a) => setCore(ref, a),
+        delete: deleteCore(ref),
+    };
+}
+class RefSubjectImpl extends YieldableFx {
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    getSetDelete;
+    core;
+    constructor(core) {
+        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(sink) {
+        return Effect.matchCauseEffect(getOrInitializeCore(this.core, true), {
+            onFailure: (cause) => sink.onFailure(cause),
+            onSuccess: () => Effect.provide(this.core.subject.run(sink), this.core.services),
+        });
+    }
+    updates(run) {
+        return this.core.semaphore.withPermits(1)(run(this.getSetDelete));
+    }
+    onSuccess(value) {
+        return setCore(this.core, value);
+    }
+    onFailure(cause) {
+        return onFailureCore(this.core, cause);
+    }
+    toEffect() {
+        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(effect, options) {
+    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(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(effect, options) {
+    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(fx, options) {
+    return Effect.gen(function* () {
+        const core = yield* makeDeferredCore(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(stream, options) {
+    return Effect.gen(function* () {
+        const core = yield* makeDeferredCore(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;
+    });
+}
+function redirectCause(core) {
+    return Stream.catchCause((cause) => Stream.unwrap(Effect.as(onFailureCore(core, cause), Stream.empty)));
+}
+function makeCore(initial, options, deferredRef) {
+    return Effect.gen(function* () {
+        const services = yield* Effect.services();
+        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();
+        const core = new RefSubjectCore(initial, subject, services, scope, deferredRef ??
+            DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? equals), subject.lastValue), Effect.makeSemaphoreUnsafe(1));
+        yield* Scope.addFinalizer(scope, core.subject.interrupt);
+        return core;
+    });
+}
+function makeDeferredCore(options) {
+    return Effect.gen(function* () {
+        const deferredRef = yield* DeferredRef.make(getExitEquivalence(options?.eq ?? equals));
+        return yield* makeCore(deferredRef.asEffect(), options, deferredRef);
+    });
+}
+function getOrInitializeCore(core, lockInitialize) {
+    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(core, lock) {
+    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(core, lock) {
+    return Effect.flatMapEager(initializeCoreEffect(core, lock), () => tapEventCore(core, core.deferredRef.asEffect()));
+}
+function setCore(core, a) {
+    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(core, cause) {
+    const exit = Exit.failCause(cause);
+    return Effect.suspend(() => {
+        if (core.deferredRef.done(exit)) {
+            return sendEvent(core, exit);
+        }
+        else {
+            return Effect.void;
+        }
+    });
+}
+function interruptCore(core) {
+    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(core) {
+    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) => count > 0 && !core._fiber ? initializeCoreEffect(core, false) : Effect.void), Effect.flatMap(() => Effect.asSome(current.value)));
+    });
+}
+function tapEventCore(core, effect) {
+    return effect.pipe(Effect.onExit((exit) => sendEvent(core, exit)));
+}
+function sendEvent(core, exit) {
+    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 = dual(2, function set(ref, a) {
+    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(ref) {
+    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 = dual(2, function updateEffect(ref, f) {
+    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 = dual(2, function update(ref, f) {
+    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 = dual(2, function modifyEffect(ref, f) {
+    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 = dual(2, function modify(ref, f) {
+    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) {
+    return value && typeof value === "object" && value[RefSubjectTypeId] === RefSubjectTypeId;
+}
+const isRefSubjectDataFirst = (args) => 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 = dual(isRefSubjectDataFirst, function runUpdates(ref, f, options) {
+    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(ref) {
+    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(ref) {
+    return update(ref, (value) => value - 1);
+}
+const Variance = {
+    _A: identity,
+    _E: identity,
+    _R: identity,
+};
+export function Service() {
+    return (id) => {
+        const service = ServiceMap.Service(id);
+        // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+        return class RefSubjectService {
+            /// Service
+            static id = id;
+            static service = service;
+            static layer = (make) => Layer.effect(service, make);
+            static make = (value, options) => {
+                const bounds = getDefaultBounds(options);
+                return make(value, options).pipe(Effect.map((ref) => (bounds ? slice(ref, bounds.skip, bounds.take) : ref)), this.layer);
+            };
+            // Fx
+            static [FxTypeId] = Variance;
+            static run = (sink) => Effect.flatMap(service.asEffect(), (ref) => ref.run(sink));
+            // Sink
+            static onSuccess = (value) => Effect.flatMap(service.asEffect(), (ref) => ref.onSuccess(value));
+            static onFailure = (cause) => Effect.flatMap(service.asEffect(), (ref) => ref.onFailure(cause));
+            /// Computed
+            static [ComputedTypeId] = ComputedTypeId;
+            static version = Effect.flatMap(service.asEffect(), (ref) => ref.version);
+            // Subject
+            static subscriberCount = Effect.flatMap(service.asEffect(), (ref) => ref.subscriberCount);
+            static interrupt = Effect.flatMap(service.asEffect(), (ref) => ref.interrupt);
+            // RefSubject
+            static [RefSubjectTypeId] = RefSubjectTypeId;
+            static updates = (f) => Effect.flatMap(service.asEffect(), (ref) => ref.updates(f));
+            // Yieldable
+            static asEffect = () => Effect.flatMap(service.asEffect(), Effect.fromYieldable);
+            static [Symbol.iterator] = function* () {
+                const ref = yield* service;
+                return yield* ref;
+            };
+            static pipe = function pipe() {
+                return pipeArguments(this, arguments);
+            };
+            constructor() {
+                return RefSubjectService;
+            }
+        };
+    };
+}
+function getDefaultBounds(options) {
+    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 = (source) => {
+    const target = {};
+    return new Proxy(target, {
+        get(self, prop) {
+            if (prop in self)
+                return self[prop];
+            return (self[prop] = map(source, (a) => a[prop]));
+        },
+    });
+};
+/**
+ * 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 = dual(2, function mapEffect(versioned, f) {
+    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 = dual(2, function map(versioned, f) {
+    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 = dual(2, function filterMapEffect(versioned, f) {
+    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 = dual(2, function filterMap(versioned, f) {
+    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 = function compact(versioned) {
+    return new FilteredImpl(versioned, Effect.succeed);
+};
+class RefSubjectSimpleTransform extends YieldableFx {
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    _fx;
+    ref;
+    transformFx;
+    transformEffect;
+    constructor(ref, transformFx, transformEffect) {
+        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(sink) {
+        return this._fx.run(sink);
+    }
+    toEffect() {
+        return this.transformEffect(this.ref.asEffect());
+    }
+    updates(run) {
+        return this.ref.updates(run);
+    }
+    onFailure(cause) {
+        return this.ref.onFailure(cause);
+    }
+    onSuccess(value) {
+        return this.ref.onSuccess(value);
+    }
+}
+export const slice = dual(3, function slice(ref, skip, take) {
+    return new RefSubjectSimpleTransform(ref, (_) => fxSlice(_, { skip, take }), identity);
+});
+class RefSubjectTransform extends YieldableFx {
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    _fx;
+    ref;
+    toB;
+    toA;
+    constructor(ref, toB, toA) {
+        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(sink) {
+        return this._fx.run(sink);
+    }
+    toEffect() {
+        return Effect.map(this.ref.asEffect(), this.toB);
+    }
+    updates(run) {
+        return this.ref.updates((innerRef) => {
+            const getSetDelete = {
+                get: Effect.map(innerRef.get, this.toB),
+                set: (b) => Effect.map(innerRef.set(this.toA(b)), this.toB),
+                delete: Effect.map(innerRef.delete, Option.map(this.toB)),
+            };
+            return run(getSetDelete);
+        });
+    }
+    onFailure(cause) {
+        return this.ref.onFailure(cause);
+    }
+    onSuccess(value) {
+        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 = dual(3, function transform(ref, toB, toA) {
+    return new RefSubjectTransform(ref, toB, toA);
+});
+const join = (a, b) => {
+    if (a === "r")
+        return b;
+    if (b === "r")
+        return a;
+    if (a === "f")
+        return a;
+    if (b === "f")
+        return b;
+    return "c";
+};
+function getRefKind(refs) {
+    let kind = "r";
+    for (const ref of refs) {
+        if (FilteredTypeId in ref) {
+            kind = "f";
+            break;
+        }
+        else if (!(RefSubjectTypeId in ref)) {
+            kind = join(kind, "c");
+        }
+    }
+    return kind;
+}
+/**
+ * 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(refs) {
+    const kind = getRefKind(Object.values(refs));
+    switch (kind) {
+        case "r":
+            return makeStructRef(refs);
+        case "c":
+            return makeStructComputed(refs);
+        case "f":
+            return makeStructFiltered(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(refs) {
+    const kind = getRefKind(refs);
+    switch (kind) {
+        case "r":
+            return makeTupleRef(refs);
+        case "c":
+            return makeTupleComputed(refs);
+        case "f":
+            return makeTupleFiltered(refs);
+    }
+}
+function makeTupleRef(refs) {
+    return new RefSubjectTuple(refs);
+}
+const UNBOUNDED = { concurrency: "unbounded" };
+class RefSubjectTuple extends YieldableFx {
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    versioned;
+    getSetDelete;
+    refs;
+    constructor(refs) {
+        super();
+        this.refs = refs;
+        this.versioned = Versioned.hold(Versioned.tuple(refs));
+        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),
+            delete: Effect.map(Effect.all(refs.map((r) => reset(r)), UNBOUNDED), Option.all),
+        };
+        this.updates = this.updates.bind(this);
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    run(sink) {
+        return this.versioned.run(sink);
+    }
+    toEffect() {
+        return this.versioned.asEffect();
+    }
+    updates(run) {
+        return run(this.getSetDelete);
+    }
+    onFailure(cause) {
+        return Effect.all(this.refs.map((ref) => ref.onFailure(cause)));
+    }
+    onSuccess(value) {
+        return Effect.catchCause(this.getSetDelete.set(value), (c) => this.onFailure(c));
+    }
+}
+function makeTupleComputed(refs) {
+    return new ComputedImpl(Versioned.tuple(refs), Effect.succeed);
+}
+function makeTupleFiltered(refs) {
+    return new FilteredImpl(Versioned.tuple(refs), Effect.succeedSome);
+}
+function makeStructRef(refs) {
+    return new RefSubjectStruct(refs);
+}
+class RefSubjectStruct extends YieldableFx {
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    versioned;
+    getSetDelete;
+    refs;
+    constructor(refs) {
+        super();
+        this.refs = refs;
+        this.versioned = Versioned.hold(Versioned.struct(refs));
+        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], a[k])), UNBOUNDED),
+            delete: Effect.map(Effect.all(Object.values(refs).map((r) => reset(r)), UNBOUNDED), Option.all),
+        };
+        this.updates = this.updates.bind(this);
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    run(sink) {
+        return this.versioned.run(sink);
+    }
+    toEffect() {
+        return this.versioned.asEffect();
+    }
+    updates(run) {
+        return run(this.getSetDelete);
+    }
+    onFailure(cause) {
+        return Effect.all(Object.values(this.refs).map((ref) => ref.onFailure(cause)));
+    }
+    onSuccess(value) {
+        return Effect.catchCause(this.getSetDelete.set(value), (c) => this.onFailure(c));
+    }
+}
+function makeStructComputed(refs) {
+    return new ComputedImpl(Versioned.struct(refs), Effect.succeed);
+}
+function makeStructFiltered(refs) {
+    return new FilteredImpl(Versioned.struct(refs), Effect.succeedSome);
+}
+export function computedFromService(effect) {
+    return new ComputedFromService(effect);
+}
+class ComputedFromService extends YieldableFx {
+    [ComputedTypeId] = ComputedTypeId;
+    effect;
+    version;
+    interrupt;
+    constructor(effect) {
+        super();
+        this.effect = effect;
+        this.version = Effect.flatMap(this.effect, (c) => c.version);
+        this.interrupt = Effect.flatMap(this.effect, (c) => c.interrupt);
+    }
+    run(sink) {
+        return Effect.flatMap(this.effect, (c) => c.run(sink));
+    }
+    toEffect() {
+        return Effect.flatMap(this.effect, (c) => c.asEffect());
+    }
+}
+export function filteredFromService(effect) {
+    return new FilteredFromService(effect);
+}
+class FilteredFromService extends YieldableFx {
+    [FilteredTypeId] = FilteredTypeId;
+    effect;
+    version;
+    interrupt;
+    constructor(effect) {
+        super();
+        this.effect = effect;
+        this.version = Effect.flatMap(this.effect, (c) => c.version);
+        this.interrupt = Effect.flatMap(this.effect, (c) => c.interrupt);
+    }
+    run(sink) {
+        return Effect.flatMap(this.effect, (c) => c.run(sink));
+    }
+    toEffect() {
+        return Effect.flatMap(this.effect, (c) => c.asEffect());
+    }
+    asComputed() {
+        return computedFromService(Effect.map(this.effect, (c) => c.asComputed()));
+    }
+}