valdres 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/index.js

@@ -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,45 +122,7 @@ 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)
-    return obj;
-  if (typeof obj !== "object" && typeof obj !== "function")
-    return obj;
-  if (Object.isFrozen(obj) || seen?.has(obj))
-    return obj;
-  if (Array.isArray(obj)) {
-    for (const item of obj) {
-      if (item && typeof item === "object") {
-        seen ??= new WeakSet;
-        seen.add(obj);
-        deepFreeze(item, seen);
-      }
-    }
-  } else {
-    const propNames = Object.getOwnPropertyNames(obj);
-    for (const name of propNames) {
-      const value = obj[name];
-      if (value && typeof value === "object") {
-        seen ??= new WeakSet;
-        seen.add(obj);
-        deepFreeze(value, seen);
-      }
-    }
-  }
-  return Object.freeze(obj);
-};
-
-// src/lib/IS_PROD.ts
-var IS_PROD = typeof process !== "undefined" && process.env != null && process.env.NODE_ENV === "production";
-
-// src/lib/setValueInData.ts
+// src/lib/trackScopeValue.ts
 var trackScopeValue = (key, data) => {
   const parent = data.parent;
   const indexKeys = data.scopeIndexKeys;
@@ -170,30 +137,6 @@ var trackScopeValue = (key, data) => {
   set.add(data);
   indexKeys.add(key);
 };
-var setValueInData = (atom, value, data) => {
-  const isNewAtomInScope = data.parent && Object.hasOwn(atom, "defaultValue") && !data.values.has(atom);
-  let written;
-  if (atom.mutable || IS_PROD) {
-    data.values.set(atom, value);
-    written = value;
-  } else {
-    const frozenValue = value !== null && (typeof value === "object" || typeof value === "function") ? deepFreeze(value) : value;
-    data.values.set(atom, frozenValue);
-    written = frozenValue;
-  }
-  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());
-  }
-  return written;
-};
 
 // src/lib/atomFamilyIndex.ts
 var getAtomFamilyRenderedMap = (index) => {
@@ -292,13 +235,29 @@ var recursivelyUpdateIndexes = (data, family) => {
     recursivelyUpdateIndexes(scopedData, family);
   }
 };
+var ensureFamilyAncestorChain = (family, data) => {
+  if (!data.parent)
+    return;
+  const parentIndex = initFamilyIndex(family, data.parent);
+  const own = data.values.get(family).__index;
+  if (own.parentIndex !== parentIndex) {
+    own.parentIndex = parentIndex;
+    own.rendered = null;
+    own.renderedArray = null;
+    data.values.set(family, renderAtomFamilyIndex(own));
+    recursivelyUpdateIndexes(data, family);
+  }
+};
 var addFamilyAtomsToSet = (family, familyAtoms, data, timestamp) => {
   if (familyAtoms.size === 0)
-    return;
+    return false;
   const index = findFamilyIndex(family, data);
   if (!index)
     throw new Error("index not found");
+  let membershipChanged = false;
   for (const atom of familyAtoms) {
+    if (!(index.created.has(atom) && !index.deleted.has(atom)))
+      membershipChanged = true;
     index.created.set(atom, timestamp);
     index.deleted.delete(atom);
   }
@@ -306,6 +265,7 @@ var addFamilyAtomsToSet = (family, familyAtoms, data, timestamp) => {
   index.renderedArray = null;
   data.values.set(family, renderAtomFamilyIndex(index));
   recursivelyUpdateIndexes(data, family);
+  return membershipChanged;
 };
 
 // src/errors/lib/generateSelectorTrace.ts
@@ -403,6 +363,276 @@ 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/utils/deepFreeze.ts
+var deepFreeze = (obj, seen) => {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object" && typeof obj !== "function")
+    return obj;
+  if (Object.isFrozen(obj) || seen?.has(obj))
+    return obj;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (item && typeof item === "object") {
+        seen ??= new WeakSet;
+        seen.add(obj);
+        deepFreeze(item, seen);
+      }
+    }
+  } else {
+    const propNames = Object.getOwnPropertyNames(obj);
+    for (const name of propNames) {
+      const value = obj[name];
+      if (value && typeof value === "object") {
+        seen ??= new WeakSet;
+        seen.add(obj);
+        deepFreeze(value, seen);
+      }
+    }
+  }
+  return Object.freeze(obj);
+};
+
+// src/lib/IS_PROD.ts
+var IS_PROD = typeof process !== "undefined" && process.env != null && process.env.NODE_ENV === "production";
+
+// src/lib/setValueInData.ts
+var setValueInData = (atom, value, data) => {
+  const isNewAtomInScope = data.parent && Object.hasOwn(atom, "defaultValue") && !data.values.has(atom);
+  const isNewFamilyInScope = !!data.parent && !data.values.has(atom) && isAtomFamily(atom);
+  let written;
+  if (atom.mutable || IS_PROD) {
+    data.values.set(atom, value);
+    written = value;
+  } else {
+    const frozenValue = value !== null && (typeof value === "object" || typeof value === "function") ? deepFreeze(value) : value;
+    data.values.set(atom, frozenValue);
+    written = frozenValue;
+  }
+  if (isNewAtomInScope) {
+    trackScopeValue(atom, data);
+    const subs = data.subscriptions.get(atom);
+    if (subs) {
+      for (const sub of subs)
+        sub.reRoot?.();
+    }
+  } else if (isNewFamilyInScope) {
+    trackScopeValue(atom, data);
+    ensureFamilyAncestorChain(atom, data);
+  }
+  if (atom.maxAge !== undefined) {
+    data.lastValueWriteAt.set(atom, Date.now());
+  }
+  return written;
+};
+
 // src/lib/initSelector.ts
 var neverAbortedSignal = new AbortController().signal;
 var syncOptionsCache = new WeakMap;
