valdres 1.0.0-beta.5 → 1.0.0-beta.7

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");
@@ -108,6 +108,11 @@ var isSelector = (state) => state && Object.hasOwn(state, "get");
 // src/utils/isAtomFamily.ts
 var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
 
+// src/utils/isPromiseLike.ts
+var isPromiseLike = (object) => {
+  return object && object.then && typeof object.then === "function";
+};
+
 // src/utils/isFamilyState.ts
 var isFamilyState = (state) => state && Object.hasOwn(state, "family");
 
@@ -117,11 +122,6 @@ var isFamilyAtom = (state) => isFamilyState(state) && isAtom(state);
 // src/utils/isSelectorFamily.ts
 var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
 
-// src/utils/isPromiseLike.ts
-var isPromiseLike = (object) => {
-  return object && object.then && typeof object.then === "function";
-};
-
 // src/utils/deepFreeze.ts
 var deepFreeze = (obj, seen) => {
   if (obj === null || obj === undefined)
@@ -403,6 +403,213 @@ var cleanUpRejectedPromise = (selector, data, promise) => {
   data.values.delete(selector);
 };
 
+// src/lib/notifyChangeListeners.ts
+var changeListenerRegistry = { count: 0, selectorCount: 0 };
+var hasChangeListener = (data) => {
+  if (changeListenerRegistry.count === 0)
+    return false;
+  let store = data;
+  while (store) {
+    const listeners = store.changeListeners;
+    if (listeners !== undefined && listeners.size > 0)
+      return true;
+    store = store.parent;
+  }
+  return false;
+};
+var hasSelectorChangeListener = (data) => {
+  if (changeListenerRegistry.selectorCount === 0)
+    return false;
+  let store = data;
+  while (store) {
+    const listeners = store.changeListeners;
+    if (listeners !== undefined) {
+      for (const flags of listeners.values()) {
+        if (flags.selectors)
+          return true;
+      }
+    }
+    store = store.parent;
+  }
+  return false;
+};
+var scopePath = (data) => {
+  const path = [];
+  let store = data;
+  while (store && store.parent) {
+    path.push(store.id);
+    store = store.parent;
+  }
+  path.reverse();
+  return path;
+};
+var notifyChangeListeners = (groups, meta) => {
+  let buckets;
+  for (const group of groups) {
+    if (group.changes.length === 0)
+      continue;
+    let store = group.data;
+    while (store) {
+      const listeners = store.changeListeners;
+      if (listeners !== undefined && listeners.size > 0) {
+        if (!buckets)
+          buckets = new Map;
+        let bucket = buckets.get(store);
+        if (!bucket) {
+          bucket = [];
+          buckets.set(store, bucket);
+        }
+        for (const change of group.changes)
+          bucket.push(change);
+      }
+      store = store.parent;
+    }
+  }
+  if (!buckets)
+    return;
+  for (const [store, changes] of buckets) {
+    const listeners = store.changeListeners;
+    if (listeners === undefined || listeners.size === 0)
+      continue;
+    let hasSelector;
+    let hasAtom;
+    let atomOnly;
+    let selectorOnly;
+    let firstError;
+    let hasError = false;
+    for (const [listener, flags] of [...listeners]) {
+      let payload;
+      if (flags.atoms && flags.selectors) {
+        payload = changes;
+      } else if (flags.atoms) {
+        if (atomOnly === undefined) {
+          hasSelector ??= changes.some((c) => c.type === "selector");
+          atomOnly = hasSelector ? changes.filter((c) => c.type === "atom") : changes;
+        }
+        payload = atomOnly;
+      } else if (flags.selectors) {
+        if (selectorOnly === undefined) {
+          hasAtom ??= changes.some((c) => c.type === "atom");
+          selectorOnly = hasAtom ? changes.filter((c) => c.type === "selector") : changes;
+        }
+        payload = selectorOnly;
+      } else {
+        continue;
+      }
+      if (payload.length === 0)
+        continue;
+      try {
+        listener(payload, meta);
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+      }
+    }
+    if (hasError)
+      throw firstError;
+  }
+};
+var buildChangeGroup = (data, changedAtoms, deletedAtoms, changedSelectors) => {
+  const scope = scopePath(data);
+  const changes = [];
+  let seen;
+  if (changedAtoms) {
+    for (const atom of changedAtoms) {
+      if (atom.__valdresInternal || isAtomFamily(atom))
+        continue;
+      if (seen?.has(atom))
+        continue;
+      (seen ??= new Set).add(atom);
+      changes.push({
+        type: "atom",
+        kind: "set",
+        state: atom,
+        value: data.values.get(atom),
+        scope
+      });
+    }
+  }
+  if (deletedAtoms) {
+    for (const atom of deletedAtoms) {
+      if (atom.__valdresInternal || isAtomFamily(atom))
+        continue;
+      changes.push({ type: "atom", kind: "delete", state: atom, scope });
+    }
+  }
+  if (changedSelectors) {
+    for (const selector of changedSelectors) {
+      if (selector.__valdresInternal || isSelectorFamily(selector))
+        continue;
+      if (!data.values.has(selector))
+        continue;
+      changes.push({
+        type: "selector",
+        state: selector,
+        value: data.values.get(selector),
+        scope
+      });
+    }
+  }
+  return { data, changes };
+};
+var emitGroup = (group, report) => {
+  if (group.changes.length === 0)
+    return;
+  if (typeof report === "string") {
+    notifyChangeListeners([group], { source: report });
+  } else {
+    report.groups.push(group);
+  }
+};
+var reportAtomChanges = (atoms, data, report, changedSelectors) => {
+  if (!hasChangeListener(data))
+    return;
+  const selectors = changedSelectors && changedSelectors.size > 0 && hasSelectorChangeListener(data) ? changedSelectors : undefined;
+  emitGroup(buildChangeGroup(data, atoms, undefined, selectors), report);
+};
+var reportUnsetAtom = (atom, data, revertedValue, report) => {
+  if (!hasChangeListener(data))
+    return;
+  const group = {
+    data,
+    changes: [
+      {
+        type: "atom",
+        kind: "unset",
+        state: atom,
+        value: revertedValue,
+        scope: scopePath(data)
+      }
+    ]
+  };
+  emitGroup(group, report);
+};
+var reportDeletedAtoms = (atoms, data, report, changedSelectors) => {
+  if (!hasChangeListener(data))
+    return;
+  const selectors = changedSelectors && changedSelectors.size > 0 && hasSelectorChangeListener(data) ? changedSelectors : undefined;
+  emitGroup(buildChangeGroup(data, undefined, atoms, selectors), report);
+};
+var reportSelectorChanges = (changedSelectors, data, report) => {
+  if (changedSelectors.size === 0)
+    return;
+  if (!hasSelectorChangeListener(data))
+    return;
+  emitGroup(buildChangeGroup(data, undefined, undefined, changedSelectors), report);
+};
+var createChangeSink = (name, source = "transaction") => ({
+  source,
+  name,
+  groups: []
+});
+var flushChangeSink = (sink) => {
+  if (sink.groups.length > 0) {
+    notifyChangeListeners(sink.groups, { source: sink.source, name: sink.name });
+  }
+};
+
 // src/lib/initSelector.ts
 var neverAbortedSignal = new AbortController().signal;
 var syncOptionsCache = new WeakMap;
@@ -549,7 +756,7 @@ var handleSelectorResult = (value, selector, data) => {
       const initializedAtomsSet = new Set;
       const res = initSelector(selector, data, initializedAtomsSet);
       if (initializedAtomsSet.size > 0) {
-        propagateAtomUpdate([...initializedAtomsSet], data);
+        propagateAtomUpdate([...initializedAtomsSet], data, false, undefined, "async-set");
       }
       return res;
     }).catch(() => {
@@ -590,7 +797,12 @@ var handleSelectorResult = (value, selector, data) => {
       const dependents = data.stateDependents.get(selector);
       const subs = data.subscriptions.get(selector);
       if (subs && subs.size > 0 || dependents && dependents.size > 0) {
-        propagateDirtySelectors([], new Set(dependents), data, new Set(subs), new Map);
+        const changedSelectors = changeListenerRegistry.selectorCount !== 0 && hasSelectorChangeListener(data) ? new Set : undefined;
+        propagateDirtySelectors([], new Set(dependents), data, new Set(subs), new Map, false, undefined, changedSelectors);
+        if (changedSelectors) {
+          changedSelectors.add(selector);
+          reportSelectorChanges(changedSelectors, data, "async-set");
+        }
       }
     }).catch(() => {
       pendingAsyncDeps.delete(value);
@@ -628,6 +840,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);
@@ -674,6 +894,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) {
@@ -681,20 +930,24 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now(), evaluatedSelectors) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, deletedFamilyAtoms = new Map, timestamp = performance.now(), notify, report) => {
+  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)
@@ -702,28 +955,35 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
-  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()) {
-      const scopesWithFamily = data.scopeValueIndex.get(family);
-      if (scopesWithFamily) {
-        for (const scope of scopesWithFamily) {
-          let list = scopeFamilies.get(scope);
-          if (!list) {
-            list = [];
-            scopeFamilies.set(scope, list);
-          }
-          list.push(family);
-        }
-      }
-    }
-    for (const [scope, familiesInScope] of scopeFamilies) {
-      propagateInScope(familiesInScope, scope, false, evaluatedSelectors);
-    }
-  }
-};
-var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
+  const selectorActive = report !== undefined && changeListenerRegistry.selectorCount !== 0 && hasSelectorChangeListener(data);
+  const changedSelectors = selectorActive ? new Set : undefined;
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, deletedFamilyAtoms, false, notify, changedSelectors);
+  if (notifyEntry)
+    collectFamilyAtomsForNotify(notifyEntry, deletedFamilyAtoms);
+  const hasScopeCascade = !!data.scopes && data.scopes.size > 0;
+  const watching = report !== undefined && changeListenerRegistry.count !== 0;
+  let localSink;
+  let effectiveReport = report;
+  if (selectorActive && hasScopeCascade && typeof report === "string") {
+    localSink = createChangeSink(undefined, report);
+    effectiveReport = localSink;
+  }
+  const reportIsSink = effectiveReport !== undefined && typeof effectiveReport !== "string";
+  if (watching && reportIsSink)
+    reportDeletedAtoms(atoms, data, effectiveReport, changedSelectors);
+  if (hasScopeCascade) {
+    const scopeAtoms = atoms.slice();
+    for (const family of deletedFamilyAtoms.keys()) {
+      scopeAtoms.push(family);
+    }
+    propagateToScopes(scopeAtoms, data, false, notify, effectiveReport);
+  }
+  if (watching && !reportIsSink)
+    reportDeletedAtoms(atoms, data, effectiveReport, changedSelectors);
+  if (localSink)
+    flushChangeSink(localSink);
+};
+var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify, report, skipFamilyIndexUpdate = false, reportAtoms = true) => {
   if (atoms.length === 1) {
     const atom = atoms[0];
     if (!isFamilyAtom(atom) && !isAtomFamily(atom)) {
@@ -731,28 +991,35 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors)
       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);
+        }
+        if (reportAtoms && report !== undefined && changeListenerRegistry.count !== 0 && !isInitOnly) {
+          reportAtomChanges(atoms, data, report);
         }
         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 (isFamilyAtom(atom) && !skipFamilyIndexUpdate) {
+      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)
@@ -762,35 +1029,65 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors)
   }
   if (data.scopes && data.scopes.size > 0) {
     for (const atom of atoms) {
-      if (isAtomFamily(atom) && !families.has(atom)) {
+      if (isAtomFamily(atom) && !updatedFamilyAtoms.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);
+  const selectorActive = report !== undefined && !isInitOnly && changeListenerRegistry.selectorCount !== 0 && hasSelectorChangeListener(data);
+  const changedSelectors = selectorActive ? new Set : undefined;
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, updatedFamilyAtoms, isInitOnly, notify, changedSelectors);
+  if (notifyEntry)
+    collectFamilyAtomsForNotify(notifyEntry, updatedFamilyAtoms);
+  const hasScopes = !!data.scopes && data.scopes.size > 0;
+  const watching = report !== undefined && changeListenerRegistry.count !== 0 && !isInitOnly;
+  let localSink;
+  let effectiveReport = report;
+  if (selectorActive && hasScopes && typeof report === "string") {
+    localSink = createChangeSink(undefined, report);
+    effectiveReport = localSink;
   }
-};
-var propagateInScope = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
-  const subscriptions = new Set;
+  const reportIsSink = effectiveReport !== undefined && typeof effectiveReport !== "string";
+  const emitOrigin = (rpt) => {
+    if (reportAtoms) {
+      reportAtomChanges(atoms, data, rpt, changedSelectors);
+    } else if (changedSelectors && changedSelectors.size > 0) {
+      reportSelectorChanges(changedSelectors, data, rpt);
+    }
+  };
+  if (watching && reportIsSink)
+    emitOrigin(effectiveReport);
+  if (hasScopes) {
+    propagateToScopes(atoms, data, isInitOnly, notify, effectiveReport);
+  }
+  if (watching && !reportIsSink)
+    emitOrigin(effectiveReport);
+  if (localSink)
+    flushChangeSink(localSink);
+};
+var propagateInScope = (atoms, data, isInitOnly = false, notify, report) => {
+  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, evaluatedSelectors);
+  const changedSelectors = report !== undefined && !isInitOnly && changeListenerRegistry.selectorCount !== 0 && hasSelectorChangeListener(data) ? new Set : undefined;
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, notify, changedSelectors);
+  if (changedSelectors && changedSelectors.size > 0) {
+    reportSelectorChanges(changedSelectors, data, report);
+  }
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
+    propagateToScopes(atoms, data, isInitOnly, notify, report);
   }
 };
