@typed/fx 1.18.4 → 1.20.0

package/dist/esm/RefSubject.js

@@ -1,217 +1,940 @@
 /**
- * A RefSubject is the core abstraction for keeping state and subscribing to its
- * changes over time.
- *
- * @since 1.18.0
+ * A RefSubject is a Subject that can be used to read and write a value.
+ * @since 1.20.0
  */
 import * as C from "@typed/context";
-import { Cause, Exit, identity } from "effect";
+import { Fiber } from "effect";
+import * as Boolean from "effect/Boolean";
+import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
-import { equals } from "effect/Equal";
-import { dual } from "effect/Function";
+import * as Equal from "effect/Equal";
+import * as ExecutionStrategy from "effect/ExecutionStrategy";
+import * as Exit from "effect/Exit";
+import { dual, identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import { sum } from "effect/Number";
 import * as Option from "effect/Option";
-import { Computed, fromTag } from "./Computed.js";
-import { Filtered } from "./Filtered.js";
-import * as coreRefSubject from "./internal/core-ref-subject.js";
-import { fromStream, provide, skipRepeatsWith } from "./internal/core.js";
-import { exit, fromFxEffect } from "./internal/fx.js";
+import * as ReadonlyArray from "effect/ReadonlyArray";
+import * as Scope from "effect/Scope";
+import * as core from "./internal/core.js";
+import * as DeferredRef from "./internal/DeferredRef.js";
+import { getExitEquivalence, matchEffectPrimitive, withScope } from "./internal/helpers.js";
 import { FxEffectBase } from "./internal/protos.js";
-import { fromRefSubject, toRefSubject } from "./internal/schema-ref-subject.js";
-import { ComputedTypeId, RefSubjectTypeId } from "./TypeId.js";
+import { runtimeToLayer } from "./internal/provide.js";
+import * as share from "./internal/share.js";
+import * as Sink from "./Sink.js";
+import * as Subject from "./Subject.js";
+import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId, TypeId } from "./TypeId.js";
 import * as Versioned from "./Versioned.js";
+const UNBOUNDED = { concurrency: "unbounded" };
 /**
- * Construct a RefSubject with a lazily initialized value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function fromEffect(initial, eq) {
-    return coreRefSubject.fromEffect(initial, eq);
+export function fromEffect(effect, options) {
+    return Effect.map(makeCore(effect, options), (core) => new RefSubjectImpl(core));
 }
 /**
- * Construct a RefSubject from a synchronous value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function of(initial, eq) {
-    return fromEffect(Effect.succeed(initial), eq);
+export function fromFx(fx, options) {
+    return DeferredRef.make(getExitEquivalence(options?.eq ?? Equal.equals)).pipe(Effect.bindTo("deferredRef"), Effect.bind("core", ({ deferredRef }) => makeCore(deferredRef, options)), Effect.tap(({ core, deferredRef }) => Effect.forkIn(fx.run(Sink.make((cause) => Effect.flatMap(Effect.sync(() => deferredRef.done(Exit.failCause(cause))), () => core.subject.onFailure(cause)), (value) => Effect.flatMap(Effect.sync(() => deferredRef.done(Exit.succeed(value))), () => setCore(core, value)))), core.scope)), Effect.map(({ core }) => new RefSubjectImpl(core)));
 }
 /**
- * Construct a RefSubject from a synchronous value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
+ */
+export function fromRefSubject(ref, options) {
+    return DeferredRef.make(getExitEquivalence(options?.eq ?? Equal.equals)).pipe(Effect.bindTo("deferredRef"), Effect.bind("core", ({ deferredRef }) => makeCore(deferredRef, options)), Effect.tap(({ core, deferredRef }) => Effect.forkIn(ref.run(Sink.make((cause) => Effect.sync(() => deferredRef.done(Exit.failCause(cause))), (value) => Effect.sync(() => deferredRef.done(Exit.succeed(value))))), core.scope)), Effect.map(({ core }) => new DerivedImpl(core, persistCore(ref, core))));
+}
+function persistCore(ref, core) {
+    // Log any errors that fail to persist, but don't fail the consumer
+    return Effect.ignoreLogged(Effect.provide(Effect.flatMap(core.deferredRef, (value) => set(ref, value)), core.context));
+}
+/**
+ * @since 1.20.0
+ */
+export const make = function make(fxOrEffect, options) {
+    if (RefSubjectTypeId in fxOrEffect)
+        return fromRefSubject(fxOrEffect, options);
+    else if (TypeId in fxOrEffect)
+        return fromFx(fxOrEffect, options);
+    else
+        return fromEffect(fxOrEffect, options);
+};
+/**
+ * @since 1.20.0
  */
