valdres 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/index.js

@@ -97,10 +97,10 @@ var equal = (a, b, updatedAtomsSet) => {
 };
 
 // src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+var isAtom = (state) => state && Object.hasOwn(state, "defaultValue");
 
 // src/utils/isGlobalAtom.ts
-var isGlobalAtom = (state) => Object.hasOwn(state, "stores");
+var isGlobalAtom = (state) => state && Object.hasOwn(state, "stores");
 
 // src/utils/isSelector.ts
 var isSelector = (state) => state && Object.hasOwn(state, "get");
@@ -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,10 +152,8 @@ 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) => {
@@ -172,7 +173,7 @@ var trackScopeValue = (key, data) => {
 var setValueInData = (atom, value, data) => {
   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 {
@@ -180,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());
   }
@@ -275,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));
@@ -619,6 +628,14 @@ var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
 };
 
 // src/lib/propagateUpdatedAtoms.ts
+var notifyEntryFor = (notify, data) => {
+  let entry = notify.get(data);
+  if (entry === undefined) {
+    entry = { subscriptions: new Set, families: new Map };
+    notify.set(data, entry);
+  }
+  return entry;
+};
 var reEvaluateSelector = (selector, data, updatedAtoms, depsChange, existingValue) => {
   try {
     const rawValue = evaluateSelector(selector, data, updatedAtoms, undefined, depsChange);
@@ -665,6 +682,35 @@ var callSubscribers = (subscriptions, families) => {
   if (hasError)
     throw firstError;
 };
+var notifyDeferred = (notify) => {
+  let firstError;
+  let hasError = false;
+  for (const entry of notify.values()) {
+    if (entry.subscriptions.size > 0) {
+      try {
+        callSubscribers(entry.subscriptions, entry.families);
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+      }
+    }
+  }
+  if (hasError)
+    throw firstError;
+};
+var collectFamilyAtomsForNotify = (entry, changedByFamily) => {
+  for (const [family, atoms] of changedByFamily) {
+    let target = entry.families.get(family);
+    if (target === undefined) {
+      target = new Set;
+      entry.families.set(family, target);
+    }
+    for (const atom of atoms)
+      target.add(atom);
+  }
+};
 var addSetToSet = (fromSet, toSet) => {
   if (fromSet && fromSet.size > 0) {
     for (const item of fromSet) {
@@ -672,20 +718,24 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now()) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, deletedFamilyAtoms = new Map, timestamp = performance.now(), notify) => {
+  const notifyEntry = notify ? notifyEntryFor(notify, data) : undefined;
+  if (notifyEntry) {
+    subscriptions = notifyEntry.subscriptions;
+  }
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
     addSetToSet(data.subscriptions.get(atom), subscriptions);
     if (isFamilyAtom(atom)) {
-      if (!families.has(atom.family)) {
-        families.set(atom.family, new Set);
+      if (!deletedFamilyAtoms.has(atom.family)) {
+        deletedFamilyAtoms.set(atom.family, new Set);
       }
-      families.get(atom.family).add(atom);
+      deletedFamilyAtoms.get(atom.family).add(atom);
     }
   }
-  if (families.size > 0) {
-    for (const [family, familyAtoms] of families) {
+  if (deletedFamilyAtoms.size > 0) {
+    for (const [family, familyAtoms] of deletedFamilyAtoms) {
       addSetToSet(data.stateDependents.get(family), selectors);
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
@@ -693,10 +743,12 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
-  if (families.size > 0 && data.scopes && data.scopes.size > 0) {
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, deletedFamilyAtoms, false, notify);
+  if (notifyEntry)
+    collectFamilyAtomsForNotify(notifyEntry, deletedFamilyAtoms);
+  if (deletedFamilyAtoms.size > 0 && data.scopes && data.scopes.size > 0) {
     const scopeFamilies = new Map;
-    for (const family of families.keys()) {
+    for (const family of deletedFamilyAtoms.keys()) {
       const scopesWithFamily = data.scopeValueIndex.get(family);
       if (scopesWithFamily) {
         for (const scope of scopesWithFamily) {
@@ -710,11 +762,11 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       }
     }
     for (const [scope, familiesInScope] of scopeFamilies) {
-      propagateInScope(familiesInScope, scope);
+      propagateInScope(familiesInScope, scope, false, notify);
     }
   }
 };
-var propagateAtomUpdate = (atoms, data, isInitOnly = false) => {
+var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify) => {
   if (atoms.length === 1) {
     const atom = atoms[0];
     if (!isFamilyAtom(atom) && !isAtomFamily(atom)) {
@@ -722,28 +774,32 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false) => {
       if ((!dependents || dependents.size === 0) && (!data.scopes || data.scopes.size === 0)) {
         const subs = data.subscriptions.get(atom);
         if (subs && subs.size > 0) {
-          callSubscribers(subs);
+          if (notify)
+            addSetToSet(subs, notifyEntryFor(notify, data).subscriptions);
+          else
+            callSubscribers(subs);
         }
         return;
       }
     }
   }
-  const subscriptions = new Set;
-  const families = new Map;
+  const notifyEntry = notify ? notifyEntryFor(notify, data) : undefined;
+  const subscriptions = notifyEntry ? notifyEntry.subscriptions : new Set;
+  const updatedFamilyAtoms = new Map;
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
     addSetToSet(data.subscriptions.get(atom), subscriptions);
     if (isFamilyAtom(atom)) {
-      if (!families.has(atom.family)) {
-        families.set(atom.family, new Set);
+      if (!updatedFamilyAtoms.has(atom.family)) {
+        updatedFamilyAtoms.set(atom.family, new Set);
       }
-      families.get(atom.family).add(atom);
+      updatedFamilyAtoms.get(atom.family).add(atom);
     }
   }
-  if (families.size > 0) {
+  if (updatedFamilyAtoms.size > 0) {
     const timestamp = performance.now();
-    for (const [family, familyAtoms] of families) {
+    for (const [family, familyAtoms] of updatedFamilyAtoms) {
       addSetToSet(data.stateDependents.get(family), selectors);
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
@@ -751,30 +807,39 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false) => {
       addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly);
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly);
+    for (const atom of atoms) {
+      if (isAtomFamily(atom) && !updatedFamilyAtoms.has(atom)) {
+        recursivelyUpdateIndexes(data, atom);
+      }
+    }
+  }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, updatedFamilyAtoms, isInitOnly, notify);
+  if (notifyEntry)
+    collectFamilyAtomsForNotify(notifyEntry, updatedFamilyAtoms);
+  if (data.scopes && data.scopes.size > 0) {
+    propagateToScopes(atoms, data, isInitOnly, notify);
   }
 };
-var propagateInScope = (atoms, data, isInitOnly = false) => {
-  const subscriptions = new Set;
+var propagateInScope = (atoms, data, isInitOnly = false, notify) => {
+  const subscriptions = notify ? notifyEntryFor(notify, data).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);
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, notify);
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly);
+    propagateToScopes(atoms, data, isInitOnly, notify);
   }
 };
-var propagateToScopes = (atoms, data, isInitOnly) => {
+var propagateToScopes = (atoms, data, isInitOnly, notify) => {
   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);
+        propagateInScope(atoms, scope, isInitOnly, notify);
       }
     }
     return;
@@ -794,7 +859,7 @@ var propagateToScopes = (atoms, data, isInitOnly) => {
   }
   if (!anyShadowed) {
     for (const [, scope] of data.scopes) {
-      propagateInScope(atoms, scope, isInitOnly);
+      propagateInScope(atoms, scope, isInitOnly, notify);
     }
     return;
   }
@@ -811,16 +876,16 @@ var propagateToScopes = (atoms, data, isInitOnly) => {
       }
     }
     if (atomsToUpdateInScope.length > 0) {
-      propagateInScope(atomsToUpdateInScope, scope, isInitOnly);
+      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, notify);
     }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false) => {
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, notify) => {
   const updatedInitializedAtoms = new Set(updatedAtoms);
   if (selectors.size > 0) {
     propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly);
   }
-  if (subscriptions.size > 0) {
+  if (!notify && subscriptions.size > 0) {
     callSubscribers(subscriptions, families);
   }
 };
@@ -857,13 +922,22 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       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 (!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)
@@ -897,17 +971,20 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
     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 (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);
+        if (removed) {
+          for (const dep of removed) {
+            onLiveDependencyRemoved(dep, data);
+            unmountOrphanedDeps(dep, data);
+          }
         }
       }
     }
