@typed/fx 1.18.4 → 1.20.0

package/dist/cjs/RefSubject.js

@@ -3,237 +3,978 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.compact = void 0;
-exports.deriveFromSchema = deriveFromSchema;
-exports.deriveToSchema = deriveToSchema;
+exports.compact = exports.asTrue = exports.asFalse = void 0;
+exports.computedFromTag = computedFromTag;
+exports.filterMapEffect = exports.filterMap = exports.filterEffect = exports.filter = exports.drop = exports.decrement = void 0;
+exports.filteredFromTag = filteredFromTag;
 exports.fromEffect = fromEffect;
-exports.fromSubscriptionRef = fromSubscriptionRef;
-exports.make = make;
-exports.makeWithExtension = makeWithExtension;
+exports.fromFx = fromFx;
+exports.fromRefSubject = fromRefSubject;
+exports.fromTag = fromTag;
+exports.increment = void 0;
+exports.isComputed = isComputed;
+exports.isDerived = isDerived;
+exports.isFiltered = isFiltered;
+exports.isRefSubject = isRefSubject;
+exports.modifyEffect = exports.modify = exports.mapEffect = exports.map = exports.make = void 0;
 exports.of = of;
-exports.struct = exports.split = void 0;
-exports.sync = sync;
+exports.provide = void 0;
+exports.delete = exports.reset = reset;
+exports.set = exports.runUpdates = void 0;
+exports.skipRepeats = skipRepeats;
+exports.slice = exports.skipRepeatsWith = void 0;
+exports.struct = struct;
 exports.tagged = tagged;
-exports.unsafeMake = exports.tuple = exports.transform = void 0;
+exports.toggle = exports.take = void 0;
+exports.transform = transform;
+exports.transformOrFail = transformOrFail;
+exports.tuple = tuple;
+exports.unsafeMake = unsafeMake;
+exports.updateEffect = exports.update = void 0;
 var C = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@typed/context"));
 var _effect = /*#__PURE__*/require("effect");
+var Boolean = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Boolean"));
+var Cause = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Cause"));
 var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
-var _Equal = /*#__PURE__*/require("effect/Equal");
+var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Equal"));
+var ExecutionStrategy = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/ExecutionStrategy"));
+var Exit = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Exit"));
 var _Function = /*#__PURE__*/require("effect/Function");
+var Layer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Layer"));
+var _Number = /*#__PURE__*/require("effect/Number");
 var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Option"));
-var _Computed = /*#__PURE__*/require("./Computed.js");
-var _Filtered = /*#__PURE__*/require("./Filtered.js");
-var coreRefSubject = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/core-ref-subject.js"));
-var _core = /*#__PURE__*/require("./internal/core.js");
-var _fx = /*#__PURE__*/require("./internal/fx.js");
+var ReadonlyArray = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/ReadonlyArray"));
+var Scope = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Scope"));
+var core = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/core.js"));
+var DeferredRef = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/DeferredRef.js"));
+var _helpers = /*#__PURE__*/require("./internal/helpers.js");
 var _protos = /*#__PURE__*/require("./internal/protos.js");
-var _schemaRefSubject = /*#__PURE__*/require("./internal/schema-ref-subject.js");
+var _provide = /*#__PURE__*/require("./internal/provide.js");
+var share = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/share.js"));
+var Sink = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Sink.js"));
+var Subject = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Subject.js"));
 var _TypeId = /*#__PURE__*/require("./TypeId.js");
 var Versioned = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Versioned.js"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
- * 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
  */
 
+const UNBOUNDED = {
+  concurrency: "unbounded"
+};
 /**
- * Construct a RefSubject with a lazily initialized value.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-function fromEffect(initial, eq) {
-  return coreRefSubject.fromEffect(initial, eq);
+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
  */