-var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
+var propagateToScopes = (atoms, data, isInitOnly, notify, report) => {
   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);
+        propagateInScope(atoms, scope, isInitOnly, notify, report);
       }
     }
     return;
@@ -810,7 +1107,7 @@ var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
   }
   if (!anyShadowed) {
     for (const [, scope] of data.scopes) {
-      propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
+      propagateInScope(atoms, scope, isInitOnly, notify, report);
     }
     return;
   }
@@ -827,20 +1124,20 @@ var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
       }
     }
     if (atomsToUpdateInScope.length > 0) {
-      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, evaluatedSelectors);
+      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, notify, report);
     }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, evaluatedSelectors) => {
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, notify, changedSelectors) => {
   const updatedInitializedAtoms = new Set(updatedAtoms);
   if (selectors.size > 0) {
-    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly, changedSelectors);
   }
-  if (subscriptions.size > 0) {
+  if (!notify && subscriptions.size > 0) {
     callSubscribers(subscriptions, families);
   }
 };
-var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors) => {
+var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, changedSelectors) => {
   const closure = new Set(seeds);
   {
     const stack = [...seeds];
@@ -901,10 +1198,6 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
   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);
@@ -924,8 +1217,6 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     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) {
@@ -946,8 +1237,11 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       }
     }
     advance(selector, wasValueUpdated);