@@ -916,6 +993,62 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       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);
+        continue;
+      }
+      depsChange.added = undefined;
+      depsChange.removed = undefined;
+      const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+      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) {
+        if (subscribers)
+          addSetToSet(subscribers, collectedSubscribers);
+        const downstream = data.stateDependents.get(selector);
+        if (downstream) {
+          for (const d of downstream)
+            next.add(d);
+        }
+      }
+    }
+    work = next;
+  }
 };
 var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
   if (selectors.size === 0)
@@ -971,7 +1104,7 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
 // src/lib/isFunction.ts
 var isFunction = (value) => typeof value === "function";
 
-// src/lib/setAtom.ts
+// src/lib/resolvePendingDefault.ts
 var resolvePendingDefault = (atom, data, value) => {
   let cur = data;
   while (cur) {
@@ -984,6 +1117,8 @@ var resolvePendingDefault = (atom, data, value) => {
     cur = "parent" in cur ? cur.parent : undefined;
   }
 };
+
+// src/lib/setAtom.ts
 var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
   setValueInData(atom, promise, data);
   promise.then((resolvedValue) => {
@@ -1504,14 +1639,18 @@ var installMaxAgeTimer = (state, data) => {
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
   let parentUnsubscribe;
+  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)) {
@@ -1533,12 +1672,14 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
     subscription = {
       callback,
       state,
-      requireDeepEqualCheckBeforeCallback
+      requireDeepEqualCheckBeforeCallback,
+      reRoot: dropDelegate
     };
   } else {
     subscription = {
       callback,
-      requireDeepEqualCheckBeforeCallback
+      requireDeepEqualCheckBeforeCallback,
+      reRoot: dropDelegate
     };
   }
   subscribers.add(subscription);
@@ -1562,17 +1703,25 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   };
 };
 