-function of(initial, eq) {
-  return fromEffect(Effect.succeed(initial), eq);
+function fromFx(fx, options) {
+  return DeferredRef.make((0, _helpers.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
+ */
+function fromRefSubject(ref, options) {
+  return DeferredRef.make((0, _helpers.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
+ */
+const make = exports.make = function make(fxOrEffect, options) {
+  if (_TypeId.RefSubjectTypeId in fxOrEffect) return fromRefSubject(fxOrEffect, options);else if (_TypeId.TypeId in fxOrEffect) return fromFx(fxOrEffect, options);else return fromEffect(fxOrEffect, options);
+};
+/**
+ * @since 1.20.0
  */
-function sync(initial, eq) {
-  return fromEffect(Effect.sync(initial), eq);
+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);
 }
-function make(fx, eq) {
-  return coreRefSubject.make(fx, eq);
+const withScopeAndFiberId = (f, strategy) => Effect.fiberIdWith(id => (0, _helpers.withScope)(scope => f(scope, id), strategy));
+const emptyContext = /*#__PURE__*/C.empty();
+/**
+ * @since 1.20.0
+ */
+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));
+  });
 }
-function tagged(defaultEq) {
-  function makeTagged(identifier) {
-    return new ContextImpl(C.Tagged(identifier), defaultEq);
+class RefSubjectImpl extends _protos.FxEffectBase {
+  core;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.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);
   }
-  return makeTagged;
 }
-class ContextImpl extends _protos.FxEffectBase {
-  tag;
-  defaultEq;
+class DerivedImpl extends RefSubjectImpl {
+  persist;
+  constructor(core, persist) {
+    super(core);
+    this.persist = persist;
+  }
+}
+/**
+ * @since 1.20.0
+ */
+const set = exports.set = /*#__PURE__*/(0, _Function.dual)(2, function set(ref, a) {
+  return ref.runUpdates(ref => ref.set(a));
+});
+/**
+ * @since 1.20.0
+ */
+function reset(ref) {
+  return ref.runUpdates(ref => ref.delete);
+}
+/**
+ * @since 1.20.0
+ */
+
+function getSetDelete(ref) {
+  return {
+    get: getOrInitializeCore(ref, false),
+    set: a => setCore(ref, a),
+    delete: deleteCore(ref)
+  };
+}
+/**
+ * @since 1.20.0
+ */
+const updateEffect = exports.updateEffect = /*#__PURE__*/(0, _Function.dual)(2, function updateEffect(ref, f) {
+  return ref.runUpdates(ref => Effect.flatMap(Effect.flatMap(ref.get, f), ref.set));
+});
+/**
+ * @since 1.20.0
+ */
+const update = exports.update = /*#__PURE__*/(0, _Function.dual)(2, function update(ref, f) {
+  return updateEffect(ref, value => Effect.succeed(f(value)));
+});
+/**
+ * @since 1.20.0
+ */
+const modifyEffect = exports.modifyEffect = /*#__PURE__*/(0, _Function.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
+ */
+const modify = exports.modify = /*#__PURE__*/(0, _Function.dual)(2, function modify(ref, f) {
+  return modifyEffect(ref, value => Effect.succeed(f(value)));
+});
+const isRefSubjectDataFirst = args => isRefSubject(args[0]);
+/**
+ * @since 1.20.0
+ */
+const runUpdates = exports.runUpdates = /*#__PURE__*/(0, _Function.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((0, _helpers.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, (0, _helpers.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(_effect.Fiber.succeed(a));
+  };
+  const onCause = cause => {
+    core.deferredRef.done(Exit.failCause(cause));
+    return Effect.succeed(_effect.Fiber.failCause(cause));
+  };
+  const onError = e => onCause(Cause.fail(e));
+  return (0, _helpers.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
+ */
+const mapEffect = exports.mapEffect = /*#__PURE__*/(0, _Function.dual)(2, function mapEffect(versioned, f) {
+  return _TypeId.FilteredTypeId in versioned ? FilteredImpl.make(versioned, a => Effect.asSome(f(a))) : ComputedImpl.make(versioned, f);
+});
+/**
+ * @since 1.20.0
+ */
+const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, function map(versioned, f) {
+  return mapEffect(versioned, a => Effect.succeed(f(a)));
+});
+/**
+ * @since 1.20.0
+ */
+const filterMapEffect = exports.filterMapEffect = /*#__PURE__*/(0, _Function.dual)(2, function filterMapEffect(versioned, f) {
+  return FilteredImpl.make(versioned, f);
+});
+/**
+ * @since 1.20.0
+ */
+const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, function filterMap(versioned, f) {
+  return FilteredImpl.make(versioned, a => Effect.succeed(f(a)));
+});
+/**
+ * @since 1.20.0
+ */
+const compact = versioned => filterMap(versioned, _Function.identity);
+/**
+ * @since 1.20.0
+ */
+exports.compact = compact;
+const filterEffect = exports.filterEffect = /*#__PURE__*/(0, _Function.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
+ */
+const filter = exports.filter = /*#__PURE__*/(0, _Function.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;
+  [_TypeId.ComputedTypeId] = _TypeId.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;
+  [_TypeId.FilteredTypeId] = _TypeId.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
+ */
+const skipRepeatsWith = exports.skipRepeatsWith = /*#__PURE__*/(0, _Function.dual)(2, function skipRepeatsWith(ref, eq) {
+  const versioned = Versioned.transform(ref, fx => core.skipRepeatsWith(fx, eq), _Function.identity);
+  if (_TypeId.FilteredTypeId in ref) {
+    return FilteredImpl.make(versioned, Effect.succeedSome);
+  } else {
+    return ComputedImpl.make(versioned, Effect.succeed);
+  }
+});
+function skipRepeats(ref) {
+  return skipRepeatsWith(ref, Equal.equals);
+}
+/**
+ * @since 1.20.0
+ */
+function transform(ref, from, to) {
+  return new RefSubjectTransform(ref, from, to);
+}
+/**
+ * @since 1.20.0
+ */
+function transformOrFail(ref, from, to) {
+  return new RefSubjectTransformEffect(ref, from, to);
+}
+class RefSubjectTransform extends _protos.FxEffectBase {
+  ref;
+  from;
+  to;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
   [_TypeId.RefSubjectTypeId] = _TypeId.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 _protos.FxEffectBase {
+  ref;
+  from;
+  to;
   [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.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
+ */
+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 (_TypeId.FilteredTypeId in ref) {
+      kind = "f";
+      break;
+    } else if (!(_TypeId.RefSubjectTypeId in ref)) {
+      kind = join(kind, "c");
+    }
+  }
+  return kind;
+}
+function makeTupleRef(refs) {
+  return new RefSubjectTuple(refs);
+}
+class RefSubjectTuple extends _protos.FxEffectBase {
+  refs;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.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, _Number.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
+ */
+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 _protos.FxEffectBase {
+  refs;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.RefSubjectTypeId;
+  version;
+  interrupt;
+  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, _Number.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
+ */
+function tagged(replay) {
+  return identifier => new RefSubjectTagged(C.Tagged(identifier), replay);
+}
+class RefSubjectTagged extends _protos.FxEffectBase {
+  tag;
+  replay;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.RefSubjectTypeId;
+  version;
   interrupt;
-  constructor(tag, defaultEq) {
+  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 (0, _fx.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 => (0, _Computed.Computed)(this, f);
-  map = f => (0, _Computed.Computed)(this, a => Effect.sync(() => f(a)));
-  filterMapEffect = f => (0, _Filtered.Filtered)(this, f);
-  filterMap = f => (0, _Filtered.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 = _Equal.equals) => (0, _Computed.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) => (0, _core.provide)(this.make(fx, eq || this.defaultEq));
-}
-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
  */
-const unsafeMake = exports.unsafeMake = coreRefSubject.unsafeMake;
+function fromTag(tag, f) {
+  return new RefSubjectFromTag(tag, f);
+}
+class RefSubjectFromTag extends _protos.FxEffectBase {
+  tag;
+  f;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.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));
+  }
+}
+function isRefSubject(u) {
+  return isObjectLike(u) && _TypeId.RefSubjectTypeId in u;
+}
+function isComputed(u) {
+  return isObjectLike(u) && _TypeId.ComputedTypeId in u;
+}
+function isFiltered(u) {
+  return isObjectLike(u) && _TypeId.FilteredTypeId in u;
+}
+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
  */
-const compact = refSubject => refSubject.filterMap(_effect.identity);
+function computedFromTag(tag, f) {
+  return new ComputedFromTag(tag, f);
+}
+class ComputedFromTag extends _protos.FxEffectBase {
+  tag;
+  f;
+  [_TypeId.ComputedTypeId] = _TypeId.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
  */
-exports.compact = compact;
-const split = refSubject => {
-  const versioned = Versioned.transform(refSubject, _fx.exit, Effect.exit);
-  const left = (0, _Filtered.Filtered)(versioned, getLeft);
-  const right = (0, _Filtered.Filtered)(versioned, getRight);
-  return [left, right];
-};
-exports.split = split;
-const getLeft = exit => Effect.succeed(_effect.Exit.match(exit, {
-  onFailure: cause => _effect.Cause.failureOption(cause),
-  onSuccess: () => Option.none()
-}));
-const getRight = exit => Effect.succeed(_effect.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
+function filteredFromTag(tag, f) {
+  return new FilteredFromTag(tag, f);
+}
+class FilteredFromTag extends _protos.FxEffectBase {
+  tag;
+  f;
+  [_TypeId.FilteredTypeId] = _TypeId.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
  */
-function deriveFromSchema(schema) {
-  return (0, _schemaRefSubject.fromRefSubject)(schema);
+const provide = exports.provide = /*#__PURE__*/(0, _Function.dual)(2, function provide(ref, providing) {
+  const layer = Layer.isLayer(providing) ? providing : C.isContext(providing) ? Layer.succeedContext(providing) : (0, _provide.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 _protos.FxEffectBase {
+  ref;
+  layer;
+  [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.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
  */
-function deriveToSchema(schema) {
-  return (0, _schemaRefSubject.toRefSubject)(schema);
-}
+const asTrue = ref => set(ref, true);
 /**
+ * Set the value to false
  * @since 1.18.0
  */
-const tuple = exports.tuple = coreRefSubject.tuple;
+exports.asTrue = asTrue;
+const asFalse = ref => set(ref, false);
 /**
+ * Toggle the boolean value between true and false
  * @since 1.18.0
  */
-const struct = exports.struct = coreRefSubject.struct;
+exports.asFalse = asFalse;
+const toggle = ref => update(ref, Boolean.not);
+exports.toggle = toggle;
+const add = x => x + 1;
 /**
+ * Set the value to true
  * @since 1.18.0
  */
-function fromSubscriptionRef(subscriptionRef) {
-  return coreRefSubject.make((0, _core.fromStream)(subscriptionRef.changes));
-}
+const increment = ref => update(ref, add);
+exports.increment = increment;
+const sub = x => x - 1;
 /**
+ * Set the value to false
  * @since 1.18.0
  */
-const transform = exports.transform = /*#__PURE__*/(0, _Function.dual)(3, function transform(ref, from, to) {
-  return new TransformImpl(ref, from, to);
+const decrement = ref => update(ref, sub);
+/**
+ * @since 1.20.0
+ */
+exports.decrement = decrement;
+const slice = exports.slice = /*#__PURE__*/(0, _Function.dual)(3, function slice(ref, drop, take) {
+  return new RefSubjectSlice(ref, drop, take);
+});
+/**
+ * @since 1.20.0
+ */
+const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, function drop(ref, drop) {
+  return slice(ref, drop, Infinity);
 });
-class TransformImpl extends _protos.FxEffectBase {
+/**
+ * @since 1.20.0
+ */
+const take = exports.take = /*#__PURE__*/(0, _Function.dual)(2, function take(ref, take) {
+  return slice(ref, 0, take);
+});
+class RefSubjectSlice extends _protos.FxEffectBase {
   ref;
-  from;
-  to;
-  [_TypeId.RefSubjectTypeId] = _TypeId.RefSubjectTypeId;
+  drop;
+  take;
   [_TypeId.ComputedTypeId] = _TypeId.ComputedTypeId;
+  [_TypeId.RefSubjectTypeId] = _TypeId.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 => (0, _Computed.Computed)(this, f);
-  map = f => this.mapEffect(b => Effect.sync(() => f(b)));
-  filterMapEffect = f => (0, _Filtered.Filtered)(this, f);
-  filterMap = f => (0, _Filtered.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 = _Equal.equals) => (0, _Computed.Computed)(Versioned.transformFx(this, (0, _core.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