-    if (wasValueUpdated && subscribers) {
-      addSetToSet(subscribers, collectedSubscribers);
+    if (wasValueUpdated) {
+      if (changedSelectors)
+        changedSelectors.add(selector);
+      if (subscribers)
+        addSetToSet(subscribers, collectedSubscribers);
     }
   }
   if (!graphMutated)
@@ -978,8 +1272,6 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       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)) {
@@ -997,6 +1289,8 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
         }
       }
       if (wasValueUpdated) {
+        if (changedSelectors)
+          changedSelectors.add(selector);
         if (subscribers)
           addSetToSet(subscribers, collectedSubscribers);
         const downstream = data.stateDependents.get(selector);
@@ -1009,15 +1303,12 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     work = next;
   }
 };
-var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false, evaluatedSelectors) => {
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false, changedSelectors) => {
   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;
@@ -1030,8 +1321,6 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     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)) {
@@ -1050,6 +1339,8 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     }
     if (!wasValueUpdated)
       continue;
+    if (changedSelectors)
+      changedSelectors.add(selector);
     if (subscribers)
       addSetToSet(subscribers, collectedSubscribers);
     const downstream = data.stateDependents.get(selector);
@@ -1061,14 +1352,14 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     }
   }
   if (downstreamSeeds && downstreamSeeds.size > 0) {
-    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
+    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, changedSelectors);
   }
 };
 
 // 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) {
