@typed/fx 1.13.0 → 1.15.0

package/dist/cjs/RefSubject.js

@@ -22,294 +22,403 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRefSubject = exports.RefSubject = exports.makeRef = exports.RefSubjectTypeId = void 0;
-const Debug_1 = require("@effect/data/Debug");
-const Equal_1 = require("@effect/data/Equal");
+exports.asRef = exports.isRefSubject = exports.RefSubject = exports.makeRef = exports.RefSubjectTypeId = void 0;
+const Context = __importStar(require("@effect/data/Context"));
 const Equal = __importStar(require("@effect/data/Equal"));
 const Function_1 = require("@effect/data/Function");
 const Hash = __importStar(require("@effect/data/Hash"));
 const MutableRef = __importStar(require("@effect/data/MutableRef"));
 const Option = __importStar(require("@effect/data/Option"));
-const RR = __importStar(require("@effect/data/ReadonlyRecord"));
-const Equivalence = __importStar(require("@effect/data/typeclass/Equivalence"));
+const Pipeable_1 = require("@effect/data/Pipeable");
+const Equivalence = __importStar(require("@effect/data/Equivalence"));
+const Deferred = __importStar(require("@effect/io/Deferred"));
 const Effect = __importStar(require("@effect/io/Effect"));
 const Fiber = __importStar(require("@effect/io/Fiber"));
+const Scope = __importStar(require("@effect/io/Scope"));
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const Computed_js_1 = require("./Computed.js");
+const Filtered_js_1 = require("./Filtered.js");
 const Fx_js_1 = require("./Fx.js");
+const RefTransform_js_1 = require("./RefTransform.js");
 const combineAll_js_1 = require("./combineAll.js");
 const hold_js_1 = require("./hold.js");
-const map_js_1 = require("./map.js");
-const multicast_js_1 = require("./multicast.js");
 const never_js_1 = require("./never.js");