@@ -549,7 +779,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 +820,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);
@@ -718,7 +953,7 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, deletedFamilyAtoms = new Map, timestamp = performance.now(), notify) => {
+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;
@@ -743,30 +978,35 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, deletedFamily
       deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, deletedFamilyAtoms, false, notify);
+  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);
-  if (deletedFamilyAtoms.size > 0 && data.scopes && data.scopes.size > 0) {
-    const scopeFamilies = new Map;
+  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()) {
-      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, notify);
+      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) => {
+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)) {
@@ -779,6 +1019,9 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify) => {
           else
             callSubscribers(subs);
         }
+        if (reportAtoms && report !== undefined && changeListenerRegistry.count !== 0 && !isInitOnly) {
+          reportAtomChanges(atoms, data, report);
+        }
         return;
       }
     }
@@ -790,13 +1033,14 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify) => {
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
     addSetToSet(data.subscriptions.get(atom), subscriptions);
-    if (isFamilyAtom(atom)) {
+    if (isFamilyAtom(atom) && !skipFamilyIndexUpdate) {
       if (!updatedFamilyAtoms.has(atom.family)) {
         updatedFamilyAtoms.set(atom.family, new Set);
       }
       updatedFamilyAtoms.get(atom.family).add(atom);
     }
   }
+  let membershipChanged;
   if (updatedFamilyAtoms.size > 0) {
     const timestamp = performance.now();
     for (const [family, familyAtoms] of updatedFamilyAtoms) {
@@ -804,7 +1048,11 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify) => {
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
         throw new Error("Should not be possible");
-      addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
+      if (addFamilyAtomsToSet(family, familyAtoms, data, timestamp)) {
+        if (!membershipChanged)
+          membershipChanged = new Set;
+        membershipChanged.add(family);
+      }
     }
   }
   if (data.scopes && data.scopes.size > 0) {
@@ -814,32 +1062,68 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify) => {
       }
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, updatedFamilyAtoms, isInitOnly, notify);
+  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);
-  if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly, notify);
+  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;
+  }
+  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) {
+    let scopeAtoms = atoms;
+    if (membershipChanged) {
+      scopeAtoms = atoms.slice();
+      for (const family of membershipChanged) {
+        if (!scopeAtoms.includes(family))
+          scopeAtoms.push(family);
+      }
+    }
+    propagateToScopes(scopeAtoms, data, isInitOnly, notify, effectiveReport);
   }
+  if (watching && !reportIsSink)
+    emitOrigin(effectiveReport);
+  if (localSink)
+    flushChangeSink(localSink);
 };
-var propagateInScope = (atoms, data, isInitOnly = false, notify) => {
+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, notify);
+  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, notify);
+    propagateToScopes(atoms, data, isInitOnly, notify, report);
   }
 };
-var propagateToScopes = (atoms, data, isInitOnly, notify) => {
+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, notify);
+        propagateInScope(atoms, scope, isInitOnly, notify, report);
       }
     }
     return;
@@ -859,7 +1143,7 @@ var propagateToScopes = (atoms, data, isInitOnly, notify) => {
   }
   if (!anyShadowed) {
     for (const [, scope] of data.scopes) {
-      propagateInScope(atoms, scope, isInitOnly, notify);
+      propagateInScope(atoms, scope, isInitOnly, notify, report);
     }
     return;
   }
@@ -876,20 +1160,20 @@ var propagateToScopes = (atoms, data, isInitOnly, notify) => {
       }
     }
     if (atomsToUpdateInScope.length > 0) {
-      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, notify);
+      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, notify, report);
     }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, notify) => {
+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);
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly, changedSelectors);
   }
   if (!notify && subscriptions.size > 0) {
     callSubscribers(subscriptions, families);
   }
 };
-var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly) => {
+var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, changedSelectors) => {
   const closure = new Set(seeds);
   {
     const stack = [...seeds];
@@ -989,8 +1273,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)
@@ -1038,6 +1325,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);
@@ -1050,7 +1339,7 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     work = next;
   }
 };
-var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false, changedSelectors) => {
   if (selectors.size === 0)
     return;
   let downstreamSeeds;
@@ -1086,6 +1375,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);
@@ -1097,7 +1388,7 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     }
   }
   if (downstreamSeeds && downstreamSeeds.size > 0) {
-    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly);
+    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, changedSelectors);
   }
 };
 