-// src/lib/setAtoms.ts
-var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
+// 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);
-    const areEqual = isPromiseLike(currentValue) || isPromiseLike(value) ? currentValue === value : atom.equal(currentValue, value);
+    const currentIsPromise = isPromiseLike(currentValue);
+    const areEqual = currentIsPromise || isPromiseLike(value) ? currentValue === value : atom.equal(currentValue, value);
     if (!areEqual) {
       updatedAtoms.push(atom);
       value = setValueInData(atom, value, data);
-      if (atom.onSet && !skipOnSet)
-        atom.onSet(value, data);
+      if (atom.onSet && !skipOnSet) {
+        if (onSetQueue)
+          onSetQueue.push([atom, value, data]);
+        else
+          atom.onSet(value, data);
+      }
+      if (currentIsPromise && !isPromiseLike(value)) {
+        resolvePendingDefault(atom, data, value);
+      }
     } else {
       setValueInData(atom, value, data);
     }
@@ -1582,6 +1731,12 @@ var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
       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) {
     propagateAtomUpdate(updatedAtoms, data);
   }
@@ -1671,7 +1826,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);
@@ -1761,15 +1916,60 @@ 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 notify2 = new Map;
+        const updatedAtoms = writeAtoms(this._atomMap, this.data, initializedAtomsSet);
+        if (updatedAtoms.length > 0) {
+          propagateAtomUpdate(updatedAtoms, this.data, false, notify2);
+        }
+        deleteAtomFamilyAtoms(this._deleteSet, this.data);
+        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, notify2);
+        notifyDeferred(notify2);
+      } 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 notify = new Map;
+    for (const { data, updatedAtoms, deleted } of plan) {
+      if (updatedAtoms.length > 0) {
+        propagateAtomUpdate(updatedAtoms, data, false, notify);
+      }
+      if (deleted) {
+        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, notify);
+      }
     }
+    notifyDeferred(notify);
+  };
+  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);
       }
     }
   };