-export function sync(initial, eq) {
-    return fromEffect(Effect.sync(initial), eq);
+export function of(a, options) {
+    return Effect.acquireRelease(withScopeAndFiberId((scope, id) => unsafeMake({
+        id,
+        initial: Effect.succeed(a),
+        initialValue: a,
+        options,
+        scope
+    }), options?.executionStrategy ?? ExecutionStrategy.sequential), (ref) => ref.interrupt);
+}
+const withScopeAndFiberId = (f, strategy) => Effect.fiberIdWith((id) => withScope((scope) => f(scope, id), strategy));
+const emptyContext = C.empty();
+/**
+ * @since 1.20.0
+ */
+export function unsafeMake(params) {
+    const { id, initial, options, scope } = params;
+    return Effect.suspend(() => {
+        const core = unsafeMakeCore(initial, id, emptyContext, scope, options);
+        // Sometimes we might be instantiating directly from a known value
+        // Here we seed the value and ensure the subject has it as well for re-broadcasting
+        if ("initialValue" in params) {
+            core.deferredRef.done(Exit.succeed(params.initialValue));
+            return Effect.map(core.subject.onSuccess(params.initialValue), () => new RefSubjectImpl(core));
+        }
+        return Effect.succeed(new RefSubjectImpl(core));
+    });
 }
-export function make(fx, eq) {
-    return coreRefSubject.make(fx, eq);
+class RefSubjectImpl extends FxEffectBase {
+    core;
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    getSetDelete;
+    constructor(core) {
+        super();
+        this.core = core;
+        this.version = Effect.sync(() => core.deferredRef.version);
+        this.interrupt = interruptCore(core);
+        this.subscriberCount = Effect.provide(core.subject.subscriberCount, core.context);
+        this.getSetDelete = getSetDelete(core);
+        this.runUpdates = this.runUpdates.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+        this.onFailure = this.onFailure.bind(this);
+    }
+    run(sink) {
+        return Effect.matchCauseEffect(this.toEffect(), {
+            onFailure: (cause) => sink.onFailure(cause),
+            onSuccess: () => Effect.provide(this.core.subject.run(sink), this.core.context)
+        });
+    }
+    runUpdates(run, lock = true) {
+        return lock ? this.core.semaphore.withPermits(1)(run(this.getSetDelete)) : run(this.getSetDelete);
+    }
+    onSuccess(value) {
+        return setCore(this.core, value);
+    }
+    onFailure(cause) {
+        return onFailureCore(this.core, cause);
+    }
+    toEffect() {
+        return getOrInitializeCore(this.core, true);
+    }
 }
-export function tagged(defaultEq) {
-    function makeTagged(identifier) {
-        return new ContextImpl(C.Tagged(identifier), defaultEq);
+class DerivedImpl extends RefSubjectImpl {
+    persist;
+    constructor(core, persist) {
+        super(core);
+        this.persist = persist;
     }
-    return makeTagged;
 }
-class ContextImpl extends FxEffectBase {
-    tag;
-    defaultEq;
+/**
+ * @since 1.20.0
+ */
+export const set = dual(2, function set(ref, a) {
+    return ref.runUpdates((ref) => ref.set(a));
+});
+/**
+ * @since 1.20.0
+ */
+export function reset(ref) {
+    return ref.runUpdates((ref) => ref.delete);
+}
+/**
+ * @since 1.20.0
+ */
+export { 
+/**
+ * @since 1.20.0
+ */
+reset as delete };
+function getSetDelete(ref) {
+    return {
+        get: getOrInitializeCore(ref, false),
+        set: (a) => setCore(ref, a),
+        delete: deleteCore(ref)
+    };
+}
+/**
+ * @since 1.20.0
+ */
+export const updateEffect = dual(2, function updateEffect(ref, f) {
+    return ref.runUpdates((ref) => Effect.flatMap(Effect.flatMap(ref.get, f), ref.set));
+});
+/**
+ * @since 1.20.0
+ */
+export const update = dual(2, function update(ref, f) {
+    return updateEffect(ref, (value) => Effect.succeed(f(value)));
+});
+/**
+ * @since 1.20.0
+ */
+export const modifyEffect = dual(2, function modifyEffect(ref, f) {
+    return ref.runUpdates((ref) => Effect.flatMap(ref.get, (value) => Effect.flatMap(f(value), ([b, a]) => Effect.flatMap(ref.set(a), () => Effect.succeed(b)))));
+});
+/**
+ * @since 1.20.0
+ */
+export const modify = dual(2, function modify(ref, f) {
+    return modifyEffect(ref, (value) => Effect.succeed(f(value)));
+});
+const isRefSubjectDataFirst = (args) => isRefSubject(args[0]);
+/**
+ * @since 1.20.0
+ */
+export const runUpdates = dual(isRefSubjectDataFirst, function runUpdates(ref, f, options) {
+    if (!options) {
+        return ref.runUpdates(f);
+    }
+    else if (options.value === "initial") {
+        return ref.runUpdates((ref) => Effect.uninterruptibleMask((restore) => Effect.flatMap(ref.get, (initial) => f(ref).pipe(restore, Effect.tapErrorCause(Effect.unifiedFn((cause) => Cause.isInterruptedOnly(cause)
+            ? options.onInterrupt(initial)
+            : Effect.unit))))));
+    }
+    else {
+        return ref.runUpdates((ref) => Effect.uninterruptibleMask((restore) => f(ref).pipe(restore, Effect.tapErrorCause(Effect.unifiedFn((cause) => Cause.isInterruptedOnly(cause)
+            ? Effect.flatMap(ref.get, options.onInterrupt)
+            : Effect.unit)))));
+    }
+});
+class RefSubjectCore {
+    initial;
+    subject;
+    context;
+    scope;
+    deferredRef;
+    semaphore;
+    constructor(initial, subject, context, scope, deferredRef, semaphore) {
+        this.initial = initial;
+        this.subject = subject;
+        this.context = context;
+        this.scope = scope;
+        this.deferredRef = deferredRef;
+        this.semaphore = semaphore;
+    }
+    _fiber = undefined;
+}
+function makeCore(initial, options) {
+    return Effect.context().pipe(Effect.bindTo("ctx"), Effect.let("executionStrategy", () => options?.executionStrategy ?? ExecutionStrategy.parallel), Effect.bind("scope", ({ ctx, executionStrategy }) => Scope.fork(C.get(ctx, Scope.Scope), executionStrategy)), Effect.bind("deferredRef", () => DeferredRef.make(getExitEquivalence(options?.eq ?? Equal.equals))), Effect.let("subject", () => Subject.unsafeMake(Math.max(1, options?.replay ?? 1))), Effect.tap(({ scope, subject }) => Scope.addFinalizer(scope, subject.interrupt)), Effect.map(({ ctx, deferredRef, scope, subject }) => new RefSubjectCore(initial, subject, ctx, scope, deferredRef, Effect.unsafeMakeSemaphore(1))));
+}
+function unsafeMakeCore(initial, id, ctx, scope, options) {
+    return new RefSubjectCore(initial, Subject.unsafeMake(Math.max(1, options?.replay ?? 1)), ctx, scope, DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? Equal.equals)), Effect.unsafeMakeSemaphore(1));
+}
+function getOrInitializeCore(core, lockInitialize) {
+    return Effect.suspend(() => {
+        if (core._fiber === undefined && Option.isNone(core.deferredRef.current)) {
+            return initializeCoreAndTap(core, lockInitialize);
+        }
+        else {
+            return core.deferredRef;
+        }
+    });
+}
+function initializeCoreEffect(core, lock) {
+    const initialize = Effect.onExit(Effect.provide(core.initial, core.context), (exit) => {
+        core._fiber = undefined;
+        core.deferredRef.done(exit);
+        return Effect.unit;
+    });
+    return Effect.flatMap(Effect.forkIn(lock && core.semaphore ? core.semaphore.withPermits(1)(initialize) : initialize, core.scope), (fiber) => Effect.sync(() => core._fiber = fiber));
+}
+function initializeCore(core, lock) {
+    const onSuccess = (a) => {
+        core.deferredRef.done(Exit.succeed(a));
+        return Effect.succeed(Fiber.succeed(a));
+    };
+    const onCause = (cause) => {
+        core.deferredRef.done(Exit.failCause(cause));
+        return Effect.succeed(Fiber.failCause(cause));
+    };
+    const onError = (e) => onCause(Cause.fail(e));
+    return matchEffectPrimitive(core.initial, {
+        Success: onSuccess,
+        Failure: onCause,
+        Some: onSuccess,
+        None: onError,
+        Left: onError,
+        Right: onSuccess,
+        Sync: (f) => onSuccess(f()),
+        Otherwise: () => initializeCoreEffect(core, lock)
+    });
+}
+function initializeCoreAndTap(core, lock) {
+    return Effect.zipRight(initializeCore(core, lock), tapEventCore(core, core.deferredRef));
+}
+function setCore(core, a) {
+    const exit = Exit.succeed(a);
+    return Effect.suspend(() => {
+        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.unit;
+        }
+    });
+}
+function interruptCore(core) {
+    return Effect.fiberIdWith((id) => {
+        core.deferredRef.reset();
+        return Scope.close(core.scope, Exit.interrupt(id));
+    });
+}
+function deleteCore(core) {
+    return Effect.suspend(() => {
+        const current = core.deferredRef.current;
+        core.deferredRef.reset();
+        if (Option.isNone(current)) {
+            return Effect.succeed(Option.none());
+        }
+        return core.subject.subscriberCount.pipe(Effect.provide(core.context), Effect.flatMap((count) => count > 0 && !core._fiber ? initializeCore(core, false) : Effect.unit), Effect.zipRight(Effect.asSome(current.value)));
+    });
+}
+function tapEventCore(core, effect) {
+    return effect.pipe(Effect.exit, Effect.tap((exit) => sendEvent(core, exit)), Effect.flatten);
+}
+function sendEvent(core, exit) {
+    if (Exit.isSuccess(exit)) {
+        return Effect.provide(core.subject.onSuccess(exit.value), core.context);
+    }
+    else {
+        return Effect.provide(core.subject.onFailure(exit.cause), core.context);
+    }
+}
+/**
+ * @since 1.20.0
+ */
+export const mapEffect = dual(2, function mapEffect(versioned, f) {
+    return FilteredTypeId in versioned
+        ? FilteredImpl.make(versioned, (a) => Effect.asSome(f(a)))
+        : ComputedImpl.make(versioned, f);
+});
+/**
+ * @since 1.20.0
+ */
+export const map = dual(2, function map(versioned, f) {
+    return mapEffect(versioned, (a) => Effect.succeed(f(a)));
+});
+/**
+ * @since 1.20.0
+ */
+export const filterMapEffect = dual(2, function filterMapEffect(versioned, f) {
+    return FilteredImpl.make(versioned, f);
+});
+/**
+ * @since 1.20.0
+ */
+export const filterMap = dual(2, function filterMap(versioned, f) {
+    return FilteredImpl.make(versioned, (a) => Effect.succeed(f(a)));
+});
+/**
+ * @since 1.20.0
+ */
+export const compact = (versioned) => filterMap(versioned, identity);
+/**
+ * @since 1.20.0
+ */
+export const filterEffect = dual(2, function filterEffect(versioned, f) {
+    return FilteredImpl.make(versioned, (a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()));
+});
+/**
+ * @since 1.20.0
+ */
+export const filter = dual(2, function filter(versioned, f) {
+    return FilteredImpl.make(versioned, (a) => Effect.succeed(f(a) ? Option.some(a) : Option.none()));
+});
+class ComputedImpl extends Versioned.VersionedTransform {
+    input;
+    f;
+    [ComputedTypeId] = ComputedTypeId;
+    constructor(input, f) {
+        super(input, (fx) => share.hold(core.mapEffect(fx, f)), Effect.flatMap(f));
+        this.input = input;
+        this.f = f;
+    }
+    static make(input, f) {
+        return new ComputedImpl(input, f);
+    }
+}
+class FilteredImpl extends Versioned.VersionedTransform {
+    input;
+    f;
+    [FilteredTypeId] = FilteredTypeId;
+    constructor(input, f) {
+        super(input, (fx) => share.hold(core.filterMapEffect(fx, f)), (effect) => Effect.flatten(Effect.flatMap(effect, f)));
+        this.input = input;
+        this.f = f;
+    }
+    static make(input, f) {
+        return new FilteredImpl(input, f);
+    }
+    asComputed() {
+        return ComputedImpl.make(this.input, this.f);
+    }
+}
+/**
+ * @since 1.20.0
+ */
+export const skipRepeatsWith = dual(2, function skipRepeatsWith(ref, eq) {
+    const versioned = Versioned.transform(ref, (fx) => core.skipRepeatsWith(fx, eq), identity);
+    if (FilteredTypeId in ref) {
+        return FilteredImpl.make(versioned, Effect.succeedSome);
+    }
+    else {
+        return ComputedImpl.make(versioned, Effect.succeed);
+    }
+});
+export function skipRepeats(ref) {
+    return skipRepeatsWith(ref, Equal.equals);
+}
+/**
+ * @since 1.20.0
+ */
+export function transform(ref, from, to) {
+    return new RefSubjectTransform(ref, from, to);
+}
+/**
+ * @since 1.20.0
+ */
+export function transformOrFail(ref, from, to) {
+    return new RefSubjectTransformEffect(ref, from, to);
+}
+class RefSubjectTransform extends FxEffectBase {
+    ref;
+    from;
+    to;
+    [ComputedTypeId] = ComputedTypeId;
     [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    constructor(ref, from, to) {
+        super();
+        this.ref = ref;
+        this.from = from;
+        this.to = to;
+        this.version = ref.version;
+        this.interrupt = ref.interrupt;
+        this.subscriberCount = ref.subscriberCount;
+    }
+    run(sink) {
+        return this.ref.run(Sink.map(sink, this.from));
+    }
+    runUpdates(run) {
+        return this.ref.runUpdates((ref) => run({
+            get: Effect.map(ref.get, this.from),
+            set: (b) => Effect.map(ref.set(this.to(b)), this.from),
+            delete: Effect.map(ref.delete, Option.map(this.from))
+        }));
+    }
+    onFailure(cause) {
+        return this.ref.onFailure(cause);
+    }
+    onSuccess(value) {
+        return this.ref.onSuccess(this.to(value));
+    }
+    toEffect() {
+        return Effect.map(this.ref, this.from);
+    }
+}
+class RefSubjectTransformEffect extends FxEffectBase {
+    ref;
+    from;
+    to;
     [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
     version;
+    interrupt;
     subscriberCount;
-    get;
-    delete;
+    subject;
+    constructor(ref, from, to) {
+        super();
+        this.ref = ref;
+        this.from = from;
+        this.to = to;
+        this.version = ref.version;
+        this.interrupt = ref.interrupt;
+        this.subscriberCount = ref.subscriberCount;
+        this.subject = Subject.unsafeMake();
+    }
+    run(sink) {
+        return core.merge(core.mapEffect(this.ref, this.from), this.subject).run(sink);
+    }
+    runUpdates(run) {
+        return this.ref.runUpdates((ref) => run({
+            get: Effect.flatMap(ref.get, this.from),
+            set: (b) => Effect.matchCauseEffect(Effect.flatMap(this.to(b), ref.set), {
+                onFailure: (cause) => Effect.as(this.subject.onFailure(cause), b),
+                onSuccess: () => Effect.as(this.subject.onSuccess(b), b)
+            }),
+            delete: Effect.flatMap(ref.delete, Option.match({
+                onNone: () => Effect.succeedNone,
+                onSome: (b) => Effect.asSome(this.from(b))
+            }))
+        }));
+    }
+    onFailure(cause) {
+        return this.subject.onFailure(cause);
+    }
+    onSuccess(value) {
+        return Effect.matchCauseEffect(this.to(value), {
+            onFailure: (cause) => this.subject.onFailure(cause),
+            onSuccess: (a) => this.ref.onSuccess(a)
+        });
+    }
+    toEffect() {
+        return Effect.flatMap(this.ref, this.from);
+    }
+}
+/**
+ * @since 1.20.0
+ */
+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);
+    }
+}
+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;
+}
+function makeTupleRef(refs) {
+    return new RefSubjectTuple(refs);
+}
+class RefSubjectTuple extends FxEffectBase {
+    refs;
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    versioned;
+    getSetDelete;
+    constructor(refs) {
+        super();
+        this.refs = refs;
+        this.versioned = 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), ReadonlyArray.reduce(0, sum));
+        this.getSetDelete = {
+            get: this.versioned,
+            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.runUpdates = this.runUpdates.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;
+    }
+    runUpdates(run) {
+        return run(this.getSetDelete);
+    }
+    onFailure(cause) {
+        return Effect.all(this.refs.map((ref) => ref.onFailure(cause)));
+    }
+    onSuccess(value) {
+        return Effect.catchAllCause(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);
+}
+/**
+ * @since 1.20.0
+ */
+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);
+    }
+}
+function makeStructRef(refs) {
+    return new RefSubjectStruct(refs);
+}
+class RefSubjectStruct extends FxEffectBase {
+    refs;
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
     interrupt;
-    constructor(tag, defaultEq) {
+    subscriberCount;
+    versioned;
+    getSetDelete;
+    constructor(refs) {
+        super();
+        this.refs = refs;
+        this.versioned = 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), ReadonlyArray.reduce(0, sum));
+        this.getSetDelete = {
+            get: this.versioned,
+            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.runUpdates = this.runUpdates.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;
+    }
+    runUpdates(run) {
+        return run(this.getSetDelete);
+    }
+    onFailure(cause) {
+        return Effect.all(Object.values(this.refs).map((ref) => ref.onFailure(cause)));
+    }
+    onSuccess(value) {
+        return Effect.catchAllCause(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);
+}
+/**
+ * @since 1.20.0
+ */
+export function tagged(replay) {
+    return (identifier) => new RefSubjectTagged(C.Tagged(identifier), replay);
+}
+class RefSubjectTagged extends FxEffectBase {
+    tag;
+    replay;
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    constructor(tag, replay = 0) {
         super();
         this.tag = tag;
-        this.defaultEq = defaultEq;
+        this.replay = replay;
         this.version = tag.withEffect((ref) => ref.version);
+        this.interrupt = tag.withEffect((ref) => ref.interrupt);
         this.subscriberCount = tag.withEffect((ref) => ref.subscriberCount);
-        this.get = tag.withEffect((ref) => ref.get);
-        this.delete = tag.withEffect((ref) => ref.delete);
-        this.interrupt = tag.withEffect((r) => r.interrupt);
+        this.runUpdates = this.runUpdates.bind(this);
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
     }
-    toFx() {
-        return fromFxEffect(this.tag);
+    run(sink) {
+        return this.tag.withEffect((ref) => ref.run(sink));
     }
     toEffect() {
-        return this.get;
-    }
-    runUpdate = (f, onInterrupt) => this.tag.withEffect((ref) => ref.runUpdate(f, onInterrupt));
-    modifyEffect = (f) => this.tag.withEffect((ref) => ref.modifyEffect(f));
-    modify = (f) => this.tag.withEffect((ref) => ref.modify(f));
-    updateEffect = (f) => this.tag.withEffect((ref) => ref.updateEffect(f));
-    update = (f) => this.tag.withEffect((ref) => ref.update(f));
-    set = (a) => this.tag.withEffect((ref) => ref.set(a));
-    mapEffect = (f) => Computed(this, f);
-    map = (f) => Computed(this, (a) => Effect.sync(() => f(a)));
-    filterMapEffect = (f) => Filtered(this, f);
-    filterMap = (f) => Filtered(this, (a) => Effect.sync(() => f(a)));
-    filter = (f) => this.filterMap((a) => f(a) ? Option.some(a) : Option.none());
-    filterEffect = (f) => this.filterMapEffect((a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()));
-    skipRepeats = (eq = equals) => fromTag(this.tag, (s) => s.skipRepeats(eq));
-    onFailure = (cause) => this.tag.withEffect((ref) => ref.onFailure(cause));
-    onSuccess = (a) => this.tag.withEffect((ref) => ref.onSuccess(a));
-    make = (fx, eq) => this.tag.scoped(make(fx, eq || this.defaultEq));
-    of = (value, eq) => this.tag.scoped(of(value, eq));
-    provide = (fx, eq) => Effect.provide(this.make(fx, eq || this.defaultEq));
-    provideFx = (fx, eq) => provide(this.make(fx, eq || this.defaultEq));
-}
-export function makeWithExtension(fx, f, eq) {
-    return coreRefSubject.makeWithExtension(fx, f, eq);
-}
-/**
- * Construct a RefSubject with an initial value and the specified subject.
- * @since 1.18.0
- * @category constructors
+        return this.tag.withEffect((ref) => ref);
+    }
+    runUpdates(run) {
+        return this.tag.withEffect((ref) => ref.runUpdates(run));
+    }
+    onFailure(cause) {
+        return this.tag.withEffect((ref) => ref.onFailure(cause));
+    }
+    onSuccess(value) {
+        return this.tag.withEffect((ref) => ref.onSuccess(value));
+    }
+    make = (fxOrEffect) => this.tag.scoped(make(fxOrEffect));
+}
+/**
+ * @since 1.20.0
  */
-export const unsafeMake = coreRefSubject.unsafeMake;
+export function fromTag(tag, f) {
+    return new RefSubjectFromTag(tag, f);
+}
+class RefSubjectFromTag extends FxEffectBase {
+    tag;
+    f;
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    version;
+    interrupt;
+    subscriberCount;
+    _get;
+    _fx;
+    constructor(tag, f) {
+        super();
+        this.tag = tag;
+        this.f = f;
+        this._get = Effect.map(tag, f);
+        this._fx = core.fromFxEffect(this._get);
+        this.version = Effect.flatMap(this._get, (ref) => ref.version);
+        this.interrupt = Effect.flatMap(this._get, (ref) => ref.interrupt);
+        this.subscriberCount = Effect.flatMap(this._get, (ref) => ref.subscriberCount);
+    }
+    run(sink) {
+        return this._fx.run(sink);
+    }
+    toEffect() {
+        return Effect.flatten(this._get);
+    }
+    runUpdates(run) {
+        return Effect.flatMap(this._get, (ref) => ref.runUpdates(run));
+    }
+    onFailure(cause) {
+        return Effect.flatMap(this._get, (ref) => ref.onFailure(cause));
+    }
+    onSuccess(value) {
+        return Effect.flatMap(this._get, (ref) => ref.onSuccess(value));
+    }
+}
+export function isRefSubject(u) {
+    return isObjectLike(u) && RefSubjectTypeId in u;
+}
+export function isComputed(u) {
+    return isObjectLike(u) && ComputedTypeId in u;
+}
+export function isFiltered(u) {
+    return isObjectLike(u) && FilteredTypeId in u;
+}
+export function isDerived(u) {
+    return isRefSubject(u) && "persist" in u;
+}
+function isObjectLike(u) {
+    if (u == null)
+        return false;
+    const type = typeof u;
+    return (type === "object" && !Array.isArray(u)) || type === "function";
+}
 /**
- * Flatten an RefSubject of an Option into a Filtered.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const compact = (refSubject) => refSubject.filterMap(identity);
+export function computedFromTag(tag, f) {
+    return new ComputedFromTag(tag, f);
+}
+class ComputedFromTag extends FxEffectBase {
+    tag;
+    f;
+    [ComputedTypeId] = ComputedTypeId;
+    version;
+    _get;
+    constructor(tag, f) {
+        super();
+        this.tag = tag;
+        this.f = f;
+        this._get = Effect.map(tag, f);
+        this.version = Effect.flatMap(this._get, (ref) => ref.version);
+    }
+    run(sink) {
+        return Effect.flatMap(this._get, (ref) => ref.run(sink));
+    }
+    toEffect() {
+        return Effect.flatten(this._get);
+    }
+}
 /**
- * Split a RefSubject's into 2 Filtered values that track its errors and
- * success values separately.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const split = (refSubject) => {
-    const versioned = Versioned.transform(refSubject, exit, Effect.exit);
-    const left = Filtered(versioned, getLeft);
-    const right = Filtered(versioned, getRight);
-    return [left, right];
-};
-const getLeft = (exit) => Effect.succeed(Exit.match(exit, {
-    onFailure: (cause) => Cause.failureOption(cause),
-    onSuccess: () => Option.none()
-}));
-const getRight = (exit) => Effect.succeed(Exit.match(exit, {
-    onFailure: Option.none,
-    onSuccess: Option.some
-}));
-/**
- * Derive a RefSubjectSchema using the "from" or "encoded" value represented by a Schema.
- * @since 1.18.0
+export function filteredFromTag(tag, f) {
+    return new FilteredFromTag(tag, f);
+}
+class FilteredFromTag extends FxEffectBase {
+    tag;
+    f;
+    [FilteredTypeId] = FilteredTypeId;
+    version;
+    _get;
+    constructor(tag, f) {
+        super();
+        this.tag = tag;
+        this.f = f;
+        this._get = Effect.map(tag, f);
+        this.version = Effect.flatMap(this._get, (ref) => ref.version);
+    }
+    run(sink) {
+        return Effect.flatMap(this._get, (ref) => ref.run(sink));
+    }
+    toEffect() {
+        return Effect.flatten(this._get);
+    }
+    asComputed() {
+        return new ComputedFromTag(this.tag, (s) => this.f(s).asComputed());
+    }
+}
+/**
+ * @since 1.20.0
  */
-export function deriveFromSchema(schema) {
-    return fromRefSubject(schema);
+export const provide = dual(2, function provide(ref, providing) {
+    const layer = Layer.isLayer(providing)
+        ? providing
+        : C.isContext(providing)
+            ? Layer.succeedContext(providing)
+            : runtimeToLayer(providing);
+    if (isComputed(ref)) {
+        return ComputedImpl.make(Versioned.provide(ref, layer), Effect.succeed);
+    }
+    else if (isFiltered(ref)) {
+        return FilteredImpl.make(Versioned.provide(ref, layer), Effect.succeedSome);
+    }
+    else {
+        return new RefSubjectProvide(ref, layer);
+    }
+});
+class RefSubjectProvide extends FxEffectBase {
+    ref;
+    layer;
+    [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
+    interrupt;
+    subscriberCount;
+    constructor(ref, layer) {
+        super();
+        this.ref = ref;
+        this.layer = layer;
+        this.interrupt = Effect.provide(ref.interrupt, layer);
+        this.subscriberCount = Effect.provide(ref.subscriberCount, layer);
+    }
+    run(sink) {
+        return Effect.provide(this.ref.run(sink), this.layer);
+    }
+    toEffect() {
+        return Effect.provide(this.ref, this.layer);
+    }
 }
 /**
- * Derive a RefSubjectSchema using the "to" or "decoded" value represented by a Schema.
+ * Set the value to true
  * @since 1.18.0
  */
-export function deriveToSchema(schema) {
-    return toRefSubject(schema);
-}
+export const asTrue = (ref) => set(ref, true);
 /**
+ * Set the value to false
  * @since 1.18.0
  */
-export const tuple = coreRefSubject.tuple;
+export const asFalse = (ref) => set(ref, false);
 /**
+ * Toggle the boolean value between true and false
  * @since 1.18.0
  */
-export const struct = coreRefSubject.struct;
+export const toggle = (ref) => update(ref, Boolean.not);
+const add = (x) => x + 1;
 /**
+ * Set the value to true
  * @since 1.18.0
  */
-export function fromSubscriptionRef(subscriptionRef) {
-    return coreRefSubject.make(fromStream(subscriptionRef.changes));
-}
+export const increment = (ref) => update(ref, add);
+const sub = (x) => x - 1;
 /**
+ * Set the value to false
  * @since 1.18.0
  */
-export const transform = dual(3, function transform(ref, from, to) {
-    return new TransformImpl(ref, from, to);
+export const decrement = (ref) => update(ref, sub);
+/**
+ * @since 1.20.0
+ */
+export const slice = dual(3, function slice(ref, drop, take) {
+    return new RefSubjectSlice(ref, drop, take);
+});
+/**
+ * @since 1.20.0
+ */
+export const drop = dual(2, function drop(ref, drop) {
+    return slice(ref, drop, Infinity);
 });
-class TransformImpl extends FxEffectBase {
+/**
+ * @since 1.20.0
+ */
+export const take = dual(2, function take(ref, take) {
+    return slice(ref, 0, take);
+});
+class RefSubjectSlice extends FxEffectBase {
     ref;
-    from;
-    to;
-    [RefSubjectTypeId] = RefSubjectTypeId;
+    drop;
+    take;
     [ComputedTypeId] = ComputedTypeId;
+    [RefSubjectTypeId] = RefSubjectTypeId;
     version;
-    subscriberCount;
-    get;
-    delete;
     interrupt;
-    constructor(ref, from, to) {
+    subscriberCount;
+    _fx;
+    constructor(ref, drop, take) {
         super();
         this.ref = ref;
-        this.from = from;
-        this.to = to;
+        this.drop = drop;
+        this.take = take;
         this.version = ref.version;
-        this.subscriberCount = ref.subscriberCount;
-        this.get = Effect.map(ref.get, from);
-        this.delete = Effect.map(ref.delete, Option.map(from));
         this.interrupt = ref.interrupt;
+        this.subscriberCount = ref.subscriberCount;
+        this._fx = share.hold(core.slice(ref, drop, take));
+        this._effect = ref;
     }
-    toFx() {
-        return this.ref.map(this.from);
+    run(sink) {
+        return this._fx.run(sink);
     }
     toEffect() {
-        return this.ref.map(this.from);
-    }
-    set = (b) => Effect.map(this.ref.set(this.to(b)), this.from);
-    update = (f) => Effect.map(this.ref.update((a) => this.to(f(this.from(a)))), this.from);
-    updateEffect = (f) => Effect.map(this.ref.updateEffect((a) => Effect.map(f(this.from(a)), this.to)), this.from);
-    modifyEffect = (f) => this.ref.modifyEffect((a) => Effect.map(f(this.from(a)), ([c, b]) => [c, this.to(b)]));
-    modify = (f) => this.ref.modify((a) => {
-        const [c, b] = f(this.from(a));
-        return [c, this.to(b)];
-    });
-    runUpdate = (f) => this.ref.runUpdate((get, set) => f(Effect.map(get, this.from), (b) => Effect.map(set(this.to(b)), this.from)));
-    mapEffect = (f) => Computed(this, f);
-    map = (f) => this.mapEffect((b) => Effect.sync(() => f(b)));
-    filterMapEffect = (f) => Filtered(this, f);
-    filterMap = (f) => Filtered(this, (a) => Effect.sync(() => f(a)));
-    filter = (f) => this.filterMap((a) => f(a) ? Option.some(a) : Option.none());
-    filterEffect = (f) => this.filterMapEffect((a) => Effect.map(f(a), (b) => b ? Option.some(a) : Option.none()));
-    onSuccess = (b) => this.ref.onSuccess(this.to(b));
-    onFailure = (b) => this.ref.onFailure(b);
-    skipRepeats = (eq = equals) => Computed(Versioned.transformFx(this, skipRepeatsWith(eq)), Effect.succeed);
+        return this.ref;
+    }
+    runUpdates(run) {
+        return this.ref.runUpdates(run);
+    }
+    onFailure(cause) {
+        return this.ref.onFailure(cause);
+    }
+    onSuccess(value) {
+        return this.ref.onSuccess(value);
+    }
 }
 //# sourceMappingURL=RefSubject.js.map