-const switchMap_js_1 = require("./switchMap.js");
-exports.RefSubjectTypeId = Symbol.for('./RefSubject');
-function makeRef(effect, eq = Equal_1.equals) {
-    return Effect.contextWith((ctx) => new RefSubjectImpl(Effect.provideContext(effect, ctx), eq));
+const observe_js_1 = require("./observe.js");
+const struct_js_1 = require("./struct.js");
+const switchMatch_js_1 = require("./switchMatch.js");
+const unboundedConcurrency = { concurrency: 'unbounded' };
+const refVariance = {
+    _R: Function_1.identity,
+    _E: Function_1.identity,
+    _A: Function_1.identity,
+};
+exports.RefSubjectTypeId = Symbol.for('@typed/fx/RefSubject');
+function makeRef(effect, eq) {
+    return Effect.contextWithEffect((context) => Effect.suspend(() => {
+        const ref = RefSubject.unsafeMake(Effect.provideContext(effect, context), Context.get(context, Scope.Scope), eq);
+        return Effect.as(Effect.addFinalizer(() => ref.end()), ref);
+    }));
 }
 exports.makeRef = makeRef;
 var RefSubject;
 (function (RefSubject) {
-    function tuple(...subjects) {
-        return new TupleRefSubjectImpl(subjects);
+    function unsafeMake(initial, scope, eq = fast_deep_equal_1.default) {
+        return makeRefFromPrimitive(unsafeMakeRefPrimitive(initial, scope, eq));
+    }
+    RefSubject.unsafeMake = unsafeMake;
+    function tuple(...refs) {
+        return makeRefFromPrimitive(tupleRefPrimitive(refs));
     }
     RefSubject.tuple = tuple;
-    function struct(subjects) {
-        return new StructRefSubjectImpl(subjects);
+    function struct(refs) {
+        return makeRefFromPrimitive(structRefPrimitive(refs));
     }
     RefSubject.struct = struct;
-    function all(subjects) {
-        return (Array.isArray(subjects) ? tuple(...subjects) : struct(subjects));
+    function all(...subjects) {
+        /// MUST be a tuple if more than one argument
+        if (subjects.length > 1) {
+            return tuple(...subjects);
+        }
+        // Otherwise a single param is either a tuple or a struct
+        const singleParam = subjects[0];
+        if (Array.isArray(singleParam)) {
+            return tuple(...singleParam);
+        }
+        return struct(singleParam);
     }
     RefSubject.all = all;
-    function unsafeMake(get, eq = Equal_1.equals) {
-        return new RefSubjectImpl(get, eq);
-    }
-    RefSubject.unsafeMake = unsafeMake;
-})(RefSubject = exports.RefSubject || (exports.RefSubject = {}));
-const refSubjectVariant = {
-    _R: Function_1.identity,
-    _E: Function_1.identity,
-    _A: Function_1.identity,
-};
-class RefSubjectImpl extends hold_js_1.HoldFx {
-    constructor(i0, i1) {
-        super((0, never_js_1.never)());
-        this.i0 = i0;
-        this.i1 = i1;
-        this._tag = 'Commit';
-        this.i2 = undefined;
-        this.trace = undefined;
-        this[_a] = refSubjectVariant;
-        this[_b] = exports.RefSubjectTypeId;
-        this.lock = Effect.unsafeMakeSemaphore(1).withPermits(1);
-        this.initializeFiber = MutableRef.make(Option.none());
-        this.event = (0, Debug_1.methodWithTrace)((trace) => (a) => Effect.catchAllCause(this.set(a), this.error).traced(trace));
-        this.end = (0, Debug_1.methodWithTrace)((trace) => () => Effect.suspend(() => Effect.zipPar(this.interruptFibers(), this.interruptInitializeFiber())).traced(trace));
-        this.get = Effect.suspend(() => (0, Function_1.pipe)(MutableRef.get(this.current), Option.match(() => (0, Function_1.pipe)(MutableRef.get(this.initializeFiber), Option.match(() => this.lock(Effect.uninterruptibleMask((restore) => (0, Function_1.pipe)(Effect.forkDaemon(restore(this.i0)), Effect.tap((fiber) => Effect.sync(() => MutableRef.set(this.initializeFiber, Option.some(fiber)))), Effect.flatMap(Fiber.join), Effect.tap((a) => Effect.suspend(() => {
-            MutableRef.set(this.current, Option.some(a));
-            MutableRef.set(this.initializeFiber, Option.none());
-            return super.event(a);
-        }))))), Fiber.join)), Effect.succeed)));
-        this.modify = (f) => this.modifyEffect((a) => Effect.sync(() => f(a)));
-        this.updateEffect = (f) => this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]));
-        this.update = (f) => this.updateEffect((a) => Effect.sync(() => f(a)));
-        this.set = (a) => this.update(() => a);
-        this.delete = Effect.suspend(() => {
-            const current = MutableRef.get(this.current);
-            if (Option.isSome(current)) {
-                MutableRef.set(this.current, Option.none());
-            }
-            return Effect.succeed(current);
-        });
-        this.mapEffect = (f) => new ComputedImpl(this, f);
-        this.map = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
-        this.modifyEffect = this.modifyEffect.bind(this);
-        this.eq = i1;
-    }
-    run(sink) {
-        return Effect.suspend(() => {
-            const current = MutableRef.get(this.current);
-            if (Option.isNone(current)) {
-                return (0, Function_1.pipe)(this.get, Effect.catchAllCause(sink.error), Effect.flatMap(() => super.run(sink)));
-            }
-            return super.run(sink);
-        });
-    }
-    interruptFibers() {
-        return this.fiber ? Fiber.interrupt(this.fiber) : Effect.unit();
-    }
-    interruptInitializeFiber() {
-        const fiber = MutableRef.get(this.initializeFiber);
+})(RefSubject || (exports.RefSubject = RefSubject = {}));
+function isRefSubject(u) {
+    return (0, Fx_js_1.isFx)(u) && exports.RefSubjectTypeId in u;
+}
+exports.isRefSubject = isRefSubject;
+// Internals for RefSubject
+function makeGetFromContext(ctx) {
+    return Effect.suspend(() => {
+        const current = MutableRef.get(ctx.currentRef);
+        if (Option.isSome(current)) {
+            return Effect.succeed(current.value);
+        }
+        const fiber = MutableRef.get(ctx.initializingFiberRef);
         if (Option.isSome(fiber)) {
-            return Fiber.interrupt(fiber.value);
+            return Fiber.join(fiber.value);
         }
-        return Effect.unit();
-    }
-    modifyEffect(f) {
-        return (0, Debug_1.methodWithTrace)((trace) => (f) => Effect.flatMap(this.get, (a1) => this.lock(Effect.flatMap(f(a1), ([b, a2]) => Effect.suspend(() => {
-            MutableRef.set(this.current, Option.some(a2));
-            if (this.i1(a1, a2)) {
-                return Effect.succeed(b);
+        return Effect.tap(ctx.lock(initializeFromContext(ctx)), (a) => ctx.hold.event(a));
+    });
+}
+function initializeFromContext(ctx) {
+    return Effect.uninterruptibleMask((restore) => Effect.flatMap(Effect.forkIn(restore(ctx.initial), ctx.scope), (fiber) => {
+        MutableRef.set(ctx.initializingFiberRef, Option.some(fiber));
+        return Effect.tap(Fiber.join(fiber), (a) => Effect.sync(() => {
+            MutableRef.increment(ctx.version);
+            MutableRef.set(ctx.currentRef, Option.some(a));
+            MutableRef.set(ctx.initializingFiberRef, Option.none());
+        }));
+    }));
+}
+function makeRefMethods(primitive) {
+    const modify = makeModify(primitive.modifyEffect);
+    const updateEffect = makeUpdateEffect(primitive.modifyEffect);
+    const update = makeUpdate(updateEffect);
+    return {
+        modify,
+        updateEffect,
+        update,
+    };
+}
+function makeModifyEffectFromContext(get, ctx) {
+    return (f) => Effect.flatMap(get, (a1) => ctx.lock(Effect.flatMap(f(a1), ([b, a2]) => Effect.suspend(() => {
+        MutableRef.set(ctx.currentRef, Option.some(a2));
+        if (ctx.eq(a1, a2)) {
+            return Effect.succeed(b);
+        }
+        MutableRef.increment(ctx.version);
+        return Effect.as(ctx.hold.event(a2), b);
+    }))));
+}
+function makeModify(modifyEffect) {
+    return (f) => modifyEffect((a) => Effect.sync(() => f(a)));
+}
+function makeUpdateEffect(modifyEffect) {
+    return (f) => modifyEffect((a) => Effect.map(f(a), (a) => [a, a]));
+}
+function makeUpdate(updateEffect) {
+    return (f) => updateEffect((a) => Effect.sync(() => f(a)));
+}
+function makeSetFromContext(ctx) {
+    return (a) => Effect.suspend(() => {
+        const fiber = MutableRef.get(ctx.initializingFiberRef);
+        return (0, Function_1.pipe)(fiber, Option.match({ onNone: () => Effect.unit, onSome: Fiber.await }), 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Effect.flatMap((_) => {
+            const current = MutableRef.get(ctx.currentRef);
+            MutableRef.set(ctx.currentRef, Option.some(a));
+            // Only emit if the value has changed
+            if (Option.isNone(current) || (Option.isSome(current) && !ctx.eq(current.value, a))) {
+                // Increment the version
+                MutableRef.increment(ctx.version);
+                return Effect.as(ctx.hold.event(a), a);
             }
-            return Effect.as(super.event(a2), b);
-        })))).traced(trace))(f);
-    }
-    [(_a = Effect.EffectTypeId, _b = exports.RefSubjectTypeId, Equal.symbol)](that) {
+            return Effect.succeed(a);
+        }));
+    });
+}
+function makeDeleteFromContext(ctx) {
+    return Effect.sync(() => {
+        const current = MutableRef.get(ctx.currentRef);
+        if (Option.isSome(current)) {
+            MutableRef.set(ctx.version, 0);
+            MutableRef.set(ctx.currentRef, Option.none());
+        }
+        return current;
+    });
+}
+function makeEndFromContext(ctx) {
+    return () => Effect.suspend(() => {
+        MutableRef.set(ctx.version, 0);
+        const fibers = [
+            ctx.hold.fiber || Fiber.unit,
+            Option.getOrElse(MutableRef.get(ctx.initializingFiberRef), () => Fiber.unit),
+        ];
+        return Fiber.interruptAll(fibers);
+    });
+}
+function makeFiltered(f) {
+    const get = makeMemoizedGet(f);
+    function filterMapEffect(f) {
+        return new Filtered_js_1.FilteredImpl(get(), f);
+    }
+    function filterMap(f) {
+        return filterMapEffect((a) => Effect.sync(() => f(a)));
+    }
+    function filterEffect(f) {
+        return filterMapEffect((a) => Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())));
+    }
+    function filter(f) {
+        return filterEffect((a) => Effect.sync(() => f(a)));
+    }
+    function filterNotEffect(f) {
+        return filterEffect((a) => Effect.map(f(a), (b) => !b));
+    }
+    function filterNot(f) {
+        return filterNotEffect((a) => Effect.sync(() => f(a)));
+    }
+    return {
+        filterMapEffect,
+        filterMap,
+        filterEffect,
+        filter,
+        filterNotEffect,
+        filterNot,
+    };
+}
+function makeComputedMethods(f) {
+    const get = makeMemoizedGet(f);
+    function mapEffect(f) {
+        return new Computed_js_1.ComputedImpl(get(), f);
+    }
+    function map(f) {
+        return mapEffect((a) => Effect.sync(() => f(a)));
+    }
+    return {
+        mapEffect,
+        map,
+    };
+}
+function makeTransformMethods(f) {
+    const get = makeMemoizedGet(f);
+    function transformBoth(f, g) {
+        return new RefTransform_js_1.RefTransformImpl(get(), f, g);
+    }
+    function transform(f) {
+        return transformBoth(f, Function_1.identity);
+    }
+    function transformGet(f) {
+        return transformBoth(Function_1.identity, f);
+    }
+    return {
+        transformBoth,
+        transform,
+        transformGet,
+    };
+}
+const placeholders = {
+    _tag: 'Commit',
+    [Effect.EffectTypeId]: refVariance,
+    i0: undefined,
+    i1: undefined,
+    i2: undefined,
+    [Equal.symbol](that) {
         return this === that;
-    }
+    },
     [Hash.symbol]() {
         return Hash.random(this);
-    }
-    traced(trace) {
-        if (trace) {
-            const traced = new RefSubjectImpl(this.i0, this.i1);
-            traced.trace = trace;
-            return traced;
+    },
+    pipe() {
+        // eslint-disable-next-line prefer-rest-params
+        return (0, Pipeable_1.pipeArguments)(this, arguments);
+    },
+};
+function makeEffectMethods(get) {
+    return Object.assign({
+        commit() {
+            return get;
+        },
+    }, placeholders);
+}
+function makeMemoizedGet(f) {
+    let memoized = Option.none();
+    return () => {
+        if (Option.isNone(memoized)) {
+            memoized = Option.some(f());
         }
-        return this;
-    }
-    commit() {
-        return this.get.traced(this.trace);
-    }
+        return memoized.value;
+    };
 }