@@ -2513,38 +2713,27 @@ var index = (family, callback, options) => {
   const map = new Map;
   const index2 = (term) => {
     const termKey = stableStringify(term);
-    if (map.has(termKey))
-      return map.get(termKey);
-    const termIndexSelectorSet = new Set;
-    const termIndexSelectorMap = new Map;
-    const termIndexSelector = selector((get) => {
-      const allFamilyAtoms = new Set(get(family));
-      const deletedAtoms = termIndexSelectorSet.symmetricDifference(allFamilyAtoms);
-      const addedAtoms = allFamilyAtoms.difference(termIndexSelectorSet);
-      if (deletedAtoms.size || addedAtoms.size) {
-        deletedAtoms.forEach((atom2) => {
-          termIndexSelectorSet.delete(atom2);
-          termIndexSelectorMap.delete(atom2);
+    const existing = map.get(termKey);
+    if (existing)
+      return existing;
+    const predicateSelectors = new WeakMap;
+    const predicateFor = (atom2) => {
+      let sel = predicateSelectors.get(atom2);
+      if (!sel) {
+        sel = selector((get) => callback(get(atom2), term), {
+          name: `index:callback:selector:${atom2.name}`
         });
-        addedAtoms.forEach((atom2) => {
-          termIndexSelectorSet.add(atom2);
-          termIndexSelectorMap.set(atom2, selector((get2) => callback(get2(atom2), term), {
-            name: `index:callback:selector:${atom2.name}`
-          }));
-        });
-        return new Set(termIndexSelectorSet);
-      } else {
-        return termIndexSelectorSet;
+        predicateSelectors.set(atom2, sel);
       }
-    }, { name: `index:${options?.name}(${termKey})` });
+      return sel;
+    };
     const filteredSelector = selector((get) => {
-      const set = get(termIndexSelector);
       const res = [];
-      set.forEach((atom2) => {
-        if (get(termIndexSelectorMap.get(atom2))) {
+      const members = get(family);
+      for (const atom2 of members) {
+        if (get(predicateFor(atom2)))
           res.push(atom2);
-        }
-      });
+      }
       return res;
     }, {
       name: `index:${options?.name}:${termKey}:termSelector`
@@ -2592,9 +2781,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.4"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.6"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.4";
+  globalThis.__valdres__ = "1.0.0-beta.6";
 }
 export {
   store,

package/dist/types/indexConstructor.d.ts

@@ -1,5 +1,6 @@
 import type { AtomFamily } from "./types/AtomFamily";
+import type { AtomFamilyAtom } from "./types/AtomFamilyAtom";
 import type { Selector } from "./types/Selector";
 export declare const index: <Term, Value extends any, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(family: AtomFamily<Value, FamilyArgs>, callback: (value: Value, term: Term) => boolean, options?: {
     name?: string;
-}) => ((term: Term) => Selector<Term[]>);
+}) => ((term: Term) => Selector<AtomFamilyAtom<Value, FamilyArgs>[]>);

package/dist/types/lib/IS_PROD.d.ts

@@ -0,0 +1 @@
+export declare const IS_PROD: boolean;

package/dist/types/lib/atomFamilyIndex.d.ts

@@ -14,4 +14,5 @@ export type AtomFamilyIndex = {
 export declare const cloneAtomFamilyIndex: (index: AtomFamilyIndex, parentIndexOverride?: AtomFamilyIndex) => AtomFamilyIndex;
 export declare const createAtomFamilyIndex: (parentIndex?: AtomFamilyIndex) => AtomFamilyIndex;
 export declare const deleteFamilyAtomsFromSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: number) => void;
+export declare const recursivelyUpdateIndexes: (data: StoreData, family: Family<any>) => void;
 export declare const addFamilyAtomsToSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: number) => void;

package/dist/types/lib/propagateUpdatedAtoms.d.ts

@@ -7,7 +7,13 @@ import type { Subscription } from "../types/Subscription";
 export type { AtomFamilyIndex, } from "./atomFamilyIndex";
 export { cloneAtomFamilyIndex, createAtomFamilyIndex, renderAtomFamilyIndex, } from "./atomFamilyIndex";
 type AtomInput = Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>;
-export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number) => void;
-export declare const propagateAtomUpdate: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean) => void;
-export declare const propagateInScope: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean) => void;
-export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isInitOnly?: boolean) => void;
+type NotifyStoreEntry = {
+    subscriptions: Set<Subscription>;
+    families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>;
+};
+export type NotifyTarget = Map<StoreData, NotifyStoreEntry>;
+export declare const notifyDeferred: (notify: NotifyTarget) => void;
+export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, deletedFamilyAtoms?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number, notify?: NotifyTarget) => void;
+export declare const propagateAtomUpdate: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, notify?: NotifyTarget) => void;
+export declare const propagateInScope: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, notify?: NotifyTarget) => void;
+export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isInitOnly?: boolean, notify?: NotifyTarget) => void;

package/dist/types/lib/resolvePendingDefault.d.ts

