apps 0.0.1-beta.7 → 0.0.1-beta.70

package/js/{chunk-M3B3DE4K.js → chunk-74YVXBKY.js}

@@ -1,9 +1,3 @@
-import {
-  Reactivity,
-  invalidate,
-  layer,
-  mutation
-} from "./chunk-PJJ24GU7.js";
 import {
   Boolean,
   Cause,
@@ -43,6 +37,7 @@ import {
   constTrue,
   constVoid,
   constant,
+  context,
   contextWith,
   declareConstructor,
   decodeEffect,
@@ -53,7 +48,7 @@ import {
   effect,
   empty,
   empty2,
-  empty3,
+  empty6 as empty3,
   empty7 as empty4,
   encodeEffect,
   encodeExit,
@@ -65,6 +60,7 @@ import {
   fail4 as fail3,
   failCause,
   failCause2,
+  failCauseUnsafe,
   filter,
   filter2,
   filterInterruptors,
@@ -75,18 +71,21 @@ import {
   flatMap2,
   flatMapEager,
   flatMapNullishOr,
+  flow,
   forkDetach,
   fromInputUnsafe,
   fromJsonString,
+  fromQueue,
   gen,
   get,
-  get2,
+  get3 as get2,
   get5 as get3,
   getCurrent,
   getOrElse,
   getOrNull,
   getOrThrowWith,
   getOrUndefined,
+  getOrUndefined2,
   getStackTraceLimit,
   getSuccess,
   getUnsafe,
@@ -109,6 +108,7 @@ import {
   joinAll,
   lastNonEmpty,
   link,
+  make3 as make,
   makeCompositeAtKey,
   makeMemoMapUnsafe,
   makeUnsafe2 as makeUnsafe,
@@ -124,19 +124,22 @@ import {
   never,
   none,
   offerUnsafe,
+  onExit,
   pipe,
   pipeArguments,
   provide2 as provide,
   provideMerge,
-  remove,
+  provideService,
+  remove3 as remove,
   runCallbackWith,
   runForEachArray,
   runForkWith,
+  runIn,
   runSync,
   runSyncWith,
   scope,
   scopedWith,
-  set,
+  set4 as set,
   set5 as set2,
   some,
   squash,
@@ -148,6 +151,7 @@ import {
   symbol,
   symbol2,
   sync2 as sync,
+  tap,
   toCodecJson,
   toMillis,
   toPull,
@@ -158,12 +162,12 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.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 +280,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 +291,7 @@ var waiting = (self, options) => {
     result.timestamp = Date.now();
   }
   return result;
-};
+});
 var touch = (result) => {
   if (isSuccess(result)) {
     return success(result.value, {
@@ -296,7 +300,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 +308,7 @@ var replacePrevious = (self, previous) => {
     });
   }
   return self;
-};
+});
 var value = (self) => {
   if (self._tag === "Success") {
     return some(self.value);
@@ -600,7 +604,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,
@@ -610,27 +614,27 @@ __export(AtomRegistry_exports, {
   batchState: () => batchState,
   getResult: () => getResult,
   isAtomRegistry: () => isAtomRegistry,
-  layer: () => layer2,
+  layer: () => layer,
   layerOptions: () => layerOptions,
-  make: () => make,
+  make: () => make2,
   mount: () => mount,
   toStream: () => toStream,
   toStreamResult: () => toStreamResult
 });
 var TypeId2 = "~effect/reactivity/AtomRegistry";
 var isAtomRegistry = (u) => hasProperty(u, TypeId2);
-var make = (options) => new RegistryImpl(options?.initialValues, options?.scheduleTask, options?.timeoutResolution, options?.defaultIdleTTL);
+var make2 = (options) => new RegistryImpl(options?.initialValues, options?.scheduleTask, options?.timeoutResolution, options?.defaultIdleTTL);
 var AtomRegistry = /* @__PURE__ */ Service(TypeId2);
 var layerOptions = (options) => effect(AtomRegistry, gen(function* () {
   const scope2 = yield* scope;
-  const registry = make({
+  const registry = make2({
     ...options,
     scheduleTask: options?.scheduleTask
   });
   yield* addFinalizer(scope2, sync(() => registry.dispose()));
   return registry;
 }));
-var layer2 = /* @__PURE__ */ layerOptions();
+var layer = /* @__PURE__ */ layerOptions();
 var toStream = /* @__PURE__ */ dual(2, (self, atom) => callback2((queue) => suspend(() => {
   const fiber = getCurrent();
   const scope2 = getUnsafe(fiber.context, Scope);
@@ -660,9 +664,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 +749,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 +871,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 +931,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 +955,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 +1069,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 +1219,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 +1336,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 +1387,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,28 +1436,21 @@ 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,
   Reset: () => Reset,
   SerializableTypeId: () => SerializableTypeId2,
   ServerValueTypeId: () => ServerValueTypeId,
-  TypeId: () => TypeId3,
+  TypeId: () => TypeId4,
   WritableTypeId: () => WritableTypeId,
   autoDispose: () => autoDispose,
   batch: () => batch2,
-  context: () => context,
+  context: () => context2,
   debounce: () => debounce,
   family: () => family,
   fn: () => fn,
@@ -1365,7 +1464,7 @@ __export(Atom_exports, {
   isWritable: () => isWritable,
   keepAlive: () => keepAlive,
   kvs: () => kvs,
-  make: () => make2,
+  make: () => make4,
   makeRefreshOnSignal: () => makeRefreshOnSignal,
   map: () => map5,
   mapResult: () => mapResult,
@@ -1400,12 +1499,146 @@ __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/reactivity/Reactivity.js
+var TypeId3 = "~effect/reactivity/Reactivity";
+var Reactivity = /* @__PURE__ */ Service("effect/reactivity/Reactivity");
+var make3 = /* @__PURE__ */ sync(() => {
+  const handlers = /* @__PURE__ */ new Map();
+  const invalidateUnsafe = (keys) => {
+    keysToHashes(keys, (hash2) => {
+      const set4 = handlers.get(hash2);
+      if (set4 === void 0) return;
+      set4.forEach((run) => run());
+    });
+  };
+  const invalidate2 = (keys) => contextWith((services) => {
+    const pending = getOrUndefined2(services, PendingInvalidation);
+    if (pending) {
+      keysToHashes(keys, (hash2) => {
+        pending.add(hash2);
+      });
+    } else {
+      invalidateUnsafe(keys);
+    }
+    return void_2;
+  });
+  const mutation2 = (keys, effect3) => tap(effect3, invalidate2(keys));
+  const registerUnsafe = (keys, handler) => {
+    const resolvedKeys = [];
+    keysToHashes(keys, (hash2) => {
+      resolvedKeys.push(hash2);
+      let set4 = handlers.get(hash2);
+      if (set4 === void 0) {
+        set4 = /* @__PURE__ */ new Set();
+        handlers.set(hash2, set4);
+      }
+      set4.add(handler);
+    });
+    return () => {
+      for (let i = 0; i < resolvedKeys.length; i++) {
+        const set4 = handlers.get(resolvedKeys[i]);
+        if (set4 === void 0) continue;
+        set4.delete(handler);
+        if (set4.size === 0) {
+          handlers.delete(resolvedKeys[i]);
+        }
+      }
+    };
+  };
+  const query = (keys, effect3) => gen(function* () {
+    const services = yield* context();
+    const scope2 = get(services, Scope);
+    const results = yield* make();
+    const runFork = flow(runForkWith(services), runIn(scope2));
+    let running = false;
+    let pending = false;
+    const handleExit = (exit) => {
+      if (exit._tag === "Failure") {
+        failCauseUnsafe(results, exit.cause);
+      } else {
+        offerUnsafe(results, exit.value);
+      }
+      if (pending) {
+        pending = false;
+        runFork(effect3).addObserver(handleExit);
+      } else {
+        running = false;
+      }
+    };
+    function run() {
+      if (running) {
+        pending = true;
+        return;
+      }
+      running = true;
+      runFork(effect3).addObserver(handleExit);
+    }
+    const cancel = registerUnsafe(keys, run);
+    yield* addFinalizer(scope2, sync(cancel));
+    run();
+    return results;
+  });
+  const stream2 = (tables, effect3) => query(tables, effect3).pipe(map2(fromQueue), unwrap);
+  const withBatch = (effect3) => suspend(() => {
+    const pending = /* @__PURE__ */ new Set();
+    return effect3.pipe(provideService(PendingInvalidation, pending), onExit((_) => sync(() => {
+      pending.forEach((hash2) => {
+        const set4 = handlers.get(hash2);
+        if (set4 === void 0) return;
+        set4.forEach((run) => run());
+      });
+    })));
+  });
+  return Reactivity.of({
+    [TypeId3]: TypeId3,
+    mutation: mutation2,
+    query,
+    stream: stream2,
+    invalidateUnsafe,
+    invalidate: invalidate2,
+    registerUnsafe,
+    withBatch
+  });
+});
+var PendingInvalidation = class extends (/* @__PURE__ */ Service()("effect/reactivity/Reactivity/PendingInvalidation")) {
+};
+var mutation = /* @__PURE__ */ dual(2, (effect3, keys) => Reactivity.use((_) => _.mutation(keys, effect3)));
+var invalidate = (keys) => Reactivity.use((r) => r.invalidate(keys));
+var layer2 = /* @__PURE__ */ effect(Reactivity)(make3);
+function stringOrHash(u) {
+  switch (typeof u) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+      return String(u);
+    default:
+      return hash(u);
+  }
+}
+var keysToHashes = (keys, f) => {
+  if (Array.isArray(keys)) {
+    for (let i = 0; i < keys.length; i++) {
+      f(stringOrHash(keys[i]));
+    }
+    return;
+  }
+  for (const key in keys) {
+    f(key);
+    const ids = keys[key];
+    for (let i = 0; i < ids.length; i++) {
+      f(`${key}:${stringOrHash(ids[i])}`);
+    }
+  }
+};
+
+// ../../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,9 +1675,9 @@ 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
-var TypeId3 = "~effect/reactivity/Atom";
-var isAtom = (u) => hasProperty(u, TypeId3);
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/Atom.js
+var TypeId4 = "~effect/reactivity/Atom";
+var isAtom = (u) => hasProperty(u, TypeId4);
 var WritableTypeId = "~effect/reactivity/Atom/Writable";
 var setIdleTTL = /* @__PURE__ */ dual(2, (self, durationInput) => {
   const duration = fromInputUnsafe(durationInput);
@@ -1457,7 +1690,7 @@ var setIdleTTL = /* @__PURE__ */ dual(2, (self, durationInput) => {
 });
 var removeTtl = /* @__PURE__ */ setIdleTTL(0);
 var AtomProto = {
-  [TypeId3]: TypeId3,
+  [TypeId4]: TypeId4,
   equals: Object.is,
   ...PipeInspectableProto,
   toJSON() {
@@ -1555,9 +1788,9 @@ var writable = (read, write, refresh2) => {
 function constSetSelf(ctx, value2) {
   ctx.setSelf(value2);
 }
-var make2 = (arg, options) => {
+var make4 = (arg, options) => {
   const readOrAtom = makeRead(arg, options);
-  if (TypeId3 in readOrAtom) {
+  if (TypeId4 in readOrAtom) {
     return readOrAtom;
   }
   return readable(readOrAtom);
@@ -1602,7 +1835,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(() => {
@@ -1627,9 +1860,9 @@ function makeEffect(ctx, effect3, initialValue2, services = empty2(), uninterrup
   }
   return waiting(initialValue2);
 }
-function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
+function runCallbackSync(services, effect3, onExit2, uninterruptible = false) {
   if (isExit(effect3)) {
-    onExit(effect3);
+    onExit2(effect3);
     return void 0;
   }
   const runFork = runForkWith(services);
@@ -1637,10 +1870,10 @@ function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
   fiber.currentDispatcher?.flush();
   const result = fiber.pollUnsafe();
   if (result) {
-    onExit(result);
+    onExit2(result);
     return void 0;
   }
-  const remove2 = fiber.addObserver(onExit);
+  const remove2 = fiber.addObserver(onExit2);
   function cancel() {
     remove2();
     if (!uninterruptible) {
@@ -1649,10 +1882,10 @@ function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
   }
   return cancel;
 }
-function context(options) {
-  const memoMap = options?.memoMap ?? removeTtl(make2(() => makeMemoMapUnsafe()));
+function context2(options) {
+  const memoMap = options?.memoMap ?? removeTtl(make4(() => makeMemoMapUnsafe()));
   const resolveMemoMap = (get5) => isAtom(memoMap) ? get5(memoMap) : memoMap;
-  let globalLayer = layer;
+  let globalLayer = layer2;
   function factory(create) {
     const self = Object.create(RuntimeProto);
     self.keepAlive = false;
@@ -1672,9 +1905,9 @@ function context(options) {
   }
   factory.memoMap = memoMap;
   factory.addGlobalLayer = (layer3) => {
-    globalLayer = provideMerge(globalLayer, provide(layer3, layer));
+    globalLayer = provideMerge(globalLayer, provide(layer3, layer2));
   };
-  const reactivityAtom = removeTtl(make2((get5) => contextWith((services) => buildWithMemoMap(layer, resolveMemoMap(get5), get(services, Scope))).pipe(map2(get(Reactivity)))));
+  const reactivityAtom = removeTtl(make4((get5) => contextWith((services) => buildWithMemoMap(layer2, resolveMemoMap(get5), get(services, Scope))).pipe(map2(get(Reactivity)))));
   factory.withReactivity = (keys) => (atom) => transform2(atom, (get5) => {
     const reactivity = getOrThrow(get5(reactivityAtom));
     get5.addFinalizer(reactivity.registerUnsafe(keys, () => {
@@ -1687,13 +1920,13 @@ function context(options) {
   });
   return factory;
 }
-var runtime = /* @__PURE__ */ context();
+var runtime = /* @__PURE__ */ context2();
 var withReactivity = runtime.withReactivity;
 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 +1965,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 +2061,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 +2094,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 +2157,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 +2286,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;
   }, {