-class TupleRefSubjectImpl extends hold_js_1.HoldFx {
-    constructor(i0) {
-        super((0, combineAll_js_1.combineAll)(...i0));
-        this.i0 = i0;
-        this._tag = 'Commit';
-        this.trace = undefined;
-        this[_c] = refSubjectVariant;
-        this[_d] = exports.RefSubjectTypeId;
-        this.i2 = undefined;
-        this.lock = Effect.unsafeMakeSemaphore(1).withPermits(1);
-        this.get = Effect.suspend(() => Effect.allPar(this.i0.map((s) => s.get)));
-        this.modify = (f) => this.modifyEffect((a) => Effect.sync(() => f(a)));
-        this.updateEffect = (f) => this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]));
-        this.update = (f) => this.updateEffect((a) => Effect.sync(() => f(a)));
-        this.set = (a) => this.update(() => a);
-        this.delete = Effect.suspend(() => {
-            const current = MutableRef.get(this.current);
-            if (Option.isSome(current)) {
-                MutableRef.set(this.current, Option.none());
+function makeRefSubjectContext(initial, scope, eq) {
+    const hold = new hold_js_1.HoldFx((0, never_js_1.never)());
+    const ctx = {
+        initial,
+        currentRef: hold.current,
+        initializingFiberRef: MutableRef.make(Option.none()),
+        lock: Effect.unsafeMakeSemaphore(1).withPermits(1),
+        scope,
+        eq,
+        hold,
+        version: MutableRef.make(0),
+    };
+    return ctx;
+}
+function unsafeMakeRefPrimitive(initial, scope, eq) {
+    const ctx = makeRefSubjectContext(initial, scope, eq);
+    const get = makeGetFromContext(ctx);
+    const set = makeSetFromContext(ctx);
+    function run(sink) {
+        return Effect.suspend(() => {
+            const current = MutableRef.get(ctx.hold.current);
+            if (Option.isNone(current)) {
+                return (0, Function_1.pipe)(primitive.get, Effect.catchAllCause(sink.error), Effect.flatMap(() => ctx.hold.run(sink)));
             }
-            return Effect.succeed(current);
+            return ctx.hold.run(sink);
         });
-        this.mapEffect = (f) => new ComputedImpl(this, f);
-        this.map = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
-        this.i1 = this.eq = Equivalence.tuple(...i0.map((s) => s.eq));
-    }
-    end() {
-        return Effect.allPar(this.i0.map((s) => s.end()));
-    }
-    modifyEffect(f) {
-        const { current, i0 } = this;
-        return (0, Function_1.pipe)(this.get, Effect.flatMap((a) => this.lock(Effect.gen(function* ($) {
-            const [b, a2] = yield* $(f(a));
-            MutableRef.set(current, Option.some(a2));
-            yield* $(Effect.allPar(i0.map((s, i) => s.set(a2[i]))));
-            return b;
-        }))));
-    }
-    [(_c = Effect.EffectTypeId, _d = exports.RefSubjectTypeId, Equal.symbol)](that) {
-        return this === that;
-    }
-    [Hash.symbol]() {
-        return Hash.random(this);
-    }
-    traced(trace) {
-        if (trace) {
-            const traced = new TupleRefSubjectImpl(this.i0);
-            traced.trace = trace;
-            return traced;
-        }
-        return this;
-    }
-    commit() {
-        return this.get.traced(this.trace);
     }
+    const primitive = {
+        delete: makeDeleteFromContext(ctx),
+        end: makeEndFromContext(ctx),
+        eq,
+        error: (cause) => ctx.hold.error(cause),
+        event: set,
+        get,
+        modifyEffect: makeModifyEffectFromContext(get, ctx),
+        run,
+        set,
+        version: ctx.version,
+    };
+    return primitive;
+}
+function makeRefFromPrimitive(primitive) {
+    const ref = {
+        [Fx_js_1.FxTypeId]: refVariance,
+        [exports.RefSubjectTypeId]: exports.RefSubjectTypeId,
+        [Computed_js_1.ComputedTypeId]: Computed_js_1.ComputedTypeId,
+        ...primitive,
+        ...makeRefMethods(primitive),
+        ...makeEffectMethods(primitive.get),
+        ...makeFiltered(() => ref),
+        ...makeComputedMethods(() => ref),
+        ...makeTransformMethods(() => ref),
+        version() {
+            return MutableRef.get(primitive.version);
+        },
+    };
+    return ref;
 }
-class StructRefSubjectImpl extends hold_js_1.HoldFx {
-    constructor(i0) {
-        super((0, map_js_1.map)((0, combineAll_js_1.combineAll)(...Object.entries(i0).map(([k, s]) => (0, map_js_1.map)(s, (x) => [k, x]))), Object.fromEntries));
-        this.i0 = i0;
-        this._tag = 'Commit';
-        this.trace = undefined;
-        this[_e] = refSubjectVariant;
-        this[_f] = exports.RefSubjectTypeId;
-        this.i2 = undefined;
-        this.lock = Effect.unsafeMakeSemaphore(1).withPermits(1);
-        this.get = Effect.suspend(() => Effect.allPar(RR.map(this.i0, (s) => s.get)));
-        this.modify = (f) => this.modifyEffect((a) => Effect.sync(() => f(a)));
-        this.updateEffect = (f) => this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]));
-        this.update = (f) => this.updateEffect((a) => Effect.sync(() => f(a)));
-        this.set = (a) => this.update(() => a);
-        this.delete = Effect.suspend(() => {
-            const current = MutableRef.get(this.current);
-            if (Option.isSome(current)) {
-                MutableRef.set(this.current, Option.none());
+// Internals for RefSubject.tuple
+function tupleRefPrimitive(refs) {
+    const hold = new hold_js_1.HoldFx((0, combineAll_js_1.combineAll)(...refs));
+    const eq = Equivalence.tuple(...refs.map((ref) => ref.eq));
+    const get = Effect.all(refs.map((ref) => ref.get), unboundedConcurrency);
+    const primitive = {
+        delete: Effect.map(Effect.all(refs.map((ref) => ref.delete), { concurrency: 'unbounded' }), (values) => Option.all(values)),
+        end: () => Effect.all(refs.map((ref) => ref.end()), unboundedConcurrency),
+        eq,
+        error: (error) => hold.error(error),
+        event: (value) => Effect.all(value.map((v, i) => refs[i].event(v)), unboundedConcurrency),
+        get,
+        modifyEffect: makeModifyEffectTuple(refs, get, eq),
+        run: (sink) => hold.run(sink),
+        set: (value) => Effect.all(value.map((v, i) => refs[i].set(v)), unboundedConcurrency),
+        version: MutableRef.make(0),
+    };
+    return primitive;
+}
+function makeModifyEffectTuple(refs, get, eq) {
+    return (f) => {
+        return Effect.gen(function* ($) {
+            const current = yield* $(get);
+            const [b, a] = yield* $(f(current));
+            if (eq(a, current)) {
+                return b;
             }
-            return Effect.succeed(current);
+            yield* $(Effect.all(refs.map((ref, i) => ref.set(a[i])), unboundedConcurrency));
+            return b;
         });
-        this.mapEffect = (f) => new ComputedImpl(this, f);
-        this.map = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
-        this.i1 = this.eq = Equivalence.struct(RR.map(i0, (s) => s.eq));
-    }
-    end() {
-        return Effect.allPar(RR.map(this.i0, (s) => s.end()));
-    }
-    modifyEffect(f) {
-        const { current, i0: subjects } = this;
-        return (0, Function_1.pipe)(this.get, Effect.flatMap((a) => this.lock(Effect.gen(function* ($) {
-            const [b, a2] = yield* $(f(a));
-            MutableRef.set(current, Option.some(a2));
-            yield* $(Effect.allPar(RR.map(subjects, (s, i) => s.set(a2[i]))));
+    };
+}
+function structRefPrimitive(refs) {
+    const hold = new hold_js_1.HoldFx((0, struct_js_1.struct)(refs));
+    const eq = Equivalence.struct(mapRecord(refs, (ref) => ref.eq));
+    const get = Effect.all(mapRecord(refs, (ref) => ref.get), unboundedConcurrency);
+    const primitive = {
+        delete: Effect.map(Effect.all(mapRecord(refs, (ref) => ref.delete), unboundedConcurrency), (values) => Option.all(values)),
+        end: () => Effect.all(mapRecord(refs, (ref) => ref.end()), unboundedConcurrency),
+        eq,
+        error: (error) => hold.error(error),
+        event: (value) => Effect.all(mapRecord(value, (v, i) => refs[i].event(v)), unboundedConcurrency),
+        get,
+        modifyEffect: makeModifyEffectStruct(refs, get, eq),
+        run: (sink) => hold.run(sink),
+        set: (value) => Effect.all(mapRecord(value, (v, i) => refs[i].set(v)), unboundedConcurrency),
+        version: MutableRef.make(0),
+    };
+    return primitive;
+}
+function makeModifyEffectStruct(refs, get, eq) {
+    return (f) => {
+        return Effect.gen(function* ($) {
+            const current = yield* $(get);
+            const [b, a] = yield* $(f(current));
+            if (eq(a, current)) {
+                return b;
+            }
+            yield* $(Effect.all(mapRecord(refs, (ref, i) => ref.set(a[i])), unboundedConcurrency));
             return b;
-        }))));
-    }
-    [(_e = Effect.EffectTypeId, _f = exports.RefSubjectTypeId, Equal.symbol)](that) {
-        return this === that;
-    }
-    [Hash.symbol]() {
-        return Hash.random(this);
-    }
-    traced(trace) {
-        if (trace) {
-            const traced = new StructRefSubjectImpl(this.i0);
-            traced.trace = trace;
-            return traced;
-        }
-        return this;
-    }
-    commit() {
-        return this.get.traced(this.trace);
-    }
+        });
+    };
 }
-class ComputedImpl {
-    constructor(i0, i1) {
-        this.i0 = i0;
-        this.i1 = i1;
-        this[_g] = {
-            _R: Function_1.identity,
-            _E: Function_1.identity,
-            _A: Function_1.identity,
-        };
-        this._tag = 'Commit';
-        this.trace = undefined;
-        this[_h] = refSubjectVariant;
-        this[_j] = exports.RefSubjectTypeId;
-        this.get = Effect.flatMap(this.i0.get, this.i1);
-        this.mapEffect = (f) => new ComputedImpl(this.i0, (a) => Effect.flatMap(this.i1(a), f));
-        this.map = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
-        // Create a stable reference to derived Fx
-        this.i2 = (0, multicast_js_1.multicast)((0, switchMap_js_1.switchMapEffect)(this.i0, this.i1));
-    }
-    run(sink) {
-        return this.i2.run(sink);
-    }
-    addTrace(trace) {
-        return (0, Fx_js_1.Traced)(this, trace);
-    }
-    [(_g = Fx_js_1.FxTypeId, _h = Effect.EffectTypeId, _j = exports.RefSubjectTypeId, Equal.symbol)](that) {
-        return this === that;
-    }
-    [Hash.symbol]() {
-        return Hash.random(this);
-    }
-    traced(trace) {
-        if (trace) {
-            const traced = new ComputedImpl(this.i0, this.i1);
-            traced.trace = trace;
-            return traced;
-        }
-        return this;
-    }
-    commit() {
-        return this.get.traced(this.trace);
+function mapRecord(record, f) {
+    const result = {};
+    for (const k in record) {
+        result[k] = f(record[k], k);
     }
+    return result;
 }
-function isRefSubject(u) {
-    return (0, Fx_js_1.isFx)(u) && exports.RefSubjectTypeId in u && u[exports.RefSubjectTypeId] === exports.RefSubjectTypeId;
+function asRef(fx) {
+    return Effect.flatMap(Deferred.make(), (deferred) => Effect.flatMap(makeRef(Deferred.await(deferred)), (ref) => {
+        const onValue = (value) => Effect.flatMap(Deferred.succeed(deferred, value), (closed) => closed ? Effect.unit : ref.set(value));
+        return Effect.as(Effect.forkScoped(Effect.catchAllCause((0, observe_js_1.drain)((0, switchMatch_js_1.switchMatchCauseEffect)(fx, ref.error, onValue)), ref.error)), ref);
+    }));
+    return Effect.gen(function* ($) {
+        const deferred = yield* $(Deferred.make());
+        const ref = yield* $(makeRef(Deferred.await(deferred)));
+        const onValue = (value) => Effect.flatMap(Deferred.succeed(deferred, value), (closed) => closed ? Effect.unit : ref.set(value));
+        yield* $((0, switchMatch_js_1.switchMatchCauseEffect)(fx, ref.error, onValue), observe_js_1.drain, Effect.catchAllCause(ref.error), Effect.forkScoped);
+        return ref;
+    });
 }
-exports.isRefSubject = isRefSubject;
+exports.asRef = asRef;
 //# sourceMappingURL=RefSubject.js.map