@@ -1081,6 +1372,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) => {
@@ -1090,12 +1383,12 @@ var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
     if (atom.onSet && !skipOnSet)
       atom.onSet(resolvedValue, data);
     resolvePendingDefault(atom, data, resolvedValue);
-    propagateAtomUpdate([atom], data);
+    propagateAtomUpdate([atom], data, false, undefined, "async-set");
   }).catch(() => {
     if (data.values.get(atom) !== promise)
       return;
     setValueInData(atom, currentValue, data);
-    propagateAtomUpdate([atom], data);
+    propagateAtomUpdate([atom], data, false, undefined, "async-set");
   });
 };
 var setAtom = (atom, newValue, data, skipOnSet = false) => {
@@ -1117,9 +1410,9 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
     handlePromise(atom, promise, currentValue, data, skipOnSet);
     if (initializedAtomsSet && initializedAtomsSet.size > 0) {
       initializedAtomsSet.add(atom);
-      propagateAtomUpdate([...initializedAtomsSet], data);
+      propagateAtomUpdate([...initializedAtomsSet], data, false, undefined, "set");
     } else {
-      propagateAtomUpdate([atom], data);
+      propagateAtomUpdate([atom], data, false, undefined, "set");
     }
     return promise;
   }
@@ -1133,9 +1426,9 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
   resolvePendingDefault(atom, data, syncValue);
   if (initializedAtomsSet && initializedAtomsSet.size > 0) {
     initializedAtomsSet.add(atom);
-    propagateAtomUpdate([...initializedAtomsSet], data);
+    propagateAtomUpdate([...initializedAtomsSet], data, false, undefined, "set");
   } else {
-    propagateAtomUpdate([atom], data);
+    propagateAtomUpdate([atom], data, false, undefined, "set");
   }
   return syncValue;
 };
@@ -1156,7 +1449,7 @@ var getAtomInitValue = (atom, data, initializedAtomsSet) => {
         if (data.values.get(atom) !== value)
           return;
         setValueInData(atom, resolvedValue, data);
-        propagateAtomUpdate([atom], data);
+        propagateAtomUpdate([atom], data, false, undefined, "async-set");
       }, () => {
         if (data.values.get(atom) === value) {
           data.values.delete(atom);
@@ -1180,6 +1473,23 @@ var initAtom = (atom, data, initializedAtomsSet) => {
     }, data);
 };
 