@@ -1128,12 +1419,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) => {
@@ -1155,9 +1446,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;
   }
@@ -1171,9 +1462,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;
 };
@@ -1194,7 +1485,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);
@@ -1218,6 +1509,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))
@@ -1229,7 +1537,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;
         }
       }
     }
@@ -1287,6 +1609,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++;
@@ -1320,7 +1699,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;
@@ -1341,7 +1723,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
@@ -1350,7 +1767,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");
@@ -1358,6 +1775,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);
 
@@ -1447,11 +1896,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;
       }
     }
@@ -1478,7 +1927,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,
@@ -1490,11 +1939,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 = () => {
@@ -1505,11 +1954,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 = () => {
@@ -1640,15 +2089,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);
@@ -1673,13 +2131,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);
@@ -1735,10 +2195,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);
   }
 };
 
@@ -1753,9 +2213,11 @@ class Transaction {
   data;
   parentTransaction;
   dirty;
+  name;
   _scopedTransactions;
   _initializedAtomsSet;
   _deleteSet;
+  _unsetSet;
   _selectorDependencies;
   _selectorCache;
   _atomMap;
@@ -1763,6 +2225,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([
@@ -1773,6 +2236,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)
@@ -1783,6 +2249,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);
     }
@@ -1795,6 +2264,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) {
@@ -1830,6 +2302,7 @@ class Transaction {
       resolved = deepFreeze(resolved);
     }
     this._atomMap.set(atom, resolved);
+    this._unsetSet?.delete(atom);
     if (!this.dirty)
       this.dirty = true;
     if (isFamilyAtom(atom)) {
@@ -1858,6 +2331,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;
@@ -1881,6 +2355,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);
@@ -1900,6 +2390,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) => {
@@ -1916,19 +2407,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) {
+      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, notify2);
+          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, notify2);
+        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;
     }
@@ -1942,6 +2472,9 @@ 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) {
@@ -1949,15 +2482,30 @@ class Transaction {
       }
     }
     const notify = new Map;
-    for (const { data, updatedAtoms, deleted } of plan) {
+    for (const { data, updatedAtoms, deleted, unsetAtoms } of plan) {
       if (updatedAtoms.length > 0) {
-        propagateAtomUpdate(updatedAtoms, data, false, notify);
+        propagateAtomUpdate(updatedAtoms, data, false, notify, sink);
       }
       if (deleted) {
-        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, notify);
+        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);
+        }
+      }
+    }
   };
   collectStores = (plan) => {
     plan.push({
@@ -1965,6 +2513,7 @@ class Transaction {
       data: this.data,
       updatedAtoms: [],
       deleted: undefined,
+      unsetAtoms: undefined,
       onSets: []
     });
     if (this._scopedTransactions) {
@@ -2007,7 +2556,13 @@ class Transaction {
     if (moveUpIfParent && this.parentTransaction)
       return this.parentTransaction.cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent);
     const currentFamilyList = this.get(family);
-    const clonedIndex = cloneAtomFamilyIndex(currentFamilyList.__index, parentIndex);
+    const scopeFirstMaterialization = this.data.parent && !this._atomMap.has(family) && !this.data.values.has(family);
+    let clonedIndex;
+    if (scopeFirstMaterialization) {
+      clonedIndex = createAtomFamilyIndex(parentIndex ?? currentFamilyList.__index);
+    } else {
+      clonedIndex = cloneAtomFamilyIndex(currentFamilyList.__index, parentIndex);
+    }
     if (this._scopedTransactions?.size) {
       for (const [, scopedTxn] of this._scopedTransactions) {
         scopedTxn.cloneFamilyIntoTxn(family, clonedIndex, false);
@@ -2028,8 +2583,9 @@ class Transaction {
     }
   }
 }
-var transaction = (callback, data) => {
+var transaction = (callback, data, name) => {
   const txn = new Transaction(data);
+  txn.name = name;
   return txn.execute(callback);
 };
 
@@ -2140,12 +2696,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)) {
@@ -2198,8 +2761,11 @@ function storeFromStoreData(data, detach) {
       txn,
       reset,
       del,
+      unset,
       data,
       scope,
+      onChange,
+      snapshot: storeSnapshot,
       detach
     };
   } else {
@@ -2210,8 +2776,11 @@ function storeFromStoreData(data, detach) {
       txn,
       reset,
       del,
+      unset,
       data,
-      scope
+      scope,
+      onChange,
+      snapshot: storeSnapshot
     };
   }
 }
@@ -2392,12 +2961,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"), {
@@ -2451,9 +3021,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);
       }
@@ -2463,7 +3033,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) {
@@ -2475,11 +3045,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);
       }
@@ -2703,9 +3273,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
@@ -2781,9 +3352,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.6"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.8"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.6";
+  globalThis.__valdres__ = "1.0.0-beta.8";
 }
 export {
   store,