apps 0.0.1-beta.34 → 0.0.1-beta.36

package/js/{chunk-6ZJ2H6P4.js → chunk-A4O72Z3A.js}

@@ -3,7 +3,7 @@ import {
   invalidate,
   layer,
   mutation
-} from "./chunk-DASNNAP4.js";
+} from "./chunk-HDAQBRT5.js";
 import {
   Boolean,
   Cause,
@@ -53,7 +53,7 @@ import {
   effect,
   empty,
   empty2,
-  empty3,
+  empty6 as empty3,
   empty7 as empty4,
   encodeEffect,
   encodeExit,
@@ -80,7 +80,7 @@ import {
   fromJsonString,
   gen,
   get,
-  get2,
+  get3 as get2,
   get5 as get3,
   getCurrent,
   getOrElse,
@@ -128,7 +128,7 @@ import {
   pipeArguments,
   provide2 as provide,
   provideMerge,
-  remove,
+  remove3 as remove,
   runCallbackWith,
   runForEachArray,
   runForkWith,
@@ -136,7 +136,7 @@ import {
   runSyncWith,
   scope,
   scopedWith,
-  set,
+  set4 as set,
   set5 as set2,
   some,
   squash,
@@ -158,12 +158,12 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/AsyncResult.js
 var AsyncResult_exports = {};
 __export(AsyncResult_exports, {
   Schema: () => Schema,
@@ -276,7 +276,7 @@ var failureWithPrevious = (cause2, options) => failure(cause2, {
 });
 var fail4 = (error2, options) => failure(fail(error2), options);
 var failWithPrevious = (error2, options) => failureWithPrevious(fail(error2), options);
-var waiting = (self, options) => {
+var waiting = /* @__PURE__ */ dual((args) => isAsyncResult(args[0]), (self, options) => {
   if (self.waiting) {
     return options?.touch ? touch(self) : self;
   }
@@ -287,7 +287,7 @@ var waiting = (self, options) => {
     result.timestamp = Date.now();
   }
   return result;
-};
+});
 var touch = (result) => {
   if (isSuccess(result)) {
     return success(result.value, {
@@ -296,7 +296,7 @@ var touch = (result) => {
   }
   return result;
 };
-var replacePrevious = (self, previous) => {
+var replacePrevious = /* @__PURE__ */ dual(2, (self, previous) => {
   if (self._tag === "Failure") {
     return failureWithPrevious(self.cause, {
       previous,
@@ -304,7 +304,7 @@ var replacePrevious = (self, previous) => {
     });
   }
   return self;
-};
+});
 var value = (self) => {
   if (self._tag === "Success") {
     return some(self.value);
@@ -600,7 +600,7 @@ var Schema = (options) => {
   });
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/AtomRegistry.js
 var AtomRegistry_exports = {};
 __export(AtomRegistry_exports, {
   AtomRegistry: () => AtomRegistry,
@@ -660,9 +660,21 @@ var mount = /* @__PURE__ */ dual(2, (self, atom) => acquireRelease(sync(() => se
 var constImmediate = {
   immediate: true
 };
-var notifyListener = (listener) => {
-  listener();
+var invoke = (f) => {
+  f();
 };
+var noFailure = {};
+function runAll(items, f) {
+  let failure2 = noFailure;
+  for (const item of items) {
+    try {
+      f(item);
+    } catch (error2) {
+      if (failure2 === noFailure) failure2 = error2;
+    }
+  }
+  if (failure2 !== noFailure) throw failure2;
+}
 var SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
 var atomKey = (atom) => SerializableTypeId in atom ? atom[SerializableTypeId].key : atom;
 var RegistryImpl = class {
@@ -733,6 +745,8 @@ var RegistryImpl = class {
     const node = this.ensureNode(atom);
     if (options?.immediate) {
       f(node.value());
+    } else if (node.state === NodeState.stale) {
+      node.value();
     }
     const remove2 = node.subscribe(function() {
       f(node._value);
@@ -853,26 +867,35 @@ var RegistryImpl = class {
   sweepBucket(bucket) {
     const nodes = this.timeoutBuckets.get(bucket)[0];
     this.timeoutBuckets.delete(bucket);
-    nodes.forEach((node) => {
-      this.nodeTimeoutBucket.delete(node);
-      if (!node.canBeRemoved) return;
-      this.nodes.delete(atomKey(node.atom));
-      this.onNodeRemoved?.(node);
-      this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+    runAll(nodes, this.removeIdleNode);
+  }
+  removeIdleNode = (node) => {
+    this.nodeTimeoutBucket.delete(node);
+    if (!node.canBeRemoved) return;
+    this.nodes.delete(atomKey(node.atom));
+    this.onNodeRemoved?.(node);
+    this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+    try {
       node.remove();
+    } finally {
       this.#currentSweepTTL = null;
-    });
-  }
+    }
+  };
   reset() {
     this.timeoutBuckets.forEach(([, handle]) => clearTimeout(handle));
     this.timeoutBuckets.clear();
     this.nodeTimeoutBucket.clear();
-    this.nodes.forEach((node) => {
-      node.remove();
-      this.onNodeRemoved?.(node);
-    });
+    const nodes = Array.from(this.nodes.values());
     this.nodes.clear();
+    for (const node of nodes) {
+      node.state = NodeState.removed;
+    }
+    runAll(nodes, this.destroyNode);
   }
+  destroyNode = (node) => {
+    node.remove();
+    this.onNodeRemoved?.(node);
+  };
   dispose() {
     this.disposed = true;
     this.reset();
@@ -904,13 +927,15 @@ var NodeImpl = class {
   lifetime;
   writeContext;
   preserveInitialValueOnBuild = false;
+  invalidatedDuringBuild = false;
+  failed = false;
+  // Every parent that holds this node as a child. A stale node keeps the
+  // parents of its last build, so they are not released and their next change
+  // still reaches it. A build drops the parents it did not read.
   parents = /* @__PURE__ */ new Set();
-  previousParents;
   children = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
-  skipInvalidation = false;
-  building = false;
-  invalidatedDuringBuild = false;
+  observedChildren = 0;
   currentState() {
     switch (this.state) {
       case NodeState.uninitialized:
@@ -926,33 +951,108 @@ var NodeImpl = class {
   get canBeRemoved() {
     return !this.atom.keepAlive && this.listeners.size === 0 && this.children.size === 0 && this.state !== 0;
   }
+  get building() {
+    return this.lifetime !== void 0 && this.lifetime.reads !== void 0;
+  }
+  // An observed node is rebuilt as soon as it goes stale, because something
+  // waits for its value without reading it. The count spares walking the
+  // children on every invalidation.
+  get isObserved() {
+    return !this.atom.lazy || this.listeners.size > 0 || this.observedChildren > 0;
+  }
+  childObserved(delta) {
+    const observed = this.isObserved;
+    this.observedChildren += delta;
+    if (observed !== this.isObserved) {
+      this.observedChanged(delta);
+    }
+  }
+  observedChanged(delta) {
+    for (const parent of this.parents) {
+      parent.childObserved(delta);
+    }
+  }
   _value = void 0;
   value() {
-    if ((this.state & NodeFlags.waitingForValue) !== 0) {
-      this.lifetime = makeLifetime(this);
-      this.building = true;
-      const value2 = this.atom.read(this.lifetime);
-      this.building = false;
-      if ((this.state & NodeFlags.waitingForValue) !== 0) {
-        if (this.preserveInitialValueOnBuild) {
-          this.preserveInitialValueOnBuild = false;
-          this.state = NodeState.valid;
-        } else {
-          this.setValue(value2);
-        }
+    while ((this.state & NodeFlags.waitingForValue) !== 0) {
+      this.build();
+    }
+    return this._value;
+  }
+  build() {
+    this.disposeLifetime();
+    this.invalidatedDuringBuild = false;
+    const lifetime = makeLifetime(this);
+    this.lifetime = lifetime;
+    let value2;
+    let read = false;
+    try {
+      value2 = this.atom.read(lifetime);
+      read = true;
+    } finally {
+      const reads = lifetime.reads;
+      lifetime.reads = void 0;
+      if (this.lifetime === lifetime) {
+        this.dropUnread(reads);
+        if (!read) this.fail();
       }
-      if (this.previousParents) {
-        const parents = this.previousParents;
-        this.previousParents = void 0;
-        for (const parent of parents) {
-          parent.removeChild(this);
-          if (parent.canBeRemoved) {
-            this.registry.scheduleNodeRemoval(parent);
-          }
-        }
+    }
+    if (this.lifetime === lifetime && (this.state & NodeFlags.waitingForValue) !== 0) {
+      if (this.preserveInitialValueOnBuild) {
+        this.preserveInitialValueOnBuild = false;
+        this.failed = false;
+        this.state = NodeState.valid;
+      } else {
+        this.setValue(value2);
+      }
+    }
+    if (lifetime.failure !== noFailure) throw lifetime.failure;
+  }
+  // A build that threw leaves its dependents holding, or reading, a value
+  // this node no longer stands behind, so they go stale and rebuild when
+  // pulled or observed. The read's error is the one reported.
+  fail() {
+    this.failed = true;
+    try {
+      this.invalidateChildren();
+    } catch {
+    }
+  }
+  readTracked(atom, lifetime) {
+    const parent = this.registry.ensureNode(atom);
+    if (!this.parents.has(parent)) {
+      this.parents.add(parent);
+      parent.children.add(this);
+      if (this.isObserved) {
+        parent.childObserved(1);
+      }
+    }
+    try {
+      return parent.value();
+    } catch (error2) {
+      if (lifetime.reads === void 0 || parent.state !== NodeState.valid) throw error2;
+      if (lifetime.failure === noFailure) lifetime.failure = error2;
+      return parent._value;
+    } finally {
+      if (lifetime.reads !== void 0 && !lifetime.disposed) {
+        lifetime.reads.add(parent);
+      }
+    }
+  }
+  dropUnread(reads) {
+    if (reads.size === this.parents.size) return;
+    const observed = this.isObserved;
+    for (const parent of this.parents) {
+      if (reads.has(parent)) continue;
+      this.parents.delete(parent);
+      parent.children.delete(this);
+      if (observed) {
+        parent.childObserved(-1);
+      }
+      if (parent.canBeRemoved) {
+        this.registry.scheduleNodeRemoval(parent);
       }
     }
-    return this._value;
   }
   valueOption() {
     if ((this.state & NodeFlags.initialized) === 0) {
@@ -965,151 +1065,143 @@ var NodeImpl = class {
       this.preserveInitialValueOnBuild = true;
       this.state = NodeState.stale;
       this._value = value2;
-      if (batchState.phase === BatchPhase.collect) {
-        batchState.notify.add(this);
-      } else {
-        this.notify();
+      if (this.listeners.size > 0) {
+        this.announce();
       }
       return;
     }
     this.setValue(value2);
   }
   setValue(value2) {
-    if ((this.state & NodeFlags.initialized) === 0) {
-      this.state = NodeState.valid;
-      this._value = value2;
-      if (batchState.phase === BatchPhase.collect) {
-        batchState.notify.add(this);
-      } else {
-        this.notify();
-      }
-      return;
-    }
+    const recovered = this.failed;
+    this.failed = false;
+    const initialized = (this.state & NodeFlags.initialized) !== 0;
     this.state = NodeState.valid;
-    if (this.atom.equals(this._value, value2)) {
+    if (initialized && this.atom.equals(this._value, value2)) {
+      if (recovered) this.invalidateChildren();
       return;
     }
     this._value = value2;
-    if (this.skipInvalidation) {
-      this.skipInvalidation = false;
-    } else {
+    let failure2 = noFailure;
+    try {
       this.invalidateChildren();
+    } catch (error2) {
+      failure2 = error2;
     }
     if (this.listeners.size > 0) {
-      if (batchState.phase === BatchPhase.collect) {
-        batchState.notify.add(this);
-      } else {
-        this.notify();
+      try {
+        this.announce();
+      } catch (error2) {
+        if (failure2 === noFailure) failure2 = error2;
       }
     }
+    if (failure2 !== noFailure) throw failure2;
   }
-  addParent(parent) {
-    this.parents.add(parent);
-    if (this.previousParents !== void 0) {
-      this.previousParents.delete(parent);
-      if (this.previousParents.size === 0) {
-        this.previousParents = void 0;
-      }
-    }
-    if (!parent.children.has(this)) {
-      parent.children.add(this);
-      if (parent.skipInvalidation) {
-        parent.skipInvalidation = false;
-      }
+  announce() {
+    if (batchState.phase === BatchPhase.collect) {
+      batchState.notify.add(this);
+    } else {
+      this.notify();
     }
   }
-  removeChild(child) {
-    this.children.delete(child);
-  }
   invalidate() {
-    if (this.building && batchState.phase === BatchPhase.collect) {
-      this.invalidatedDuringBuild = true;
-    }
     if (this.state === NodeState.valid) {
       this.state = NodeState.stale;
-      this.disposeLifetime();
+      try {
+        this.disposeLifetime();
+      } finally {
+        this.propagate();
+      }
+    } else if (this.building && batchState.phase !== BatchPhase.collect) {
+      this.build();
+    } else {
+      this.propagate();
     }
+  }
+  propagate() {
     if (batchState.phase === BatchPhase.collect) {
+      if (this.building) {
+        this.invalidatedDuringBuild = true;
+      }
       batchState.stale.push(this);
-    } else if (this.atom.lazy && this.listeners.size === 0 && !childrenAreActive(this.children)) {
-      this.invalidateChildren();
-      this.skipInvalidation = true;
-    } else {
+    } else if (this.isObserved) {
       this.value();
+    } else {
+      this.invalidateChildren();
     }
   }
   invalidateChildren() {
     if (this.children.size === 0) {
       return;
     }
-    const children = this.children;
-    this.children = /* @__PURE__ */ new Set();
-    for (const child of children) {
-      child.invalidate();
+    let failure2 = noFailure;
+    for (const child of Array.from(this.children)) {
+      if (!child.affectedBy(this)) continue;
+      try {
+        child.invalidate();
+      } catch (error2) {
+        if (failure2 === noFailure) failure2 = error2;
+      }
     }
+    if (failure2 !== noFailure) throw failure2;
+  }
+  // Whether a change of the parent reaches this node: it holds the parent's
+  // value, or a running build has already read it. A stale node is stale
+  // already, and a build that has not read the parent yet will read the new
+  // value. The exception is an observed node that is still stale: its rebuild
+  // failed, and a parent that has a value again is its chance to recover.
+  affectedBy(parent) {
+    if (this.state === NodeState.valid) return true;
+    const reads = this.lifetime?.reads;
+    if (reads !== void 0) return reads.has(parent);
+    return this.isObserved && parent.state === NodeState.valid;
   }
   notify() {
-    this.listeners.forEach(notifyListener);
     if (batchState.phase === BatchPhase.commit) {
       batchState.notify.delete(this);
     }
+    runAll(this.listeners, invoke);
   }
   disposeLifetime() {
-    if (this.lifetime !== void 0) {
-      this.lifetime.dispose();
+    const lifetime = this.lifetime;
+    if (lifetime !== void 0) {
       this.lifetime = void 0;
-    }
-    if (this.parents.size !== 0) {
-      this.previousParents = this.parents;
-      this.parents = /* @__PURE__ */ new Set();
+      lifetime.dispose();
     }
   }
   remove() {
+    const observed = this.isObserved;
     this.state = NodeState.removed;
     this.listeners.clear();
-    if (this.lifetime !== void 0) {
+    try {
       this.disposeLifetime();
-    }
-    if (this.previousParents === void 0) {
-      return;
-    }
-    const parents = this.previousParents;
-    this.previousParents = void 0;
-    for (const parent of parents) {
-      parent.removeChild(this);
-      if (parent.canBeRemoved) {
-        this.registry.removeNode(parent);
-      }
+    } finally {
+      const parents = Array.from(this.parents);
+      this.parents.clear();
+      runAll(parents, (parent) => {
+        parent.children.delete(this);
+        if (observed) {
+          parent.childObserved(-1);
+        }
+        if (parent.canBeRemoved) {
+          this.registry.removeNode(parent);
+        }
+      });
     }
   }
   subscribe(listener) {
+    const observed = this.isObserved;
     this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-};
-function childrenAreActive(children) {
-  if (children.size === 0) {
-    return false;
-  }
-  let current = children;
-  let stack;
-  let stackIndex = 0;
-  while (current !== void 0) {
-    for (const child of current) {
-      if (!child.atom.lazy || child.listeners.size > 0) {
-        return true;
-      } else if (child.children.size > 0) {
-        if (stack === void 0) {
-          stack = [child.children];
-        } else {
-          stack.push(child.children);
-        }
-      }
+    if (!observed) {
+      this.observedChanged(1);
     }
-    current = stack?.[stackIndex++];
+    return () => {
+      if (this.listeners.delete(listener) && !this.isObserved) {
+        this.observedChanged(-1);
+      }
+    };
   }
-  return false;
-}
+};
 var LifetimeProto = {
   get registry() {
     return this.node.registry;
@@ -1123,10 +1215,7 @@ var LifetimeProto = {
     if (this.disposed) {
       return this.node.registry.get(atom);
     }
-    const parent = this.node.registry.ensureNode(atom);
-    const value2 = parent.value();
-    this.node.addParent(parent);
-    return value2;
+    return this.node.readTracked(atom, this);
   },
   result(atom, options) {
     if (this.disposed || this.isFn) {
@@ -1243,28 +1332,23 @@ var LifetimeProto = {
     }
     const finalizers = this.finalizers;
     this.finalizers = void 0;
-    for (let i = finalizers.length - 1; i >= 0; i--) {
-      finalizers[i]();
-    }
+    runAll(finalizers.reverse(), invoke);
   }
 };
 var makeLifetime = (node) => {
   function get5(atom) {
-    if (get5.disposed) {
-      return node.registry.get(atom);
-    } else if (get5.isFn) {
+    if (get5.disposed || get5.isFn) {
       return node.registry.get(atom);
     }
-    const parent = node.registry.ensureNode(atom);
-    const value2 = parent.value();
-    node.addParent(parent);
-    return value2;
+    return node.readTracked(atom, get5);
   }
   Object.setPrototypeOf(get5, LifetimeProto);
   get5.isFn = false;
   get5.disposed = false;
   get5.finalizers = void 0;
   get5.node = node;
+  get5.reads = /* @__PURE__ */ new Set();
+  get5.failure = noFailure;
   return get5;
 };
 var WriteContextImpl = class {
@@ -1299,27 +1383,45 @@ var batchState = {
   notify: /* @__PURE__ */ new Set()
 };
 function batch(f) {
+  const previousPhase = batchState.phase;
   batchState.phase = BatchPhase.collect;
   batchState.depth++;
+  let failure2 = noFailure;
   try {
     f();
-    if (batchState.depth === 1) {
-      for (let i = 0; i < batchState.stale.length; i++) {
-        batchRebuildNode(batchState.stale[i]);
+  } catch (error2) {
+    failure2 = error2;
+  }
+  if (batchState.depth === 1) {
+    const {
+      notify,
+      stale
+    } = batchState;
+    let i = 0;
+    do {
+      batchState.phase = BatchPhase.collect;
+      for (; i < stale.length; i++) {
+        try {
+          batchRebuildNode(stale[i]);
+        } catch (error2) {
+          if (failure2 === noFailure) failure2 = error2;
+        }
       }
       batchState.phase = BatchPhase.commit;
-      for (const node of batchState.notify) {
-        node.notify();
+      for (const node of notify) {
+        try {
+          node.notify();
+        } catch (error2) {
+          if (failure2 === noFailure) failure2 = error2;
+        }
       }
-      batchState.notify.clear();
-    }
-  } finally {
-    batchState.depth--;
-    if (batchState.depth === 0) {
-      batchState.phase = BatchPhase.disabled;
-      batchState.stale = [];
-    }
+    } while (i < stale.length);
+    batchState.stale = [];
+    notify.clear();
   }
+  batchState.depth--;
+  batchState.phase = previousPhase;
+  if (failure2 !== noFailure) throw failure2;
 }
 function batchRebuildNode(node) {
   if (node.state === NodeState.valid) {
@@ -1330,17 +1432,10 @@ function batchRebuildNode(node) {
     node.state = NodeState.stale;
     node.disposeLifetime();
   }
-  for (const parent of node.parents) {
-    if (parent.state !== NodeState.valid) {
-      batchRebuildNode(parent);
-    }
-  }
-  if (node.state !== NodeState.valid) {
-    node.value();
-  }
+  node.value();
 }
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/Atom.js
 var Atom_exports = {};
 __export(Atom_exports, {
   Interrupt: () => Interrupt,
@@ -1400,12 +1495,13 @@ __export(Atom_exports, {
   writable: () => writable
 });
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/persistence/KeyValueStore.js
 var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
 var KeyValueStoreError = class extends (/* @__PURE__ */ TaggedError("KeyValueStoreError")) {
   /**
    * Marks this value as a key-value store error for runtime guards.
    *
+   * @stability unstable
    * @since 4.0.0
    */
   [ErrorTypeId] = ErrorTypeId;
@@ -1442,7 +1538,7 @@ var toSchemaStore = (self, schema) => {
   };
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/Atom.js
 var TypeId3 = "~effect/reactivity/Atom";
 var isAtom = (u) => hasProperty(u, TypeId3);
 var WritableTypeId = "~effect/reactivity/Atom/Writable";
@@ -1602,7 +1698,7 @@ var effect2 = (get5, effect3, options, services) => {
   const initialValue2 = options?.initialValue !== void 0 ? success(options.initialValue) : initial();
   return makeEffect(get5, effect3, initialValue2, services, options?.uninterruptible);
 };
-function makeEffect(ctx, effect3, initialValue2, services = empty2(), uninterruptible = false) {
+function makeEffect(ctx, effect3, initialValue2, services = empty(), uninterruptible = false) {
   const previous = ctx.self();
   const scope2 = makeUnsafe();
   ctx.addFinalizer(() => {
@@ -1693,7 +1789,7 @@ var stream = (get5, stream2, options, services) => {
   const initialValue2 = options?.initialValue !== void 0 ? success(options.initialValue) : initial();
   return makeStream(get5, stream2, initialValue2, services);
 };
-function makeStream(ctx, stream2, initialValue2, services = empty2()) {
+function makeStream(ctx, stream2, initialValue2, services = empty()) {
   const previous = ctx.self();
   services = add(services, AtomRegistry, ctx.registry);
   const run = scopedWith((scope2) => flatMap2(toPullScoped(stream2.channel, scope2), (pull2) => whileLoop({
@@ -1732,7 +1828,7 @@ var subscriptionRef = (ref) => makeSubRef(readable((get5) => {
   const value2 = typeof ref === "function" ? ref(get5) : ref;
   return isSubscriptionRef(value2) ? value2 : makeEffect(get5, value2, initial(true));
 }), readSubscriptionRef);
-var readSubscriptionRef = (get5, sub, services = empty2()) => {
+var readSubscriptionRef = (get5, sub, services = empty()) => {
   if (isSubscriptionRef(sub)) {
     get5.addFinalizer(changes2(sub).pipe(runForEachArray((arr) => {
       for (let i = 0; i < arr.length; i++) {
@@ -1828,8 +1924,9 @@ function makeResultFn(f, options) {
           startImmediately: true
         }), (fiber) => {
           fibers.add(fiber);
+          const runningFibers = Array.from(fibers);
           fiber.addObserver(() => fibers.delete(fiber));
-          return map2(joinAll(fibers), (arr) => arr[0]);
+          return map2(joinAll(runningFibers), (arr) => arr[0]);
         });
       }
       return makeEffect(get5, value2, initialValue2, services, false);
@@ -1860,7 +1957,7 @@ var pull = (create, options) => {
 var makeStreamPullEffect = (get5, pullSignal, create, options) => flatMap2(toPull(typeof create === "function" ? create(get5) : create), (pullChunk) => {
   const fiber = getCurrent();
   const services = fiber.context;
-  let acc = empty();
+  let acc = empty2();
   const pull2 = matchCauseEffect(pullChunk, {
     onFailure(cause2) {
       if (isDoneCause(cause2)) {
@@ -1923,7 +2020,10 @@ var family = typeof WeakRef === "undefined" || typeof FinalizationRegistry === "
 } : (f) => {
   const atoms = empty3();
   const registry = new FinalizationRegistry((arg) => {
-    remove(atoms, arg);
+    const entry = get2(atoms, arg);
+    if (entry._tag === "Some" && entry.value.deref() === void 0) {
+      remove(atoms, arg);
+    }
   });
   return function(arg) {
     const atomEntry = get2(atoms, arg).pipe(flatMapNullishOr((ref) => ref.deref()));
@@ -2049,7 +2149,15 @@ var swr = /* @__PURE__ */ dual(2, (self, options) => {
       return current;
     }
     if (shouldRevalidateSWR(current, staleTime)) {
-      get5.refresh(self);
+      let active = true;
+      get5.addFinalizer(() => {
+        active = false;
+      });
+      get5.registry.schedulerAsync.makeDispatcher().scheduleTask(() => {
+        if (active && shouldRevalidateSWR(get5.once(self), staleTime)) {
+          get5.refresh(self);
+        }
+      }, 0);
     }
     return current;
   }, {