+// src/lib/resolveAtomDefaultValue.ts
+var resolveAtomDefaultValue = (atom, data, initializedAtomsSet) => {
+  if (atom.defaultValue === undefined) {
+    let resolve;
+    const promise = new Promise((r) => {
+      resolve = r;
+    });
+    data.pendingDefaults.set(atom, { promise, resolve });
+    return promise;
+  } else if (typeof atom.defaultValue === "function") {
+    return atom.defaultValue();
+  } else if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data, initializedAtomsSet);
+  }
+  return atom.defaultValue;
+};
+
 // src/lib/getState.ts
 function getState(state, data, initializedAtomsSet, circularDependencySet) {
   if (data.values.has(state))
@@ -1191,7 +1501,21 @@ function getState(state, data, initializedAtomsSet, circularDependencySet) {
       const familyValue = data.values.get(state.family);
       if (familyValue?.__index) {
         if (isAtomDeletedInFamilyIndex(state, familyValue.__index)) {
-          return state.defaultValue;
+          const value = resolveAtomDefaultValue(state, data, initializedAtomsSet);
+          const cached = setValueInData(state, value, data);
+          if (isPromiseLike(cached)) {
+            cached.then((resolvedValue) => {
+              if (data.values.get(state) !== cached)
+                return;
+              setValueInData(state, resolvedValue, data);
+              propagateAtomUpdate([state], data, false, undefined, undefined, true);
+            }, () => {
+              if (data.values.get(state) === cached) {
+                data.values.delete(state);
+              }
+            });
+          }
+          return cached;
         }
       }
     }
@@ -1249,6 +1573,63 @@ var resolveReactive = (value, data) => {
   return value;
 };
 
+// src/lib/unsetValue.ts
+var InvalidStateError = "unset() expects an atom.";
+var detachOwnValue = (atom, data) => {
+  if (!data.values.has(atom))
+    return false;
+  data.values.delete(atom);
+  if (atom.maxAge !== undefined)
+    data.lastValueWriteAt.delete(atom);
+  const parent = data.parent;
+  if (parent) {
+    const scopes = parent.scopeValueIndex.get(atom);
+    if (scopes) {
+      scopes.delete(data);
+      if (scopes.size === 0)
+        parent.scopeValueIndex.delete(atom);
+    }
+    data.scopeIndexKeys.delete(atom);
+  }
+  return true;
+};
+var reDelegateScopeSubscriptions = (atom, data) => {
+  const subs = data.subscriptions.get(atom);
+  if (subs) {
+    for (const sub of subs)
+      sub.reDelegate?.();
+  }
+};
+var effectiveValueAfterUnset = (atom, data) => {
+  const parent = data.parent;
+  if (parent) {
+    const initSet = new Set;
+    const value = getState(atom, parent, initSet);
+    if (initSet.size > 0)
+      propagateAtomUpdate([...initSet], parent, true);
+    return value;
+  }
+  if (data.values.has(atom))
+    return data.values.get(atom);
+  return getAtomInitValue(atom, data, new Set);
+};
+var unsetValue = (atom, data) => {
+  if (!isAtom(atom))
+    throw new Error(InvalidStateError);
+  if (!detachOwnValue(atom, data))
+    return;
+  if (hasChangeListener(data)) {
+    const sink = createChangeSink(undefined, "unset");
+    reportUnsetAtom(atom, data, effectiveValueAfterUnset(atom, data), sink);
+    propagateAtomUpdate([atom], data, false, undefined, sink, false, false);
+    reDelegateScopeSubscriptions(atom, data);
+    flushChangeSink(sink);
+  } else {
+    propagateAtomUpdate([atom], data, false);
+    reDelegateScopeSubscriptions(atom, data);
+  }
+};
+
 // src/lib/createStoreData.ts
 var nextId = 0;
 var generateId = () => "__valdres_store_" + nextId++;
@@ -1282,7 +1663,10 @@ Object.defineProperties(lazyProto, {
 function createStoreData(id, parent, options) {
   const data = Object.create(lazyProto);
   data.id = id ?? generateId();
-  data.values = new WeakMap;
+  const enumerable = options?.enumerable ?? parent?.enumerable ?? false;
+  if (enumerable)
+    data.enumerable = true;
+  data.values = enumerable ? new Map : new WeakMap;
   data.scopes = new Map;
   data.scopeValueIndex = new WeakMap;
   data.pendingDefaults = new WeakMap;
@@ -1303,7 +1687,42 @@ var deleteFamilyAtom = (atom, data) => {
   if (atom.family) {
     atom.family.release(...atom.familyArgs);
   }
-  propagateDeletedAtoms([atom], data);
+  propagateDeletedAtoms([atom], data, undefined, undefined, undefined, undefined, "delete");
+};
+
+// src/lib/onStoreChange.ts
+var onStoreChange = (callback, data, options) => {
+  const atoms = options?.atoms ?? true;
+  const selectors = options?.selectors ?? false;
+  if (!atoms && !selectors)
+    return () => {};
+  let listeners = data.changeListeners;
+  if (!listeners) {
+    listeners = new Map;
+    data.changeListeners = listeners;
+  }
+  const prev = listeners.get(callback);
+  listeners.set(callback, { atoms, selectors });
+  if (!prev)
+    changeListenerRegistry.count++;
+  const prevSelectors = prev?.selectors ?? false;
+  if (selectors && !prevSelectors)
+    changeListenerRegistry.selectorCount++;
+  else if (!selectors && prevSelectors)
+    changeListenerRegistry.selectorCount--;
+  return () => {
+    const current = data.changeListeners;
+    if (!current)
+      return;
+    const flags = current.get(callback);
+    if (flags && current.delete(callback)) {
+      changeListenerRegistry.count--;
+      if (flags.selectors)
+        changeListenerRegistry.selectorCount--;
+      if (current.size === 0)
+        data.changeListeners = undefined;
+    }
+  };
 };
 
 // src/lib/resetAtom.ts
@@ -1312,7 +1731,7 @@ var resetAtom = (atom, data) => {
   let value = getAtomInitValue(atom, data, initializedAtomsSet);
   setValueInData(atom, value, data);
   if (!isPromiseLike(value)) {
-    propagateAtomUpdate([atom], data);
+    propagateAtomUpdate([atom], data, false, undefined, "reset");
   }
   if (initializedAtomsSet.size > 0) {
     throw new Error("Todo - propagateAtomUpdate on reset");
@@ -1320,6 +1739,38 @@ var resetAtom = (atom, data) => {
   return value;
 };
 
+// src/lib/snapshot.ts
+var warnedStores = new WeakSet;
+var collect = (data, scope, out) => {
+  for (const [state, value] of data.values) {
+    if (state.__valdresInternal)
+      continue;
+    if (isAtomFamily(state) || isSelectorFamily(state))
+      continue;
+    out.push({
+      type: isSelector(state) ? "selector" : "atom",
+      state,
+      value,
+      scope
+    });
+  }
+  for (const [id, scopeData] of data.scopes) {
+    collect(scopeData, [...scope, id], out);
+  }
+};
+var snapshot = (data) => {
+  if (!data.enumerable) {
+    if (!warnedStores.has(data)) {
+      warnedStores.add(data);
+      console.warn("store.snapshot() requires an enumerable store. Create it with " + "`store({ enumerable: true })` or `store(id, { enumerable: true })` " + "to retain state enumerably. Returning [].");
+    }
+    return [];
+  }
+  const out = [];
+  collect(data, [], out);
+  return out;
+};
+
 // src/utils/isFamily.ts
 var isFamily = (state) => isAtomFamily(state) || isSelectorFamily(state);
 
@@ -1409,11 +1860,11 @@ var installMaxAgeTimer = (state, data) => {
   const existing = globalState?.maxAgeInterval;
   if (existing) {
     existing.refCount++;
-    const metaAtom2 = state.__cacheMeta ??= { equal, defaultValue: null };
+    const metaAtom2 = state.__cacheMeta ??= { equal, defaultValue: null, __valdresInternal: true };
     for (const s of globalState.stores) {
       if (s !== data && s.values.has(metaAtom2)) {
         setValueInData(metaAtom2, s.values.get(metaAtom2), data);
-        propagateAtomUpdate([metaAtom2], data);
+        propagateAtomUpdate([metaAtom2], data, false, undefined, "revalidate");
         break;
       }
     }
@@ -1440,7 +1891,7 @@ var installMaxAgeTimer = (state, data) => {
   const getMaxAge = () => resolveReactive(state.maxAge, data);
   const getSWR = () => state.staleWhileRevalidate !== undefined ? resolveReactive(state.staleWhileRevalidate, data) : Infinity;
   const getStaleIfError = () => state.staleIfError !== undefined ? resolveReactive(state.staleIfError, data) : Infinity;
-  const metaAtom = state.__cacheMeta ??= { equal, defaultValue: null };
+  const metaAtom = state.__cacheMeta ??= { equal, defaultValue: null, __valdresInternal: true };
   const updateMeta = () => {
     const meta = {
       isRevalidating: revalidating,
@@ -1452,11 +1903,11 @@ var installMaxAgeTimer = (state, data) => {
     if (globalState) {
       for (const store of globalState.stores) {
         setValueInData(metaAtom, meta, store);
-        propagateAtomUpdate([metaAtom], store);
+        propagateAtomUpdate([metaAtom], store, false, undefined, "revalidate");
       }
     } else {
       setValueInData(metaAtom, meta, data);
-      propagateAtomUpdate([metaAtom], data);
+      propagateAtomUpdate([metaAtom], data, false, undefined, "revalidate");
     }
   };
   const isPastStaleIfErrorWindow = () => {
@@ -1467,11 +1918,11 @@ var installMaxAgeTimer = (state, data) => {
     if (globalState) {
       for (const store of globalState.stores) {
         setValueInData(atom, val, store);
-        propagateAtomUpdate([atom], store);
+        propagateAtomUpdate([atom], store, false, undefined, "revalidate");
       }
     } else {
       setValueInData(atom, val, data);
-      propagateAtomUpdate([atom], data);
+      propagateAtomUpdate([atom], data, false, undefined, "revalidate");
     }
   };
   const getValueStore = () => {
@@ -1602,15 +2053,24 @@ 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))) {
+  let reDelegate;
+  if (data.parent && (isAtom(state) || isAtomFamily(state))) {
     const originalCallback = callback;
-    parentUnsubscribe = subscribe(state, originalCallback, requireDeepEqualCheckBeforeCallback, data.parent);
+    const delegateToParent = () => subscribe(state, originalCallback, requireDeepEqualCheckBeforeCallback, data.parent);
+    if (isAtomFamily(state) || !data.values.has(state)) {
+      parentUnsubscribe = delegateToParent();
+    }
     dropDelegate = () => {
       if (parentUnsubscribe) {
         parentUnsubscribe();
         parentUnsubscribe = undefined;
       }
     };
+    reDelegate = () => {
+      if (!parentUnsubscribe) {
+        parentUnsubscribe = delegateToParent();
+      }
+    };
     callback = (arg) => {
       dropDelegate();
       originalCallback(arg);
@@ -1635,13 +2095,15 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
       callback,
       state,
       requireDeepEqualCheckBeforeCallback,
-      reRoot: dropDelegate
+      reRoot: dropDelegate,
+      reDelegate
     };
   } else {
     subscription = {
       callback,
       requireDeepEqualCheckBeforeCallback,
-      reRoot: dropDelegate
+      reRoot: dropDelegate,
+      reDelegate
     };
   }
   subscribers.add(subscription);
@@ -1670,7 +2132,8 @@ var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueu
   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);
@@ -1680,6 +2143,9 @@ var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueu
         else
           atom.onSet(value, data);
       }
+      if (currentIsPromise && !isPromiseLike(value)) {
+        resolvePendingDefault(atom, data, value);
+      }
     } else {
       setValueInData(atom, value, data);
     }
@@ -1693,10 +2159,10 @@ var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueu
 };
 
 // src/lib/setAtoms.ts
-var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
+var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, report) => {
   const updatedAtoms = writeAtoms(pairs, data, initializedAtomsSet, skipOnSet);
   if (updatedAtoms.length > 0) {
-    propagateAtomUpdate(updatedAtoms, data);
+    propagateAtomUpdate(updatedAtoms, data, false, undefined, report);
   }
 };
 
@@ -1711,9 +2177,11 @@ class Transaction {
   data;
   parentTransaction;
   dirty;
+  name;
   _scopedTransactions;
   _initializedAtomsSet;
   _deleteSet;
+  _unsetSet;
   _selectorDependencies;
   _selectorCache;
   _atomMap;
@@ -1721,6 +2189,7 @@ class Transaction {
     this.data = data;
     this.parentTransaction = parentTransaction;
     this.dirty = false;
+    this.name = undefined;
     this._atomMap = new Map;
     if (childTransaction) {
       this._scopedTransactions = new Map([
@@ -1731,6 +2200,9 @@ class Transaction {
   hasTxnOrData = (state) => {
     if (this._atomMap.has(state))
       return true;
+    if (this._unsetSet?.has(state)) {
+      return this.parentTransaction ? this.parentTransaction.hasTxnOrData(state) : false;
+    }
     if (this.data.values.has(state))
       return true;
     if (this.parentTransaction)
@@ -1741,6 +2213,9 @@ class Transaction {
     if (this._atomMap.has(state)) {
       return this._atomMap.get(state);
     }
+    if (this._unsetSet?.has(state)) {
+      return this.parentTransaction ? this.parentTransaction.valueFromTxnOrData(state) : undefined;
+    }
     if (this.data.values.has(state)) {
       return this.data.values.get(state);
     }
@@ -1753,6 +2228,9 @@ class Transaction {
       if (this.hasTxnOrData(state)) {
         return this.valueFromTxnOrData(state);
       }
+      if (this._unsetSet?.has(state)) {
+        return this.data.parent ? getState(state, this.data.parent, this.initializedAtomsSet) : getAtomInitValue(state, this.data, this.initializedAtomsSet);
+      }
       return getState(state, this.data, this.initializedAtomsSet);
     } else if (isSelector(state)) {
       if (this.dirty) {
@@ -1788,6 +2266,7 @@ class Transaction {
       resolved = deepFreeze(resolved);
     }
     this._atomMap.set(atom, resolved);
+    this._unsetSet?.delete(atom);
     if (!this.dirty)
       this.dirty = true;
     if (isFamilyAtom(atom)) {
@@ -1816,6 +2295,7 @@ class Transaction {
       if (index.deleted.has(atom))
         index.deleted.delete(atom);
       this._atomMap.set(atom, value);
+      this._unsetSet?.delete(atom);
     }
     index.rendered = null;
     index.renderedArray = null;
@@ -1839,6 +2319,22 @@ class Transaction {
       this._atomMap.delete(atom);
     }
   };
+  unset = (atom) => {
+    if (!isAtom(atom))
+      throw new Error("unset() expects an atom.");
+    this._atomMap.delete(atom);
+    if (!this._unsetSet)
+      this._unsetSet = new Set;
+    this._unsetSet.add(atom);
+  };
+  applyUnsets = (unsetSet, data) => {
+    const unsetAtoms = [];
+    for (const atom of unsetSet) {
+      if (detachOwnValue(atom, data))
+        unsetAtoms.push(atom);
+    }
+    return unsetAtoms;
+  };
   scope = (scopeId, callback) => {
     if (this.data.scopes.has(scopeId)) {
       return this.scopedTransaction(scopeId).execute(callback, false);
@@ -1858,6 +2354,7 @@ class Transaction {
   reset = (atom) => {
     const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
     this._atomMap.set(atom, value);
+    this._unsetSet?.delete(atom);
     return value;
   };
   execute = (callback, autoCommit = true) => {
@@ -1874,18 +2371,58 @@ class Transaction {
     }
   };
   commit = () => {
+    if (changeListenerRegistry.count === 0) {
+      this.commitWork(undefined);
+      return;
+    }
+    const sink = createChangeSink(this.name);
+    try {
+      this.commitWork(sink);
+    } catch (error) {
+      try {
+        flushChangeSink(sink);
+      } catch {}
+      throw error;
+    }
+    flushChangeSink(sink);
+  };
+  commitWork = (sink) => {
     if (!this._scopedTransactions) {
       const initializedAtomsSet = new Set;
-      if (this._deleteSet?.size) {
-        const evaluatedSelectors2 = new Set;
+      if (this._unsetSet?.size) {
+        const notify2 = new Map;
         const updatedAtoms = writeAtoms(this._atomMap, this.data, initializedAtomsSet);
         if (updatedAtoms.length > 0) {
-          propagateAtomUpdate(updatedAtoms, this.data, false, evaluatedSelectors2);
+          propagateAtomUpdate(updatedAtoms, this.data, false, notify2, sink);
+        }
+        if (this._deleteSet?.size) {
+          deleteAtomFamilyAtoms(this._deleteSet, this.data);
+          propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, notify2, sink);
+        }
+        const unsetAtoms = this.applyUnsets(this._unsetSet, this.data);
+        if (unsetAtoms.length > 0) {
+          if (sink) {
+            for (const atom of unsetAtoms) {
+              reportUnsetAtom(atom, this.data, effectiveValueAfterUnset(atom, this.data), sink);
+            }
+          }
+          propagateAtomUpdate(unsetAtoms, this.data, false, notify2, sink, false, false);
+        }
+        notifyDeferred(notify2);
+        for (const atom of unsetAtoms) {
+          reDelegateScopeSubscriptions(atom, this.data);
+        }
+      } else 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, sink);
         }
         deleteAtomFamilyAtoms(this._deleteSet, this.data);
-        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, evaluatedSelectors2);
+        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, notify2, sink);
+        notifyDeferred(notify2);
       } else {
-        setAtoms(this._atomMap, this.data, initializedAtomsSet);
+        setAtoms(this._atomMap, this.data, initializedAtomsSet, false, sink);
       }
       return;
     }
@@ -1899,19 +2436,38 @@ class Transaction {
         deleteAtomFamilyAtoms(txn._deleteSet, entry.data);
         entry.deleted = [...txn._deleteSet];
       }
+      if (txn._unsetSet?.size) {
+        entry.unsetAtoms = txn.applyUnsets(txn._unsetSet, entry.data);
+      }
     }
     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) {
+    const notify = new Map;
+    for (const { data, updatedAtoms, deleted, unsetAtoms } of plan) {
       if (updatedAtoms.length > 0) {
-        propagateAtomUpdate(updatedAtoms, data, false, evaluatedSelectors);
+        propagateAtomUpdate(updatedAtoms, data, false, notify, sink);
       }
       if (deleted) {
-        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, evaluatedSelectors);
+        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, notify, sink);
+      }
+      if (unsetAtoms && unsetAtoms.length > 0) {
+        if (sink) {
+          for (const atom of unsetAtoms) {
+            reportUnsetAtom(atom, data, effectiveValueAfterUnset(atom, data), sink);
+          }
+        }
+        propagateAtomUpdate(unsetAtoms, data, false, notify, sink, false, false);
+      }
+    }
+    notifyDeferred(notify);
+    for (const { data, unsetAtoms } of plan) {
+      if (unsetAtoms) {
+        for (const atom of unsetAtoms) {
+          reDelegateScopeSubscriptions(atom, data);
+        }
       }
     }
   };
@@ -1921,6 +2477,7 @@ class Transaction {
       data: this.data,
       updatedAtoms: [],
       deleted: undefined,
+      unsetAtoms: undefined,
       onSets: []
     });
     if (this._scopedTransactions) {
@@ -1984,8 +2541,9 @@ class Transaction {
     }
   }
 }
-var transaction = (callback, data) => {
+var transaction = (callback, data, name) => {
   const txn = new Transaction(data);
+  txn.name = name;
   return txn.execute(callback);
 };
 
@@ -2096,12 +2654,19 @@ function storeFromStoreData(data, detach) {
       flushPendingTxn();
     return deleteFamilyAtom(atom, data);
   };
+  const unset = (atom) => {
+    if (data.batchUpdates)
+      flushPendingTxn();
+    return unsetValue(atom, data);
+  };
   const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
-  const txn = (callback) => {
+  const txn = (callback, name) => {
     if (data.batchUpdates)
       flushPendingTxn();
-    return transaction(callback, data);
+    return transaction(callback, data, name);
   };
+  const onChange = (callback, options) => onStoreChange(callback, data, options);
+  const storeSnapshot = () => snapshot(data);
   const scope = (scopeId, callback) => {
     if (callback) {
       if (!data.scopes.has(scopeId)) {
@@ -2154,8 +2719,11 @@ function storeFromStoreData(data, detach) {
       txn,
       reset,
       del,
+      unset,
       data,
       scope,
+      onChange,
+      snapshot: storeSnapshot,
       detach
     };
   } else {
@@ -2166,8 +2734,11 @@ function storeFromStoreData(data, detach) {
       txn,
       reset,
       del,
+      unset,
       data,
-      scope
+      scope,
+      onChange,
+      snapshot: storeSnapshot
     };
   }
 }
@@ -2348,12 +2919,13 @@ var unmountOrphanedDeps = (state, data, visited) => {
 };
 
 // src/store.ts
-var store = (idOrOptions) => {
-  const id = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
-  const options = typeof idOrOptions === "object" ? idOrOptions : undefined;
+function store(idOrOptions, maybeOptions) {
+  const optionsObject = typeof idOrOptions === "object" && idOrOptions !== null ? idOrOptions : undefined;
+  const id = typeof idOrOptions === "string" ? idOrOptions : optionsObject?.id;
+  const options = optionsObject ?? maybeOptions;
   const data = createStoreData(id, undefined, options);
   return storeFromStoreData(data);
-};
+}
 
 // src/globalStore.ts
 var globalStore = Object.assign(store("valdres-global-store"), {
@@ -2407,9 +2979,9 @@ var globalAtom = (defaultValue, options) => {
   const getSelf = () => globalStore.get(atom);
   const setSelf = (newValue) => globalStore.set(atom, newValue);
   const resetSelf = () => {
-    const snapshot = [...stores];
+    const snapshot2 = [...stores];
     const subscribedStores = [];
-    for (const s of snapshot) {
+    for (const s of snapshot2) {
       if (isLive(atom, s)) {
         subscribedStores.push(s);
       }
@@ -2419,7 +2991,7 @@ var globalAtom = (defaultValue, options) => {
       if (!firstError)
         firstError = e;
     };
-    for (const s of snapshot) {
+    for (const s of snapshot2) {
       try {
         unmountAtom(atom, s);
       } catch (e) {
@@ -2431,11 +3003,11 @@ var globalAtom = (defaultValue, options) => {
       atom.maxAgeInterval.refCount = 0;
       atom.maxAgeInterval = undefined;
     }
-    for (const store2 of snapshot) {
+    for (const store2 of snapshot2) {
       stores.delete(store2);
       store2.values.delete(atom);
       try {
-        propagateAtomUpdate([atom], store2);
+        propagateAtomUpdate([atom], store2, false, undefined, "reset");
       } catch (e) {
         recordError(e);
       }
@@ -2659,9 +3231,10 @@ var cacheMeta = (sourceAtom) => {
   if (sourceAtom.__cacheMetaSelector)
     return sourceAtom.__cacheMetaSelector;
   if (!sourceAtom.__cacheMeta) {
-    sourceAtom.__cacheMeta = { equal, defaultValue: null };
+    sourceAtom.__cacheMeta = { equal, defaultValue: null, __valdresInternal: true };
   }
   sourceAtom.__cacheMetaSelector = selector((get) => get(sourceAtom.__cacheMeta));
+  sourceAtom.__cacheMetaSelector.__valdresInternal = true;
   return sourceAtom.__cacheMetaSelector;
 };
 // src/indexConstructor.ts
@@ -2669,38 +3242,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);
-        });
-        addedAtoms.forEach((atom2) => {
-          termIndexSelectorSet.add(atom2);
-          termIndexSelectorMap.set(atom2, selector((get2) => callback(get2(atom2), term), {
-            name: `index:callback:selector:${atom2.name}`
-          }));
+    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}`
         });
-        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`
@@ -2748,9 +3310,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.5"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.7"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.5";
+  globalThis.__valdres__ = "1.0.0-beta.7";
 }
 export {
   store,