@@ -0,0 +1,32 @@
+import type { Atom } from "../types/Atom";
+import type { StoreData } from "../types/StoreData";
+/** Resolve any outstanding pending-default suspense placeholder for `atom`
+ *  with `value` and remove it. The placeholder may have been registered in a
+ *  parent store (atoms with no `defaultValue` init in whichever scope first
+ *  reads them, which `getState` resolves by walking up to root), so we walk
+ *  the scope chain rather than only checking `data`.
+ *
+ *  Called by every write path that lands a value on an atom that may carry a
+ *  placeholder — `setAtom` (sync + async resolve) and `writeAtoms` (the
+ *  transaction path).
+ *
+ *  Caller contract: pass a SETTLED value, never a promise. The placeholder must
+ *  resolve to the eventual real value, so an in-flight promise stored
+ *  mid-sequence must not consume it — a later settled write still has to find
+ *  the entry here. `setAtom` guarantees this by routing promises through
+ *  `handlePromise` instead; `writeAtoms` by gating on `!isPromiseLike(value)`.
+ *
+ *  Optional optimization (not required): a caller that already knows the prior
+ *  value may skip the call when it isn't promise-like — a placeholder is always
+ *  stored as a promise, so a non-promise prior value can't have one. `writeAtoms`
+ *  does this (gating on `isPromiseLike(currentValue)`) to keep the write hot
+ *  path off this function. `setAtom` calls unconditionally; the walk is a couple
+ *  of WeakMap lookups that bail immediately when there's nothing to resolve.
+ *
+ *  Idempotent and commit-safe: the entry is deleted on first resolve and a
+ *  settled promise ignores later `resolve` calls, so calling this from more
+ *  than one store pass in a single cross-scope commit is harmless. `resolve`
+ *  only schedules the placeholder's `.then` microtasks — it runs no subscriber
+ *  code synchronously — so calling it during a transaction's write phase
+ *  cannot expose a half-applied commit. */
+export declare const resolvePendingDefault: <Value>(atom: Atom<Value>, data: StoreData, value: Value) => void;

package/dist/types/lib/transaction.d.ts

@@ -26,6 +26,7 @@ export declare class Transaction {
     execute: (callback: TransactionFn, autoCommit?: boolean) => any;
     private txnCommit;
     commit: () => void;
+    private collectStores;
     private get selectorCache();
     private get selectorDependencies();
     private get deleteSet();

package/dist/types/lib/writeAtoms.d.ts

@@ -0,0 +1,21 @@
+import type { Atom } from "../types/Atom";
+import type { StoreData } from "../types/StoreData";
+/** A deferred onSet invocation: the hook, the written value, and the store it
+ *  was written to. Collected during the write phase of a cross-scope commit so
+ *  hooks fire only once the whole tree has been written. */
+export type DeferredOnSet = [Atom<any>, any, StoreData];
+/**
+ * Write phase for a single store. Applies every value in `pairs` to
+ * `data.values`, returning the atoms whose value actually changed (the
+ * propagation set), merged with any atoms lazily initialized during the
+ * equality checks. This does NOT propagate — see `setAtoms` (single-store
+ * fast path) or `Transaction.commit` (cross-scope path) for the notify pass.
+ *
+ * onSet handling:
+ *  - `skipOnSet` true     → never fire onSet.
+ *  - `onSetQueue` given    → defer onSet by pushing `[atom, value, data]`. The
+ *    cross-scope commit uses this so a hook never observes a half-applied
+ *    transaction — it fires only after every store's writes have landed.
+ *  - otherwise             → fire onSet inline (single-store path, unchanged).
+ */
+export declare const writeAtoms: (pairs: Map<Atom<any>, any>, data: StoreData, initializedAtomsSet: Set<Atom>, skipOnSet?: boolean, onSetQueue?: DeferredOnSet[]) => Atom[];

package/dist/types/types/Subscription.d.ts

@@ -3,9 +3,16 @@ export type AtomFamilySubscription<Value extends any = any, Args extends [any, .
     state: AtomFamily<Value, Args>;
     callback: (...args: Args) => void;
     requireDeepEqualCheckBeforeCallback: boolean;
+    /** Present only on a scope subscription that is delegating to an ancestor.
+     *  Drops the ancestor delegate (idempotent). Called eagerly when the scope
+     *  shadows the state so an ancestor write in the same transaction commit
+     *  does not also notify this subscription. */
+    reRoot?: () => void;
 };
 export type SimpleSubscription = {
     requireDeepEqualCheckBeforeCallback: boolean;
     callback: () => void;
+    /** See AtomFamilySubscription.reRoot. */
+    reRoot?: () => void;
 };
 export type Subscription = SimpleSubscription | AtomFamilySubscription;

package/dist/types/utils/deepFreeze.d.ts

@@ -1 +1 @@
-export declare const deepFreeze: (obj: any, seen?: WeakSet<WeakKey>) => any;
+export declare const deepFreeze: (obj: any, seen?: WeakSet<object>) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "1.0.0-beta.4",
+    "version": "1.0.0-beta.6",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"

package/dist/types/lib/isProd.d.ts

@@ -1 +0,0 @@
-export declare const isProd: () => boolean;