valdres 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/index.js

@@ -123,17 +123,18 @@ var isPromiseLike = (object) => {
 };
 
 // src/utils/deepFreeze.ts
-var deepFreeze = (obj, seen = new WeakSet) => {
+var deepFreeze = (obj, seen) => {
   if (obj === null || obj === undefined)
     return obj;
   if (typeof obj !== "object" && typeof obj !== "function")
     return obj;
-  if (seen.has(obj) || Object.isFrozen(obj))
+  if (Object.isFrozen(obj) || seen?.has(obj))
     return obj;
-  seen.add(obj);
   if (Array.isArray(obj)) {
     for (const item of obj) {
       if (item && typeof item === "object") {
+        seen ??= new WeakSet;
+        seen.add(obj);
         deepFreeze(item, seen);
       }
     }
@@ -142,6 +143,8 @@ var deepFreeze = (obj, seen = new WeakSet) => {
     for (const name of propNames) {
       const value = obj[name];
       if (value && typeof value === "object") {
+        seen ??= new WeakSet;
+        seen.add(obj);
         deepFreeze(value, seen);
       }
     }
@@ -149,26 +152,28 @@ var deepFreeze = (obj, seen = new WeakSet) => {
   return Object.freeze(obj);
 };
 
-// src/lib/isProd.ts
-var isProd = () => {
-  return false;
-};
+// src/lib/IS_PROD.ts
+var IS_PROD = typeof process !== "undefined" && process.env != null && process.env.NODE_ENV === "production";
 
 // src/lib/setValueInData.ts
 var trackScopeValue = (key, data) => {
   const parent = data.parent;
+  const indexKeys = data.scopeIndexKeys;
+  if (!parent || !indexKeys) {
+    throw new Error("trackScopeValue called on a root store");
+  }
   let set = parent.scopeValueIndex.get(key);
   if (!set) {
     set = new Set;
     parent.scopeValueIndex.set(key, set);
   }
   set.add(data);
-  data.scopeIndexKeys.add(key);
+  indexKeys.add(key);
 };
 var setValueInData = (atom, value, data) => {
-  const isNewAtomInScope = "parent" in data && Object.hasOwn(atom, "defaultValue") && !data.values.has(atom);
+  const isNewAtomInScope = data.parent && Object.hasOwn(atom, "defaultValue") && !data.values.has(atom);
   let written;
-  if (atom.mutable || isProd()) {
+  if (atom.mutable || IS_PROD) {
     data.values.set(atom, value);
     written = value;
   } else {
@@ -176,8 +181,14 @@ var setValueInData = (atom, value, data) => {
     data.values.set(atom, frozenValue);
     written = frozenValue;
   }
-  if (isNewAtomInScope)
+  if (isNewAtomInScope) {
     trackScopeValue(atom, data);
+    const subs = data.subscriptions.get(atom);
+    if (subs) {
+      for (const sub of subs)
+        sub.reRoot?.();
+    }
+  }
   if (atom.maxAge !== undefined) {
     data.lastValueWriteAt.set(atom, Date.now());
   }
@@ -245,14 +256,14 @@ var initFamilyIndex = (family, data) => {
   if (data.values.has(family))
     return data.values.get(family).__index;
   let parentIndex;
-  if ("parent" in data) {
+  if (data.parent) {
     parentIndex = initFamilyIndex(family, data.parent);
     if (!parentIndex)
       throw new Error("Parent index is missing");
   }
   const index = createAtomFamilyIndex(parentIndex);
   data.values.set(family, renderAtomFamilyIndex(index));
-  if ("parent" in data) {
+  if (data.parent) {
     trackScopeValue(family, data);
   }
   return index;
@@ -271,8 +282,10 @@ var recursivelyUpdateIndexes = (data, family) => {
   const childScopesWithFamily = data.scopeValueIndex.get(family);
   if (!childScopesWithFamily || childScopesWithFamily.size === 0)
     return;
+  const parentIndex = data.values.get(family).__index;
   for (const scopedData of childScopesWithFamily) {
     const index = scopedData.values.get(family).__index;
+    index.parentIndex = parentIndex;
     index.rendered = null;
     index.renderedArray = null;
     scopedData.values.set(family, renderAtomFamilyIndex(index));
@@ -343,7 +356,6 @@ ${generateSelectorTrace(this.selectors)}`;
 
 // src/lib/asyncDependencyTracking.ts
 var pendingAsyncDeps = new WeakMap;
-var latestEvalContext = new WeakMap;
 
 class SuspendAndWaitForResolveError extends Error {
   promise;
@@ -379,7 +391,8 @@ var lateGet = (state, selector, data) => {
   try {
     return getState(state, data, lateInitSet);
   } finally {
-    if (isNewDep && isTransitivelySubscribed(selector, data)) {
+    if (isNewDep && isLive(selector, data)) {
+      onLiveDependencyAdded(state, data);
       mountTransitiveDeps(state, data);
     }
   }
@@ -391,23 +404,22 @@ var cleanUpRejectedPromise = (selector, data, promise) => {
 };
 
 // src/lib/initSelector.ts
-class NeedsInitError {
-  selector;
-  constructor(selector) {
-    this.selector = selector;
-  }
-}
-var _evalDepth = 0;
-var _inTrampoline = false;
-var MAX_EVAL_DEPTH = 100;
-var sharedCircularDepSet = new WeakSet;
 var neverAbortedSignal = new AbortController().signal;
 var syncOptionsCache = new WeakMap;
-var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencySet = sharedCircularDepSet, addedDepsOut, removedDepsOut) => {
+var getSyncOptions = (data) => {
+  let cached = syncOptionsCache.get(data);
+  if (!cached) {
+    cached = { signal: neverAbortedSignal, storeId: data.id };
+    syncOptionsCache.set(data, cached);
+  }
+  return cached;
+};
+var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencySet = data.circularDepSet, depsChangeOut) => {
   const currentDependencies = data.stateDependencies.get(selector);
   const updatedDepsArray = [];
   let depsChanged = false;
   let evaluationComplete = false;
+  const latestEvalContext = data.latestEvalContext;
   const prevCtx = latestEvalContext.get(selector);
   if (prevCtx)
     prevCtx.revoked = true;
@@ -418,34 +430,33 @@ var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencyS
   }
   circularDependencySet.add(selector);
   try {
-    const prev = data.abortControllers.get(selector);
     let options;
-    if (prev === false) {
-      let cached = syncOptionsCache.get(data);
-      if (!cached) {
-        cached = { signal: neverAbortedSignal, storeId: data.id };
-        syncOptionsCache.set(data, cached);
-      }
-      options = cached;
+    if (selector.get.length < 2) {
+      options = getSyncOptions(data);
     } else {
-      if (prev)
-        prev.abort();
-      let controller;
-      const myEvalCtx = evalCtx;
-      options = {
-        storeId: data.id,
-        get signal() {
-          if (!controller) {
-            controller = new AbortController;
-            if (myEvalCtx.revoked) {
-              controller.abort();
-            } else {
-              data.abortControllers.set(selector, controller);
+      const prev = data.abortControllers.get(selector);
+      if (prev === false) {
+        options = getSyncOptions(data);
+      } else {
+        if (prev)
+          prev.abort();
+        let controller;
+        const myEvalCtx = evalCtx;
+        options = {
+          storeId: data.id,
+          get signal() {
+            if (!controller) {
+              controller = new AbortController;
+              if (myEvalCtx.revoked) {
+                controller.abort();
+              } else {
+                data.abortControllers.set(selector, controller);
+              }
             }
+            return controller.signal;
           }
-          return controller.signal;
-        }
-      };
+        };
+      }
     }
     let allDepsThisEval;
     let result;
@@ -470,8 +481,6 @@ var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencyS
         return value;
       }, options);
     } catch (error) {
-      if (error instanceof NeedsInitError)
-        throw error;
       if (error instanceof SuspendAndWaitForResolveError) {
         result = error;
       } else if (error instanceof SelectorEvaluationError) {
@@ -492,22 +501,28 @@ var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencyS
           updatedDependencies.add(dep);
         }
       }
-      const prev2 = currentDependencies ?? new Set;
+      const prev = currentDependencies ?? new Set;
       for (const state of updatedDependencies) {
-        if (!prev2.has(state)) {
+        if (!prev.has(state)) {
           const set = getOrInitDependentsSet(state, data);
           set.add(selector);
-          if (addedDepsOut)
-            addedDepsOut.add(state);
+          if (depsChangeOut) {
+            if (!depsChangeOut.added)
+              depsChangeOut.added = new Set;
+            depsChangeOut.added.add(state);
+          }
         }
       }
       if (!isAsyncResult) {
-        for (const state of prev2) {
+        for (const state of prev) {
           if (!updatedDependencies.has(state)) {
             const set = getOrInitDependentsSet(state, data);
             set.delete(selector);
-            if (removedDepsOut)
-              removedDepsOut.add(state);
+            if (depsChangeOut) {
+              if (!depsChangeOut.removed)
+                depsChangeOut.removed = new Set;
+              depsChangeOut.removed.add(state);
+            }
           }
         }
       }
@@ -534,7 +549,7 @@ var handleSelectorResult = (value, selector, data) => {
       const initializedAtomsSet = new Set;
       const res = initSelector(selector, data, initializedAtomsSet);
       if (initializedAtomsSet.size > 0) {
-        propagateUpdatedAtoms([...initializedAtomsSet], data);
+        propagateAtomUpdate([...initializedAtomsSet], data);
       }
       return res;
     }).catch(() => {
@@ -556,12 +571,16 @@ var handleSelectorResult = (value, selector, data) => {
         pendingAsyncDeps.delete(value);
         const currentDeps = data.stateDependencies.get(selector);
         if (currentDeps) {
+          const selectorIsLive = isLive(selector, data);
           for (const dep of currentDeps) {
             if (!evalDeps.has(dep)) {
               currentDeps.delete(dep);
               const dependents2 = data.stateDependents.get(dep);
               if (dependents2)
                 dependents2.delete(selector);
+              if (selectorIsLive) {
+                onLiveDependencyRemoved(dep, data);
+              }
               unmountOrphanedDeps(dep, data);
             }
           }
@@ -579,11 +598,13 @@ var handleSelectorResult = (value, selector, data) => {
     });
     return value;
   } else {
-    data.abortControllers.set(selector, false);
+    if (selector.get.length >= 2) {
+      data.abortControllers.set(selector, false);
+    }
     return value;
   }
 };
-var initSelectorDirect = (selector, data, initializedAtomsSet, circularDependencySet) => {
+var initSelector = (selector, data, initializedAtomsSet, circularDependencySet = data.circularDepSet) => {
   const existingValue = data.values.get(selector);
   const updatedValue = evaluate(selector, data, initializedAtomsSet, circularDependencySet);
   const areEqual = isPromiseLike(existingValue) || isPromiseLike(updatedValue) ? existingValue === updatedValue : selector.equal(existingValue, updatedValue);
@@ -594,56 +615,6 @@ var initSelectorDirect = (selector, data, initializedAtomsSet, circularDependenc
     return true;
   }
 };
-var initSelectorTrampoline = (selector, data, initializedAtomsSet, circularDependencySet) => {
-  const stack = [selector];
-  const inStack = new Set([selector]);
-  while (stack.length > 0) {
-    const current = stack[stack.length - 1];
-    if (data.values.has(current)) {
-      stack.pop();
-      inStack.delete(current);
-      continue;
-    }
-    try {
-      initSelectorDirect(current, data, initializedAtomsSet, circularDependencySet);
-      stack.pop();
-      inStack.delete(current);
-    } catch (e) {
-      if (e instanceof NeedsInitError) {
-        if (inStack.has(e.selector)) {
-          throw new SelectorCircularDependencyError;
-        }
-        stack.push(e.selector);
-        inStack.add(e.selector);
-      } else {
-        throw e;
-      }
-    }
-  }
-};
-var initSelector = (selector, data, initializedAtomsSet, circularDependencySet = sharedCircularDepSet) => {
-  const isTopLevel = _evalDepth === 0 && !_inTrampoline;
-  _evalDepth++;
-  const existingValue = data.values.get(selector);
-  try {
-    return initSelectorDirect(selector, data, initializedAtomsSet, circularDependencySet);
-  } catch (e) {
-    if (e instanceof NeedsInitError && isTopLevel) {
-      _inTrampoline = true;
-      try {
-        initSelectorTrampoline(selector, data, initializedAtomsSet, circularDependencySet);
-      } finally {
-        _inTrampoline = false;
-      }
-      const newValue = data.values.get(selector);
-      const areEqual = isPromiseLike(existingValue) || isPromiseLike(newValue) ? existingValue === newValue : selector.equal(existingValue, newValue);
-      return !areEqual;
-    }
-    throw e;
-  } finally {
-    _evalDepth--;
-  }
-};
 var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
   let tmpValue;
   try {
@@ -657,23 +628,18 @@ var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
 };
 
 // src/lib/propagateUpdatedAtoms.ts
-var reEvaluteSelector = (selector, data, updatedAtoms) => {
-  const existingValue = data.values.get(selector);
-  const addedDeps = new Set;
-  const removedDeps = new Set;
+var reEvaluateSelector = (selector, data, updatedAtoms, depsChange, existingValue) => {
   try {
-    const rawValue = evaluateSelector(selector, data, updatedAtoms, undefined, addedDeps, removedDeps);
-    const udpatedValue = handleSelectorResult(rawValue, selector, data);
-    const areEqual = isPromiseLike(existingValue) || isPromiseLike(udpatedValue) ? existingValue === udpatedValue : selector.equal(existingValue, udpatedValue, updatedAtoms);
-    if (areEqual) {
-      return [false, false, undefined, addedDeps, removedDeps];
-    } else {
-      setValueInData(selector, udpatedValue, data);
-      return [true, false, undefined, addedDeps, removedDeps];
-    }
-  } catch (error) {
+    const rawValue = evaluateSelector(selector, data, updatedAtoms, undefined, depsChange);
+    const updatedValue = handleSelectorResult(rawValue, selector, data);
+    const areEqual = isPromiseLike(existingValue) || isPromiseLike(updatedValue) ? existingValue === updatedValue : selector.equal(existingValue, updatedValue, updatedAtoms);
+    if (areEqual)
+      return false;
+    setValueInData(selector, updatedValue, data);
+    return true;
+  } catch {
     data.values.delete(selector);
-    return [true, true, error, addedDeps, removedDeps];
+    return true;
   }
 };
 var callSubscribers = (subscriptions, families) => {
@@ -715,7 +681,7 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now()) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now(), evaluatedSelectors) => {
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
@@ -736,7 +702,7 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, false, evaluatedSelectors);
   if (families.size > 0 && data.scopes && data.scopes.size > 0) {
     const scopeFamilies = new Map;
     for (const family of families.keys()) {
@@ -753,12 +719,12 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       }
     }
     for (const [scope, familiesInScope] of scopeFamilies) {
-      propagateUpdatedAtoms(familiesInScope, scope, undefined, undefined, false, timestamp, true);
+      propagateInScope(familiesInScope, scope, false, evaluatedSelectors);
     }
   }
 };
-var propagateUpdatedAtoms = (atoms, data, subscriptions, families, isRecursive = false, timestamp = performance.now(), selectorsOnly = false, isInitOnly = false) => {
-  if (atoms.length === 1 && !isRecursive && !selectorsOnly) {
+var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
+  if (atoms.length === 1) {
     const atom = atoms[0];
     if (!isFamilyAtom(atom) && !isAtomFamily(atom)) {
       const dependents = data.stateDependents.get(atom);
@@ -771,24 +737,21 @@ var propagateUpdatedAtoms = (atoms, data, subscriptions, families, isRecursive =
       }
     }
   }
-  if (!subscriptions)
-    subscriptions = new Set;
-  if (!families)
-    families = new Map;
+  const subscriptions = new Set;
+  const families = new Map;
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
-    if (!selectorsOnly) {
-      addSetToSet(data.subscriptions.get(atom), subscriptions);
-      if (isFamilyAtom(atom)) {
-        if (!families.has(atom.family)) {
-          families.set(atom.family, new Set);
-        }
-        families.get(atom.family).add(atom);
+    addSetToSet(data.subscriptions.get(atom), subscriptions);
+    if (isFamilyAtom(atom)) {
+      if (!families.has(atom.family)) {
+        families.set(atom.family, new Set);
       }
+      families.get(atom.family).add(atom);
     }
   }
   if (families.size > 0) {
+    const timestamp = performance.now();
     for (const [family, familyAtoms] of families) {
       addSetToSet(data.stateDependents.get(family), selectors);
       addSetToSet(data.subscriptions.get(family), subscriptions);
@@ -797,96 +760,308 @@ var propagateUpdatedAtoms = (atoms, data, subscriptions, families, isRecursive =
       addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
     }
   }
-  if (!isRecursive) {
-    propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly);
-    if (data.scopes && data.scopes.size > 0) {
-      if (atoms.length === 1) {
-        const atom = atoms[0];
-        const shadowingScopes = isAtomFamily(atom) ? undefined : data.scopeValueIndex.get(atom);
-        for (const [, scope] of data.scopes) {
-          if (!shadowingScopes || !shadowingScopes.has(scope)) {
-            propagateUpdatedAtoms(atoms, scope, undefined, undefined, false, timestamp, true, isInitOnly);
-          }
-        }
+  if (data.scopes && data.scopes.size > 0) {
+    for (const atom of atoms) {
+      if (isAtomFamily(atom) && !families.has(atom)) {
+        recursivelyUpdateIndexes(data, atom);
+      }
+    }
+  }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, evaluatedSelectors);
+  if (data.scopes && data.scopes.size > 0) {
+    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
+  }
+};
+var propagateInScope = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
+  const subscriptions = new Set;
+  const families = new Map;
+  const selectors = new Set;
+  for (const atom of atoms) {
+    addSetToSet(data.stateDependents.get(atom), selectors);
+  }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, evaluatedSelectors);
+  if (data.scopes && data.scopes.size > 0) {
+    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
+  }
+};
+var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
+  if (atoms.length === 1) {
+    const atom = atoms[0];
+    const shadowingScopes = isAtomFamily(atom) ? undefined : data.scopeValueIndex.get(atom);
+    for (const [, scope] of data.scopes) {
+      if (!shadowingScopes || !shadowingScopes.has(scope)) {
+        propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
+      }
+    }
+    return;
+  }
+  let anyShadowed = false;
+  let atomShadows;
+  for (const atom of atoms) {
+    if (!isAtomFamily(atom)) {
+      const s = data.scopeValueIndex.get(atom);
+      if (s && s.size > 0) {
+        if (!atomShadows)
+          atomShadows = new Map;
+        atomShadows.set(atom, s);
+        anyShadowed = true;
+      }
+    }
+  }
+  if (!anyShadowed) {
+    for (const [, scope] of data.scopes) {
+      propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
+    }
+    return;
+  }
+  for (const [, scope] of data.scopes) {
+    const atomsToUpdateInScope = [];
+    for (const atom of atoms) {
+      if (isAtomFamily(atom)) {
+        atomsToUpdateInScope.push(atom);
       } else {
-        let anyShadowed = false;
-        let atomShadows;
-        for (const atom of atoms) {
-          if (!isAtomFamily(atom)) {
-            const s = data.scopeValueIndex.get(atom);
-            if (s && s.size > 0) {
-              if (!atomShadows)
-                atomShadows = new Map;
-              atomShadows.set(atom, s);
-              anyShadowed = true;
-            }
-          }
-        }
-        if (!anyShadowed) {
-          for (const [, scope] of data.scopes) {
-            propagateUpdatedAtoms(atoms, scope, undefined, undefined, false, timestamp, true, isInitOnly);
-          }
-        } else {
-          for (const [, scope] of data.scopes) {
-            const atomsToUpdateInScope = [];
-            for (const atom of atoms) {
-              if (isAtomFamily(atom)) {
-                atomsToUpdateInScope.push(atom);
-              } else {
-                const s = atomShadows.get(atom);
-                if (!s || !s.has(scope)) {
-                  atomsToUpdateInScope.push(atom);
-                }
-              }
-            }
-            if (atomsToUpdateInScope.length > 0) {
-              propagateUpdatedAtoms(atomsToUpdateInScope, scope, undefined, undefined, false, timestamp, true, isInitOnly);
-            }
-          }
+        const s = atomShadows.get(atom);
+        if (!s || !s.has(scope)) {
+          atomsToUpdateInScope.push(atom);
         }
       }
     }
+    if (atomsToUpdateInScope.length > 0) {
+      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, evaluatedSelectors);
+    }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false) => {
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, evaluatedSelectors) => {
   const updatedInitializedAtoms = new Set(updatedAtoms);
   if (selectors.size > 0) {
-    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly);
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
   }
   if (subscriptions.size > 0) {
     callSubscribers(subscriptions, families);
   }
 };
-var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
-  let currentSelectors = selectors;
-  while (currentSelectors.size > 0) {
-    const selectorsForNextPass = new Set;
-    for (const selector of currentSelectors) {
-      const currentValue = data.values.get(selector);
-      if (isPromiseLike(currentValue) && isInitOnly) {
+var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors) => {
+  const closure = new Set(seeds);
+  {
+    const stack = [...seeds];
+    while (stack.length > 0) {
+      const s = stack.pop();
+      const downstream = data.stateDependents.get(s);
+      if (downstream) {
+        for (const d of downstream) {
+          if (!closure.has(d)) {
+            closure.add(d);
+            stack.push(d);
+          }
+        }
+      }
+    }
+  }
+  const pending = new Map;
+  const ready = [];
+  for (const s of closure) {
+    const deps = data.stateDependencies.get(s);
+    let count = 0;
+    if (deps) {
+      for (const d of deps) {
+        if (closure.has(d))
+          count++;
+      }
+    }
+    pending.set(s, count);
+    if (count === 0)
+      ready.push(s);
+  }
+  const needsEval = new Set(seeds);
+  let graphMutated = false;
+  const advance = (selector, propagateChange) => {
+    const downstream = data.stateDependents.get(selector);
+    if (!downstream)
+      return;
+    for (const d of downstream) {
+      if (!closure.has(d)) {
+        if (propagateChange) {
+          graphMutated = true;
+          closure.add(d);
+          pending.set(d, 0);
+          needsEval.add(d);
+          ready.push(d);
+        }
         continue;
       }
+      const c = (pending.get(d) ?? 0) - 1;
+      pending.set(d, c);
+      if (propagateChange)
+        needsEval.add(d);
+      if (c <= 0)
+        ready.push(d);
+    }
+  };
+  const depsChange = {};
+  let head = 0;
+  while (head < ready.length) {
+    const selector = ready[head++];
+    if (evaluatedSelectors !== undefined && evaluatedSelectors.has(selector)) {
+      advance(selector, false);
+      continue;
+    }
+    const currentValue = data.values.get(selector);
+    if (isPromiseLike(currentValue) && isInitOnly) {
+      advance(selector, false);
+      continue;
+    }
+    if (!needsEval.has(selector)) {
+      advance(selector, false);
+      continue;
+    }
+    const dependents = data.stateDependents.get(selector);
+    const subscribers = data.subscriptions.get(selector);
+    if (!isPromiseLike(currentValue) && (!dependents || dependents.size === 0) && (!subscribers || subscribers.size === 0)) {
+      data.values.delete(selector);
+      advance(selector, false);
+      continue;
+    }
+    depsChange.added = undefined;
+    depsChange.removed = undefined;
+    const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+    if (evaluatedSelectors !== undefined)
+      evaluatedSelectors.add(selector);
+    const added = depsChange.added;
+    const removed = depsChange.removed;
+    if (added || removed) {
+      graphMutated = true;
+      if (isLive(selector, data)) {
+        if (added) {
+          for (const dep of added) {
+            onLiveDependencyAdded(dep, data);
+            mountTransitiveDeps(dep, data);
+          }
+        }
+        if (removed) {
+          for (const dep of removed) {
+            onLiveDependencyRemoved(dep, data);
+            unmountOrphanedDeps(dep, data);
+          }
+        }
+      }
+    }
+    advance(selector, wasValueUpdated);
+    if (wasValueUpdated && subscribers) {
+      addSetToSet(subscribers, collectedSubscribers);
+    }
+  }
+  if (!graphMutated)
+    return;
+  let stranded;
+  for (const s of closure) {
+    if (needsEval.has(s) && (pending.get(s) ?? 0) > 0) {
+      if (!stranded)
+        stranded = new Set;
+      stranded.add(s);
+    }
+  }
+  if (!stranded)
+    return;
+  let work = stranded;
+  while (work.size > 0) {
+    const next = new Set;
+    for (const selector of work) {
+      const currentValue = data.values.get(selector);
+      if (isPromiseLike(currentValue) && isInitOnly)
+        continue;
       const dependents = data.stateDependents.get(selector);
       const subscribers = data.subscriptions.get(selector);
       if (!isPromiseLike(currentValue) && (!dependents || dependents.size === 0) && (!subscribers || subscribers.size === 0)) {
         data.values.delete(selector);
-      } else {
-        const [wasValueUpdated, didEvalCrash, error, addedDeps, removedDeps] = reEvaluteSelector(selector, data, updatedInitializedAtoms);
-        if ((addedDeps.size > 0 || removedDeps.size > 0) && isTransitivelySubscribed(selector, data)) {
-          for (const dep of addedDeps) {
+        continue;
+      }
+      depsChange.added = undefined;
+      depsChange.removed = undefined;
+      const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+      if (evaluatedSelectors !== undefined)
+        evaluatedSelectors.add(selector);
+      const added = depsChange.added;
+      const removed = depsChange.removed;
+      if ((added || removed) && isLive(selector, data)) {
+        if (added) {
+          for (const dep of added) {
+            onLiveDependencyAdded(dep, data);
             mountTransitiveDeps(dep, data);
           }
-          for (const dep of removedDeps) {
+        }
+        if (removed) {
+          for (const dep of removed) {
+            onLiveDependencyRemoved(dep, data);
             unmountOrphanedDeps(dep, data);
           }
         }
-        if (!wasValueUpdated)
-          continue;
-        addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
-        addSetToSet(subscribers, collectedSubscribers);
+      }
+      if (wasValueUpdated) {
+        if (subscribers)
+          addSetToSet(subscribers, collectedSubscribers);
+        const downstream = data.stateDependents.get(selector);
+        if (downstream) {
+          for (const d of downstream)
+            next.add(d);
+        }
       }
     }
-    currentSelectors = selectorsForNextPass;
+    work = next;
+  }
+};
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false, evaluatedSelectors) => {
+  if (selectors.size === 0)
+    return;
+  let downstreamSeeds;
+  const depsChange = {};
+  for (const selector of selectors) {
+    if (evaluatedSelectors !== undefined && evaluatedSelectors.has(selector)) {
+      continue;
+    }
+    const currentValue = data.values.get(selector);
+    if (isPromiseLike(currentValue) && isInitOnly)
+      continue;
+    const dependents = data.stateDependents.get(selector);
+    const subscribers = data.subscriptions.get(selector);
+    if (!isPromiseLike(currentValue) && (!dependents || dependents.size === 0) && (!subscribers || subscribers.size === 0)) {
+      data.values.delete(selector);
+      continue;
+    }
+    depsChange.added = undefined;
+    depsChange.removed = undefined;
+    const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+    if (evaluatedSelectors !== undefined)
+      evaluatedSelectors.add(selector);
+    const added = depsChange.added;
+    const removed = depsChange.removed;
+    if ((added || removed) && isLive(selector, data)) {
+      if (added) {
+        for (const dep of added) {
+          onLiveDependencyAdded(dep, data);
+          mountTransitiveDeps(dep, data);
+        }
+      }
+      if (removed) {
+        for (const dep of removed) {
+          onLiveDependencyRemoved(dep, data);
+          unmountOrphanedDeps(dep, data);
+        }
+      }
+    }
+    if (!wasValueUpdated)
+      continue;
+    if (subscribers)
+      addSetToSet(subscribers, collectedSubscribers);
+    const downstream = data.stateDependents.get(selector);
+    if (downstream && downstream.size > 0) {
+      if (!downstreamSeeds)
+        downstreamSeeds = new Set;
+      for (const d of downstream)
+        downstreamSeeds.add(d);
+    }
+  }
+  if (downstreamSeeds && downstreamSeeds.size > 0) {
+    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
   }
 };
 
@@ -894,11 +1069,19 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
 var isFunction = (value) => typeof value === "function";
 
 // src/lib/setAtom.ts
-var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
-  const emptyAtomPromise = currentValue?.__isEmptyAtomPromise__ ? currentValue : currentValue?.__emptyAtomPromiseOrigin__ ?? null;
-  if (emptyAtomPromise) {
-    promise.__emptyAtomPromiseOrigin__ = emptyAtomPromise;
+var resolvePendingDefault = (atom, data, value) => {
+  let cur = data;
+  while (cur) {
+    const entry = cur.pendingDefaults.get(atom);
+    if (entry) {
+      entry.resolve(value);
+      cur.pendingDefaults.delete(atom);
+      return;
+    }
+    cur = "parent" in cur ? cur.parent : undefined;
   }
+};
+var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
   setValueInData(atom, promise, data);
   promise.then((resolvedValue) => {
     if (data.values.get(atom) !== promise)
@@ -906,15 +1089,13 @@ var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
     setValueInData(atom, resolvedValue, data);
     if (atom.onSet && !skipOnSet)
       atom.onSet(resolvedValue, data);
-    if (emptyAtomPromise) {
-      emptyAtomPromise.__resolveEmptyAtomPromise__(resolvedValue);
-    }
-    propagateUpdatedAtoms([atom], data);
+    resolvePendingDefault(atom, data, resolvedValue);
+    propagateAtomUpdate([atom], data);
   }).catch(() => {
     if (data.values.get(atom) !== promise)
       return;
     setValueInData(atom, currentValue, data);
-    propagateUpdatedAtoms([atom], data);
+    propagateAtomUpdate([atom], data);
   });
 };
 var setAtom = (atom, newValue, data, skipOnSet = false) => {
@@ -936,9 +1117,9 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
     handlePromise(atom, promise, currentValue, data, skipOnSet);
     if (initializedAtomsSet && initializedAtomsSet.size > 0) {
       initializedAtomsSet.add(atom);
-      propagateUpdatedAtoms([...initializedAtomsSet], data);
+      propagateAtomUpdate([...initializedAtomsSet], data);
     } else {
-      propagateUpdatedAtoms([atom], data);
+      propagateAtomUpdate([atom], data);
     }
     return promise;
   }
@@ -949,14 +1130,12 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
   syncValue = setValueInData(atom, syncValue, data);
   if (atom.onSet && !skipOnSet)
     atom.onSet(syncValue, data);
-  if (currentValue?.__isEmptyAtomPromise__) {
-    currentValue.__resolveEmptyAtomPromise__(syncValue);
-  }
+  resolvePendingDefault(atom, data, syncValue);
   if (initializedAtomsSet && initializedAtomsSet.size > 0) {
     initializedAtomsSet.add(atom);
-    propagateUpdatedAtoms([...initializedAtomsSet], data);
+    propagateAtomUpdate([...initializedAtomsSet], data);
   } else {
-    propagateUpdatedAtoms([atom], data);
+    propagateAtomUpdate([atom], data);
   }
   return syncValue;
 };
@@ -964,12 +1143,11 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
 // src/lib/initAtom.ts
 var getAtomInitValue = (atom, data, initializedAtomsSet) => {
   if (atom.defaultValue === undefined) {
-    let promiseResolve;
-    const promise = new Promise((resolve) => {
-      promiseResolve = resolve;
+    let resolve;
+    const promise = new Promise((r) => {
+      resolve = r;
     });
-    promise.__isEmptyAtomPromise__ = true;
-    promise.__resolveEmptyAtomPromise__ = promiseResolve;
+    data.pendingDefaults.set(atom, { promise, resolve });
     return promise;
   } else if (typeof atom.defaultValue === "function") {
     const value = atom.defaultValue();
@@ -978,7 +1156,7 @@ var getAtomInitValue = (atom, data, initializedAtomsSet) => {
         if (data.values.get(atom) !== value)
           return;
         setValueInData(atom, resolvedValue, data);
-        propagateUpdatedAtoms([atom], data);
+        propagateAtomUpdate([atom], data);
       }, () => {
         if (data.values.get(atom) === value) {
           data.values.delete(atom);
@@ -1007,7 +1185,7 @@ function getState(state, data, initializedAtomsSet, circularDependencySet) {
   if (data.values.has(state))
     return data.values.get(state);
   if (isAtom(state)) {
-    if ("parent" in data)
+    if (data.parent)
       return getState(state, data.parent, initializedAtomsSet, circularDependencySet);
     if (isFamilyAtom(state)) {
       const familyValue = data.values.get(state.family);
@@ -1022,14 +1200,11 @@ function getState(state, data, initializedAtomsSet, circularDependencySet) {
     return data.values.get(state);
   }
   if (isSelector(state)) {
-    if (_evalDepth >= MAX_EVAL_DEPTH) {
-      throw new NeedsInitError(state);
-    }
     initSelector(state, data, initializedAtomsSet, circularDependencySet);
     return data.values.get(state);
   }
   if (isAtomFamily(state)) {
-    if ("parent" in data) {
+    if (data.parent) {
       const closestData = findClosestStoreWithAtomInitialized(state, data);
       return getState(state, closestData, initializedAtomsSet, circularDependencySet);
     }
@@ -1047,7 +1222,7 @@ function getState(state, data, initializedAtomsSet, circularDependencySet) {
   throw new Error("Invalid object passed to get");
 }
 var findClosestStoreWithAtomInitialized = (atom, data) => {
-  if ("parent" in data === false)
+  if (!data.parent)
     return data;
   if (data.values.has(atom))
     return data;
@@ -1077,16 +1252,16 @@ var resolveReactive = (value, data) => {
 // src/lib/createStoreData.ts
 var nextId = 0;
 var generateId = () => "__valdres_store_" + nextId++;
-function makeLazyGetter(key) {
+function makeLazyGetter(key, factory = () => new WeakMap) {
   return {
     get() {
-      const map = new WeakMap;
+      const value = factory();
       Object.defineProperty(this, key, {
-        value: map,
+        value,
         writable: true,
         configurable: true
       });
-      return map;
+      return value;
     },
     configurable: true
   };
@@ -1098,8 +1273,11 @@ Object.defineProperties(lazyProto, {
   stateDependents: makeLazyGetter("stateDependents"),
   stateDependencies: makeLazyGetter("stateDependencies"),
   mounts: makeLazyGetter("mounts"),
+  liveDependentCount: makeLazyGetter("liveDependentCount"),
   abortControllers: makeLazyGetter("abortControllers"),
-  lastValueWriteAt: makeLazyGetter("lastValueWriteAt")
+  lastValueWriteAt: makeLazyGetter("lastValueWriteAt"),
+  circularDepSet: makeLazyGetter("circularDepSet", () => new WeakSet),
+  latestEvalContext: makeLazyGetter("latestEvalContext")
 });
 function createStoreData(id, parent, options) {
   const data = Object.create(lazyProto);
@@ -1107,6 +1285,7 @@ function createStoreData(id, parent, options) {
   data.values = new WeakMap;
   data.scopes = new Map;
   data.scopeValueIndex = new WeakMap;
+  data.pendingDefaults = new WeakMap;
   if (options?.batchUpdates) {
     data.batchUpdates = true;
   }
@@ -1133,10 +1312,10 @@ var resetAtom = (atom, data) => {
   let value = getAtomInitValue(atom, data, initializedAtomsSet);
   setValueInData(atom, value, data);
   if (!isPromiseLike(value)) {
-    propagateUpdatedAtoms([atom], data);
+    propagateAtomUpdate([atom], data);
   }
   if (initializedAtomsSet.size > 0) {
-    throw new Error("Todo - propagateUpdatedAtoms on reset");
+    throw new Error("Todo - propagateAtomUpdate on reset");
   }
   return value;
 };
@@ -1185,6 +1364,7 @@ var unsubscribe = (state, subscription, data) => {
         deleteMaxAgeCleanup(data, state);
       }
       data.subscriptions.delete(state);
+      onLastDirectSubscriber(state, data);
       unmountOrphanedDeps(state, data);
       cleanupOrphanedDeps(state, data);
     }
@@ -1194,7 +1374,7 @@ var cleanupOrphanedDeps = (state, data, visited = new Set) => {
   if (visited.has(state))
     return;
   visited.add(state);
-  if (isTransitivelySubscribed(state, data))
+  if (isLive(state, data))
     return;
   const deps = data.stateDependencies.get(state);
   if (deps) {
@@ -1223,7 +1403,7 @@ var initSubscribers = (state, data) => {
   return set;
 };
 var installMaxAgeTimer = (state, data) => {
-  if (!state.maxAge)
+  if (state.maxAge === undefined)
     return;
   const globalState = isGlobalAtom(state) ? state : undefined;
   const existing = globalState?.maxAgeInterval;
@@ -1233,7 +1413,7 @@ var installMaxAgeTimer = (state, data) => {
     for (const s of globalState.stores) {
       if (s !== data && s.values.has(metaAtom2)) {
         setValueInData(metaAtom2, s.values.get(metaAtom2), data);
-        propagateUpdatedAtoms([metaAtom2], data);
+        propagateAtomUpdate([metaAtom2], data);
         break;
       }
     }
@@ -1272,11 +1452,11 @@ var installMaxAgeTimer = (state, data) => {
     if (globalState) {
       for (const store of globalState.stores) {
         setValueInData(metaAtom, meta, store);
-        propagateUpdatedAtoms([metaAtom], store);
+        propagateAtomUpdate([metaAtom], store);
       }
     } else {
       setValueInData(metaAtom, meta, data);
-      propagateUpdatedAtoms([metaAtom], data);
+      propagateAtomUpdate([metaAtom], data);
     }
   };
   const isPastStaleIfErrorWindow = () => {
@@ -1287,11 +1467,11 @@ var installMaxAgeTimer = (state, data) => {
     if (globalState) {
       for (const store of globalState.stores) {
         setValueInData(atom, val, store);
-        propagateUpdatedAtoms([atom], store);
+        propagateAtomUpdate([atom], store);
       }
     } else {
       setValueInData(atom, val, data);
-      propagateUpdatedAtoms([atom], data);
+      propagateAtomUpdate([atom], data);
     }
   };
   const getValueStore = () => {
@@ -1421,14 +1601,18 @@ var installMaxAgeTimer = (state, data) => {
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
   let parentUnsubscribe;
-  if ("parent" in data && (!data.values.has(state) && isAtom(state) || isAtomFamily(state))) {
+  let dropDelegate;
+  if (data.parent && (!data.values.has(state) && isAtom(state) || isAtomFamily(state))) {
     const originalCallback = callback;
     parentUnsubscribe = subscribe(state, originalCallback, requireDeepEqualCheckBeforeCallback, data.parent);
-    callback = (arg) => {
+    dropDelegate = () => {
       if (parentUnsubscribe) {
         parentUnsubscribe();
         parentUnsubscribe = undefined;
       }
+    };
+    callback = (arg) => {
+      dropDelegate();
       originalCallback(arg);
     };
   } else if (!data.values.has(state) && isAtom(state)) {
@@ -1450,20 +1634,23 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
     subscription = {
       callback,
       state,
-      requireDeepEqualCheckBeforeCallback
+      requireDeepEqualCheckBeforeCallback,
+      reRoot: dropDelegate
     };
   } else {
     subscription = {
       callback,
-      requireDeepEqualCheckBeforeCallback
+      requireDeepEqualCheckBeforeCallback,
+      reRoot: dropDelegate
     };
   }
   subscribers.add(subscription);
   if (subscribers.size === 1) {
-    if (isAtom(state) && state.maxAge) {
+    if (isAtom(state) && state.maxAge !== undefined && !data.parent) {
       installMaxAgeTimer(state, data);
     }
     if (!isFamily(state)) {
+      onFirstDirectSubscriber(state, data);
       mountTransitiveDeps(state, data);
     }
   }
@@ -1478,8 +1665,8 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   };
 };
 
-// src/lib/setAtoms.ts
-var setAtoms = (pairs, data, initializedAtomsSet) => {
+// src/lib/writeAtoms.ts
+var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueue) => {
   const updatedAtoms = [];
   for (let [atom, value] of pairs) {
     const currentValue = getState(atom, data, initializedAtomsSet);
@@ -1487,8 +1674,12 @@ var setAtoms = (pairs, data, initializedAtomsSet) => {
     if (!areEqual) {
       updatedAtoms.push(atom);
       value = setValueInData(atom, value, data);
-      if (atom.onSet)
-        atom.onSet(value, data);
+      if (atom.onSet && !skipOnSet) {
+        if (onSetQueue)
+          onSetQueue.push([atom, value, data]);
+        else
+          atom.onSet(value, data);
+      }
     } else {
       setValueInData(atom, value, data);
     }
@@ -1498,8 +1689,14 @@ var setAtoms = (pairs, data, initializedAtomsSet) => {
       updatedAtoms.push(atom);
     }
   }
+  return updatedAtoms;
+};
+
+// src/lib/setAtoms.ts
+var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
+  const updatedAtoms = writeAtoms(pairs, data, initializedAtomsSet, skipOnSet);
   if (updatedAtoms.length > 0) {
-    propagateUpdatedAtoms(updatedAtoms, data);
+    propagateAtomUpdate(updatedAtoms, data);
   }
 };
 
@@ -1587,7 +1784,7 @@ class Transaction {
     } else {
       resolved = value;
     }
-    if (!atom.mutable && !isProd() && resolved !== null && (typeof resolved === "object" || typeof resolved === "function")) {
+    if (!atom.mutable && !IS_PROD && resolved !== null && (typeof resolved === "object" || typeof resolved === "function")) {
       resolved = deepFreeze(resolved);
     }
     this._atomMap.set(atom, resolved);
@@ -1651,6 +1848,9 @@ class Transaction {
   };
   parentScope = (callback) => {
     if (!this.parentTransaction) {
+      if (!this.data.parent) {
+        throw new Error("Cannot access parentScope on root store");
+      }
       this.parentTransaction = new Transaction(this.data.parent, undefined, this);
     }
     return this.parentTransaction.execute(callback, false);
@@ -1674,15 +1874,58 @@ class Transaction {
     }
   };
   commit = () => {
-    const initializedAtomsSet = new Set;
-    setAtoms(this._atomMap, this.data, initializedAtomsSet);
-    if (this.deleteSet?.size) {
-      deleteAtomFamilyAtoms(this.deleteSet, this.data);
-      propagateDeletedAtoms([...this.deleteSet], this.data);
+    if (!this._scopedTransactions) {
+      const initializedAtomsSet = new Set;
+      if (this._deleteSet?.size) {
+        const evaluatedSelectors2 = new Set;
+        const updatedAtoms = writeAtoms(this._atomMap, this.data, initializedAtomsSet);
+        if (updatedAtoms.length > 0) {
+          propagateAtomUpdate(updatedAtoms, this.data, false, evaluatedSelectors2);
+        }
+        deleteAtomFamilyAtoms(this._deleteSet, this.data);
+        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, evaluatedSelectors2);
+      } else {
+        setAtoms(this._atomMap, this.data, initializedAtomsSet);
+      }
+      return;
+    }
+    const plan = [];
+    this.collectStores(plan);
+    for (let i = plan.length - 1;i >= 0; i--) {
+      const entry = plan[i];
+      const txn = entry.txn;
+      entry.updatedAtoms = writeAtoms(txn._atomMap, entry.data, new Set, false, entry.onSets);
+      if (txn._deleteSet?.size) {
+        deleteAtomFamilyAtoms(txn._deleteSet, entry.data);
+        entry.deleted = [...txn._deleteSet];
+      }
     }
+    for (const entry of plan) {
+      for (const [atom, value, data] of entry.onSets) {
+        atom.onSet(value, data);
+      }
+    }
+    const evaluatedSelectors = new Set;
+    for (const { data, updatedAtoms, deleted } of plan) {
+      if (updatedAtoms.length > 0) {
+        propagateAtomUpdate(updatedAtoms, data, false, evaluatedSelectors);
+      }
+      if (deleted) {
+        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, evaluatedSelectors);
+      }
+    }
+  };
+  collectStores = (plan) => {
+    plan.push({
+      txn: this,
+      data: this.data,
+      updatedAtoms: [],
+      deleted: undefined,
+      onSets: []
+    });
     if (this._scopedTransactions) {
       for (const [, scopedTxn] of this._scopedTransactions) {
-        scopedTxn.commit();
+        scopedTxn.collectStores(plan);
       }
     }
   };
@@ -1759,6 +2002,8 @@ var isCachedValueStale = (state, data) => {
   const maxAge = atom.maxAge;
   if (maxAge === undefined)
     return false;
+  if (data.parent)
+    return false;
   if (isGlobalAtom(atom)) {
     if (atom.maxAgeInterval !== undefined)
       return false;
@@ -1813,7 +2058,7 @@ function storeFromStoreData(data, detach) {
       if (_initSet.size) {
         const atoms = [..._initSet];
         _initSet.clear();
-        propagateUpdatedAtoms(atoms, data, undefined, undefined, false, undefined, false, true);
+        propagateAtomUpdate(atoms, data, true);
       }
     }
     return res;
@@ -1874,11 +2119,13 @@ function storeFromStoreData(data, detach) {
         scopedStoreData = createStoreData(scopeId, data, data.batchUpdates ? { batchUpdates: true } : undefined);
         data.scopes.set(scopeId, scopedStoreData);
       }
+      const consumers = scopedStoreData.scopeConsumers;
+      const indexKeys = scopedStoreData.scopeIndexKeys;
       const detach2 = (expectedToDestroy = false) => {
-        scopedStoreData.scopeConsumers.delete(detach2);
-        if (scopedStoreData.scopeConsumers.size === 0) {
+        consumers.delete(detach2);
+        if (consumers.size === 0) {
           data.scopes.delete(scopeId);
-          for (const key of scopedStoreData.scopeIndexKeys) {
+          for (const key of indexKeys) {
             const set2 = data.scopeValueIndex.get(key);
             if (set2) {
               set2.delete(scopedStoreData);
@@ -1886,15 +2133,15 @@ function storeFromStoreData(data, detach) {
                 data.scopeValueIndex.delete(key);
             }
           }
-          scopedStoreData.scopeIndexKeys.clear();
+          indexKeys.clear();
           return true;
         }
         if (expectedToDestroy) {
-          console.warn(`Scope ${scopeId} still has ${scopedStoreData.scopeConsumers.size} consumers, will not detach`);
+          console.warn(`Scope ${scopeId} still has ${consumers.size} consumers, will not detach`);
         }
         return false;
       };
-      scopedStoreData.scopeConsumers.add(detach2);
+      consumers.add(detach2);
       const newStore = storeFromStoreData(data.scopes.get(scopeId), detach2);
       return newStore;
     }
@@ -1926,25 +2173,83 @@ function storeFromStoreData(data, detach) {
 }
 
 // src/lib/mountAtom.ts
-var isTransitivelySubscribed = (state, data, visited = new Set) => {
-  const stack = [state];
+var hasDirectSubscribers = (state, data) => {
+  const subs = data.subscriptions.get(state);
+  return !!subs && subs.size > 0;
+};
+var isLive = (state, data) => {
+  if (hasDirectSubscribers(state, data))
+    return true;
+  const count = data.liveDependentCount.get(state);
+  return !!count && count > 0;
+};
+var propagateLive = (root, data) => {
+  const stack = [root];
   while (stack.length > 0) {
     const current = stack.pop();
-    if (visited.has(current))
+    const deps = data.stateDependencies.get(current);
+    if (!deps)
       continue;
-    visited.add(current);
-    const subs = data.subscriptions.get(current);
-    if (subs && subs.size > 0)
-      return true;
-    const dependents = data.stateDependents.get(current);
-    if (dependents) {
-      for (const dep of dependents) {
-        if (!visited.has(dep))
-          stack.push(dep);
+    for (const dep of deps) {
+      const prev = data.liveDependentCount.get(dep) ?? 0;
+      data.liveDependentCount.set(dep, prev + 1);
+      if (prev === 0 && !hasDirectSubscribers(dep, data)) {
+        stack.push(dep);
       }
     }
   }
-  return false;
+};
+var propagateNotLive = (root, data) => {
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const deps = data.stateDependencies.get(current);
+    if (!deps)
+      continue;
+    for (const dep of deps) {
+      const prev = data.liveDependentCount.get(dep) ?? 0;
+      const next = prev - 1;
+      if (next <= 0) {
+        data.liveDependentCount.delete(dep);
+      } else {
+        data.liveDependentCount.set(dep, next);
+      }
+      if (prev === 1 && !hasDirectSubscribers(dep, data)) {
+        stack.push(dep);
+      }
+    }
+  }
+};
+var onFirstDirectSubscriber = (state, data) => {
+  const liveDepCount = data.liveDependentCount.get(state) ?? 0;
+  if (liveDepCount === 0) {
+    propagateLive(state, data);
+  }
+};
+var onLastDirectSubscriber = (state, data) => {
+  const liveDepCount = data.liveDependentCount.get(state) ?? 0;
+  if (liveDepCount === 0) {
+    propagateNotLive(state, data);
+  }
+};
+var onLiveDependencyAdded = (dep, data) => {
+  const prev = data.liveDependentCount.get(dep) ?? 0;
+  data.liveDependentCount.set(dep, prev + 1);
+  if (prev === 0 && !hasDirectSubscribers(dep, data)) {
+    propagateLive(dep, data);
+  }
+};
+var onLiveDependencyRemoved = (dep, data) => {
+  const prev = data.liveDependentCount.get(dep) ?? 0;
+  const next = prev - 1;
+  if (next <= 0) {
+    data.liveDependentCount.delete(dep);
+  } else {
+    data.liveDependentCount.set(dep, next);
+  }
+  if (prev === 1 && !hasDirectSubscribers(dep, data)) {
+    propagateNotLive(dep, data);
+  }
 };
 var mountAtom = (state, data) => {
   const onMountFn = state.__valdresOnMount ?? state.onMount;
@@ -1954,7 +2259,9 @@ var mountAtom = (state, data) => {
   data.mounts.set(state, mountEntry);
   const store = data.storeRef ?? storeFromStoreData(data);
   try {
-    mountEntry.cleanup = onMountFn(store, state);
+    const result = onMountFn(store, state);
+    if (typeof result === "function")
+      mountEntry.cleanup = result;
   } catch (error) {
     data.mounts.delete(state);
     throw error;
@@ -1969,14 +2276,20 @@ var unmountAtom = (state, data) => {
     mount.cleanup();
   }
 };
-var mountTransitiveDeps = (state, data, visited = new Set) => {
+var mountTransitiveDeps = (state, data, visited) => {
+  if (!state.__valdresOnMount && !state.onMount) {
+    const deps = data.stateDependencies.get(state);
+    if (!deps || deps.size === 0)
+      return;
+  }
+  const seen = visited ?? new Set;
   let firstError = null;
   const stack = [state];
   while (stack.length > 0) {
     const current = stack.pop();
-    if (visited.has(current))
+    if (seen.has(current))
       continue;
-    visited.add(current);
+    seen.add(current);
     if (current.__valdresOnMount || current.onMount) {
       try {
         mountAtom(current, data);
@@ -1988,7 +2301,7 @@ var mountTransitiveDeps = (state, data, visited = new Set) => {
     const deps = data.stateDependencies.get(current);
     if (deps) {
       for (const dep of deps) {
-        if (!visited.has(dep))
+        if (!seen.has(dep))
           stack.push(dep);
       }
     }
@@ -1997,16 +2310,22 @@ var mountTransitiveDeps = (state, data, visited = new Set) => {
     throw firstError.value;
   }
 };
-var unmountOrphanedDeps = (state, data, visited = new Set) => {
+var unmountOrphanedDeps = (state, data, visited) => {
+  if (!state.__valdresOnMount && !state.onMount) {
+    const deps = data.stateDependencies.get(state);
+    if (!deps || deps.size === 0)
+      return;
+  }
+  const seen = visited ?? new Set;
   let firstError = null;
   const stack = [state];
   while (stack.length > 0) {
     const current = stack.pop();
-    if (visited.has(current))
+    if (seen.has(current))
       continue;
-    visited.add(current);
+    seen.add(current);
     if ((current.__valdresOnMount || current.onMount) && data.mounts.has(current)) {
-      if (!isTransitivelySubscribed(current, data)) {
+      if (!isLive(current, data)) {
         try {
           unmountAtom(current, data);
         } catch (error) {
@@ -2018,7 +2337,7 @@ var unmountOrphanedDeps = (state, data, visited = new Set) => {
     const deps = data.stateDependencies.get(current);
     if (deps) {
       for (const dep of deps) {
-        if (!visited.has(dep))
+        if (!seen.has(dep))
           stack.push(dep);
       }
     }
@@ -2045,8 +2364,7 @@ var globalStore = Object.assign(store("valdres-global-store"), {
 // src/lib/globalAtom.ts
 var globalAtom = (defaultValue, options) => {
   const stores = new Set;
-  if (options.onSet)
-    throw new Error("onSet on globalAtom is currently not supported");
+  const userOnSet = options.onSet;
   const onInit = (setSelf2, data) => {
     setSelf2(globalStore.get(atom));
     stores.add(data);
@@ -2059,6 +2377,7 @@ var globalAtom = (defaultValue, options) => {
         }
       }
     }
+    userOnSet?.(newValue, currentStore);
   };
   let mountCount = 0;
   let userCleanup;
@@ -2091,7 +2410,7 @@ var globalAtom = (defaultValue, options) => {
     const snapshot = [...stores];
     const subscribedStores = [];
     for (const s of snapshot) {
-      if (isTransitivelySubscribed(atom, s)) {
+      if (isLive(atom, s)) {
         subscribedStores.push(s);
       }
     }
@@ -2116,14 +2435,14 @@ var globalAtom = (defaultValue, options) => {
       stores.delete(store2);
       store2.values.delete(atom);
       try {
-        propagateUpdatedAtoms([atom], store2);
+        propagateAtomUpdate([atom], store2);
       } catch (e) {
         recordError(e);
       }
     }
     for (const s of subscribedStores) {
       stores.add(s);
-      if (atom.maxAge && (s.subscriptions.get(atom)?.size ?? 0) > 0) {
+      if (atom.maxAge !== undefined && (s.subscriptions.get(atom)?.size ?? 0) > 0) {
         installMaxAgeTimer(atom, s);
       }
       try {
@@ -2149,9 +2468,7 @@ var globalAtom = (defaultValue, options) => {
     getSelf,
     resetSelf,
     detach,
-    get stores() {
-      return stores;
-    },
+    stores,
     maxAgeInterval: undefined
   };
   return atom;
@@ -2247,11 +2564,7 @@ var createAtomFamily = (defaultValue, options) => {
   const isFunctionDefault = !isSelectorFamilyDefault && typeof defaultValue === "function";
   const hasName = !!options?.name;
   const isGlobal = !!options?.global;
-  const atomFamily = (...args) => {
-    const key = familyKey(args);
-    const cached = map.get(key);
-    if (cached !== undefined)
-      return cached;
+  const build = (args, key) => {
     let dv;
     if (isSelectorFamilyDefault) {
       dv = defaultValue(...args);
@@ -2281,14 +2594,34 @@ var createAtomFamily = (defaultValue, options) => {
     map.set(key, familyAtom);
     return familyAtom;
   };
+  function atomFamily(a0) {
+    if (arguments.length === 1) {
+      const t = typeof a0;
+      if (t === "string" || t === "number" || t === "boolean") {
+        const cached2 = map.get(a0);
+        if (cached2 !== undefined)
+          return cached2;
+        return build([a0], a0);
+      }
+    }
+    const args = Array.prototype.slice.call(arguments);
+    const key = familyKey(args);
+    const cached = map.get(key);
+    if (cached !== undefined)
+      return cached;
+    return build(args, key);
+  }
   if (hasName)
     Object.defineProperty(atomFamily, "name", {
       value: options.name,
       writable: false
     });
-  return Object.assign(atomFamily, {
+  const callable = atomFamily;
+  return Object.assign(callable, {
     __valdresAtomFamilyMap: map,
-    release: (...args) => map.delete(familyKey(args)),
+    release: (...args) => {
+      map.delete(familyKey(args));
+    },
     equal
   });
 };
@@ -2389,11 +2722,10 @@ var selectorFamily = (callback, options) => {
     const cached = map.get(key);
     if (cached !== undefined)
       return cached;
-    const get = (selectorArgs) => callback(...args)(selectorArgs);
     const newSelector = {
       equal,
       ...options,
-      get,
+      get: callback(...args),
       family: selectorFamily2,
       familyArgs: args,
       familyArgsStringified: key,
@@ -2416,9 +2748,9 @@ var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 
 // src/index.ts
 if (globalThis.__valdres__) {
-  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.3"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.5"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.3";
+  globalThis.__valdres__ = "1.0.0-beta.5";
 }
 export {
   store,