valdres 0.2.0-pre.8 → 1.0.0-beta.0

package/dist/index.js

@@ -99,69 +99,38 @@ var equal = (a, b, updatedAtomsSet) => {
 // src/utils/isAtom.ts
 var isAtom = (state) => Object.hasOwn(state, "defaultValue");
 
+// src/utils/isGlobalAtom.ts
+var isGlobalAtom = (state) => Object.hasOwn(state, "stores");
+
+// src/utils/isSelector.ts
+var isSelector = (state) => state && Object.hasOwn(state, "get");
+
+// src/utils/isAtomFamily.ts
+var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
+
 // src/utils/isFamilyState.ts
 var isFamilyState = (state) => state && Object.hasOwn(state, "family");
 
 // src/utils/isFamilyAtom.ts
 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/errors/lib/generateSelectorTrace.ts
-var generateSelectorTrace = (selectors) => {
-  const lastIndex = selectors.length - 1;
-  return [...selectors].reverse().map((selector, index) => {
-    const name = selector.name ?? "Anonymous Selector";
-    if (index === 0) {
-      return `[START] ${name}`;
-    } else if (index === lastIndex) {
-      return `[CRASH] ${name}`;
-    } else {
-      return `        ${" ".repeat(index)}${name}`;
-    }
-  }).join(`
-`);
-};
-
-// src/errors/SelectorEvaluationError.ts
-class SelectorEvaluationError extends Error {
-  selectors;
-  constructor(cause) {
-    super();
-    this.cause = cause;
-    this.selectors = [];
-  }
-  track(selector) {
-    this.selectors.push(selector);
-  }
-  get message() {
-    const firstSelectorName = this.selectors[0].name ?? "Anonymous Selector";
-    return `Selector eval crashed in '${firstSelectorName}'
-${generateSelectorTrace(this.selectors)}`;
-  }
-}
-
-// src/utils/isAtomFamily.ts
-var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
-
-// src/utils/isSelector.ts
-var isSelector = (state) => state && Object.hasOwn(state, "get");
-
-// src/utils/isSelectorFamily.ts
-var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
-
-// src/lib/isFunction.ts
-var isFunction = (value) => typeof value === "function";
-
 // src/utils/deepFreeze.ts
 var deepFreeze = (obj, seen = new WeakSet) => {
-  if (obj === null || obj === undefined || seen.has(obj))
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object" && typeof obj !== "function")
     return obj;
-  if (obj && typeof obj === "object")
-    seen.add(obj);
+  if (seen.has(obj) || Object.isFrozen(obj))
+    return obj;
+  seen.add(obj);
   if (Array.isArray(obj)) {
     for (const item of obj) {
       if (item && typeof item === "object") {
@@ -186,120 +155,196 @@ var isProd = () => {
 };
 
 // src/lib/setValueInData.ts
+var trackScopeValue = (key, data) => {
+  const parent = data.parent;
+  let set = parent.scopeValueIndex.get(key);
+  if (!set) {
+    set = new Set;
+    parent.scopeValueIndex.set(key, set);
+  }
+  set.add(data);
+  data.scopeIndexKeys.add(key);
+};
 var setValueInData = (atom, value, data) => {
+  const isNewAtomInScope = "parent" in data && Object.hasOwn(atom, "defaultValue") && !data.values.has(atom);
+  let written;
   if (atom.mutable || isProd()) {
     data.values.set(atom, value);
-    return value;
+    written = value;
   } else {
-    const frozenValue = deepFreeze(value);
+    const frozenValue = value !== null && (typeof value === "object" || typeof value === "function") ? deepFreeze(value) : value;
     data.values.set(atom, frozenValue);
-    return frozenValue;
+    written = frozenValue;
   }
+  if (isNewAtomInScope)
+    trackScopeValue(atom, data);
+  if (atom.maxAge !== undefined) {
+    data.lastValueWriteAt.set(atom, Date.now());
+  }
+  return written;
 };
 
-// src/lib/setAtom.ts
-var setAtom = (atom, newValue, data, skipOnSet = false) => {
-  const initializedAtomsSet = new Set;
-  const currentValue = getState(atom, data, initializedAtomsSet);
-  if (isFunction(newValue)) {
-    newValue = newValue(currentValue);
-    if (isPromiseLike(newValue) || isPromiseLike(currentValue))
-      throw new Error("Todo, how should we handle this?");
+// src/lib/atomFamilyIndex.ts
+var getAtomFamilyRenderedMap = (index) => {
+  if (index.rendered)
+    return index.rendered;
+  const result = new Map(index.parentIndex ? getAtomFamilyRenderedMap(index.parentIndex) : undefined);
+  for (const [atom, timestamp] of index.created) {
+    result.set(atom, timestamp);
+  }
+  for (const [atom, timestamp] of index.deleted) {
+    result.delete(atom);
+  }
+  index.rendered = result;
+  return result;
+};
+var getSortedKeysByValues = (map) => {
+  return Array.from(map.entries()).sort((a, b) => a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0).map((entry) => entry[0]);
+};
+var renderAtomFamilyIndex = (index) => {
+  if (index.renderedArray) {
+    return index.renderedArray;
+  }
+  const renderedMap = getAtomFamilyRenderedMap(index);
+  const array = getSortedKeysByValues(renderedMap);
+  array.__index = index;
+  index.renderedArray = array;
+  return array;
+};
+var cloneAtomFamilyIndex = (index, parentIndexOverride) => {
+  return {
+    created: new Map(index.created),
+    deleted: new Map(index.deleted),
+    rendered: null,
+    renderedArray: null,
+    parentIndex: parentIndexOverride || index.parentIndex
+  };
+};
+var createAtomFamilyIndex = (parentIndex) => {
+  return {
+    created: new Map,
+    deleted: new Map,
+    rendered: null,
+    renderedArray: null,
+    parentIndex
+  };
+};
+var deleteFamilyAtomsFromSet = (family, familyAtoms, data, timestamp) => {
+  if (familyAtoms.size === 0)
+    return;
+  const index = findFamilyIndex(family, data);
+  for (const atom of familyAtoms) {
+    index.deleted.set(atom, timestamp);
+  }
+  index.rendered = null;
+  index.renderedArray = null;
+  data.values.set(family, renderAtomFamilyIndex(index));
+  recursivelyUpdateIndexes(data, family);
+};
+var initFamilyIndex = (family, data) => {
+  if (data.values.has(family))
+    return data.values.get(family).__index;
+  let parentIndex;
+  if ("parent" in data) {
+    parentIndex = initFamilyIndex(family, data.parent);
+    if (!parentIndex)
+      throw new Error("Parent index is missing");
+  }
+  const index = createAtomFamilyIndex(parentIndex);
+  data.values.set(family, renderAtomFamilyIndex(index));
+  if ("parent" in data) {
+    trackScopeValue(family, data);
+  }
+  return index;
+};
+var findFamilyIndex = (family, data) => {
+  if (!data.values.has(family)) {
+    initFamilyIndex(family, data);
   }
-  if (atom.equal(currentValue, newValue))
-    return newValue;
-  newValue = setValueInData(atom, newValue, data);
-  if (atom.onSet && !skipOnSet)
-    atom.onSet(newValue, data);
-  if (currentValue?.__isEmptyAtomPromise__) {
-    currentValue.__resolveEmptyAtomPromise__(newValue);
+  const value = data.values.get(family);
+  if (!value?.__index) {
+    throw new Error("Family index is missing");
   }
-  if (initializedAtomsSet.size > 0) {
-    const all = new Set([...initializedAtomsSet, atom]);
-    propagateUpdatedAtoms([...all], data);
-  } else {
-    propagateUpdatedAtoms([atom], data);
+  return value.__index;
+};
+var recursivelyUpdateIndexes = (data, family) => {
+  const childScopesWithFamily = data.scopeValueIndex.get(family);
+  if (!childScopesWithFamily || childScopesWithFamily.size === 0)
+    return;
+  for (const scopedData of childScopesWithFamily) {
+    const index = scopedData.values.get(family).__index;
+    index.rendered = null;
+    index.renderedArray = null;
+    scopedData.values.set(family, renderAtomFamilyIndex(index));
+    recursivelyUpdateIndexes(scopedData, family);
   }
-  return newValue;
+};
+var addFamilyAtomsToSet = (family, familyAtoms, data, timestamp) => {
+  if (familyAtoms.size === 0)
+    return;
+  const index = findFamilyIndex(family, data);
+  if (!index)
+    throw new Error("index not found");
+  for (const atom of familyAtoms) {
+    index.created.set(atom, timestamp);
+    index.deleted.delete(atom);
+  }
+  index.rendered = null;
+  index.renderedArray = null;
+  data.values.set(family, renderAtomFamilyIndex(index));
+  recursivelyUpdateIndexes(data, family);
 };
 
-// src/lib/initAtom.ts
-var getAtomInitValue = (atom, data, initializedAtomsSet) => {
-  if (atom.defaultValue === undefined) {
-    let promiseResolve;
-    const promise = new Promise((resolve) => {
-      promiseResolve = resolve;
-    });
-    promise.__isEmptyAtomPromise__ = true;
-    promise.__resolveEmptyAtomPromise__ = promiseResolve;
-    return promise;
-  } else if (typeof atom.defaultValue === "function") {
-    const value = atom.defaultValue();
-    if (isPromiseLike(value)) {
-      value.then((resolvedValue) => {
-        setValueInData(atom, resolvedValue, data);
-        propagateUpdatedAtoms([atom], data);
-      });
+// src/errors/lib/generateSelectorTrace.ts
+var generateSelectorTrace = (selectors) => {
+  const lastIndex = selectors.length - 1;
+  return [...selectors].reverse().map((selector, index) => {
+    const name = selector.name ?? "Anonymous Selector";
+    if (index === 0) {
+      return `[START] ${name}`;
+    } else if (index === lastIndex) {
+      return `[CRASH] ${name}`;
+    } else {
+      return `        ${" ".repeat(index)}${name}`;
     }
-    return value;
-  } else if (isSelector(atom.defaultValue)) {
-    return getState(atom.defaultValue, data, initializedAtomsSet);
-  } else {
-    return atom.defaultValue;
-  }
-};
-var initAtom = (atom, data, initializedAtomsSet) => {
-  const tmpVal = getAtomInitValue(atom, data, initializedAtomsSet);
-  let value = setValueInData(atom, tmpVal, data);
-  if (atom.onInit)
-    atom.onInit((newVal) => {
-      value = newVal;
-      setAtom(atom, newVal, data, true);
-    }, data);
+  }).join(`
+`);
 };
 
-// src/lib/getState.ts
-function getState(state, data, initializedAtomsSet, circularDependencySet) {
-  if (data.values.has(state))
-    return data.values.get(state);
-  if (isAtom(state)) {
-    if ("parent" in data)
-      return getState(state, data.parent, initializedAtomsSet, circularDependencySet);
-    initAtom(state, data, initializedAtomsSet);
-    initializedAtomsSet.add(state);
-    return data.values.get(state);
+// src/errors/SelectorEvaluationError.ts
+class SelectorEvaluationError extends Error {
+  selectors;
+  constructor(cause) {
+    super();
+    this.cause = cause;
+    this.selectors = [];
   }
-  if (isSelector(state)) {
-    initSelector(state, data, initializedAtomsSet, circularDependencySet);
-    return data.values.get(state);
+  track(selector) {
+    this.selectors.push(selector);
   }
-  if (isAtomFamily(state)) {
-    if ("parent" in data) {
-      const closestData = findClosestStoreWithAtomInitialized(state, data);
-      return getState(state, closestData, initializedAtomsSet, circularDependencySet);
-    }
-    data.values.set(state, []);
-    initializedAtomsSet.add(state);
-    return data.values.get(state);
+  get message() {
+    const firstSelectorName = this.selectors[0].name ?? "Anonymous Selector";
+    return `Selector eval crashed in '${firstSelectorName}'
+${generateSelectorTrace(this.selectors)}`;
   }
-  if (isSelectorFamily(state)) {
-    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
-    if (equal(array, state._keyArray))
-      return state._keyArray;
-    state._keyArray = array;
-    return array;
+}
+
+// src/errors/SelectorCircularDependencyError.ts
+class SelectorCircularDependencyError extends SelectorEvaluationError {
+  constructor() {
+    super();
+  }
+  get message() {
+    const firstSelectorName = this.selectors[0].name ?? "Anonymous Selector";
+    return `Circular dependency detected in '${firstSelectorName}'
+${generateSelectorTrace(this.selectors)}`;
   }
-  throw new Error("Invalid object passed to get");
 }
-var findClosestStoreWithAtomInitialized = (atom, data) => {
-  if ("parent" in data === false)
-    return data;
-  if (data.values.has(atom))
-    return data;
-  return findClosestStoreWithAtomInitialized(atom, data.parent);
-};
 
-// src/lib/initSelector.ts
+// src/lib/asyncDependencyTracking.ts
+var pendingAsyncDeps = new WeakMap;
+var latestEvalContext = new WeakMap;
+
 class SuspendAndWaitForResolveError extends Error {
   promise;
   constructor(promise) {
@@ -307,6 +352,9 @@ class SuspendAndWaitForResolveError extends Error {
     this.promise = promise;
   }
 }
+var isSuspendError = (e) => {
+  return e instanceof SuspendAndWaitForResolveError;
+};
 var getOrInitDependentsSet = (state, data) => {
   const set = data.stateDependents.get(state);
   if (set)
@@ -315,20 +363,103 @@ var getOrInitDependentsSet = (state, data) => {
   data.stateDependents.set(state, newSet);
   return newSet;
 };
-var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencySet = new WeakSet) => {
-  const updatedDependencies = new Set;
-  if (circularDependencySet.has(selector)) {}
+var lateGet = (state, selector, data) => {
+  let deps = data.stateDependencies.get(selector);
+  if (!deps) {
+    deps = new Set;
+    data.stateDependencies.set(selector, deps);
+  }
+  const isNewDep = !deps.has(state);
+  if (isNewDep) {
+    deps.add(state);
+    const dependents = getOrInitDependentsSet(state, data);
+    dependents.add(selector);
+  }
+  const lateInitSet = new Set;
+  try {
+    return getState(state, data, lateInitSet);
+  } finally {
+    if (isNewDep && isTransitivelySubscribed(selector, data)) {
+      mountTransitiveDeps(state, data);
+    }
+  }
+};
+var cleanUpRejectedPromise = (selector, data, promise) => {
+  if (data.values.has(selector) && data.values.get(selector) !== promise)
+    return;
+  data.values.delete(selector);
+};
+
+// src/lib/initSelector.ts
+class NeedsInitError {
+  selector;
+  constructor(selector) {
+    this.selector = selector;
+  }
+}
+var _evalDepth = 0;
+var _inTrampoline = false;
+var MAX_EVAL_DEPTH = 100;
+var sharedCircularDepSet = new WeakSet;
+var neverAbortedSignal = new AbortController().signal;
+var syncOptionsCache = new WeakMap;
+var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencySet = sharedCircularDepSet, addedDepsOut, removedDepsOut) => {
+  const currentDependencies = data.stateDependencies.get(selector);
+  const updatedDepsArray = [];
+  let depsChanged = false;
+  let evaluationComplete = false;
+  const prevCtx = latestEvalContext.get(selector);
+  if (prevCtx)
+    prevCtx.revoked = true;
+  const evalCtx = { revoked: false };
+  latestEvalContext.set(selector, evalCtx);
+  if (circularDependencySet.has(selector)) {
+    throw new SelectorCircularDependencyError;
+  }
   circularDependencySet.add(selector);
+  const prev = data.abortControllers.get(selector);
+  let options;
+  if (prev === false) {
+    let cached = syncOptionsCache.get(data);
+    if (!cached) {
+      cached = { signal: neverAbortedSignal, storeId: data.id };
+      syncOptionsCache.set(data, cached);
+    }
+    options = cached;
+  } else {
+    if (prev)
+      prev.abort();
+    const abortController = new AbortController;
+    data.abortControllers.set(selector, abortController);
+    options = { signal: abortController.signal, storeId: data.id };
+  }
+  let allDepsThisEval;
   let result;
   try {
     result = selector.get((state) => {
+      if (evaluationComplete) {
+        if (!evalCtx.revoked && allDepsThisEval) {
+          allDepsThisEval.add(state);
+        }
+        if (evalCtx.revoked) {
+          return getState(state, data, new Set);
+        }
+        return lateGet(state, selector, data);
+      }
       const value = getState(state, data, initializedAtomsSet, circularDependencySet);
-      updatedDependencies.add(state);
+      updatedDepsArray.push(state);
+      if (!depsChanged && (!currentDependencies || !currentDependencies.has(state))) {
+        depsChanged = true;
+      }
       if (isPromiseLike(value))
         throw new SuspendAndWaitForResolveError(value);
       return value;
-    }, data.id);
+    }, options);
   } catch (error) {
+    if (error instanceof NeedsInitError) {
+      circularDependencySet.delete(selector);
+      throw error;
+    }
     if (error instanceof SuspendAndWaitForResolveError) {
       result = error;
     } else if (error instanceof SelectorEvaluationError) {
@@ -337,55 +468,168 @@ var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencyS
       throw new SelectorEvaluationError(error);
     }
   }
-  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
-  const added = updatedDependencies?.difference(currentDependencies);
-  const removed = currentDependencies?.difference(updatedDependencies);
-  for (const state of added) {
-    const set = getOrInitDependentsSet(state, data);
-    set.add(selector);
+  evaluationComplete = true;
+  const isAsyncResult = result instanceof SuspendAndWaitForResolveError || isPromiseLike(result);
+  if (!isAsyncResult && !depsChanged && currentDependencies && currentDependencies.size !== updatedDepsArray.length) {
+    depsChanged = true;
+  }
+  if (depsChanged || !currentDependencies) {
+    const updatedDependencies = new Set(updatedDepsArray);
+    if (isAsyncResult && currentDependencies) {
+      for (const dep of currentDependencies) {
+        updatedDependencies.add(dep);
+      }
+    }
+    const prev2 = currentDependencies ?? new Set;
+    for (const state of updatedDependencies) {
+      if (!prev2.has(state)) {
+        const set = getOrInitDependentsSet(state, data);
+        set.add(selector);
+        if (addedDepsOut)
+          addedDepsOut.add(state);
+      }
+    }
+    if (!isAsyncResult) {
+      for (const state of prev2) {
+        if (!updatedDependencies.has(state)) {
+          const set = getOrInitDependentsSet(state, data);
+          set.delete(selector);
+          if (removedDepsOut)
+            removedDepsOut.add(state);
+        }
+      }
+    }
+    data.stateDependencies.set(selector, updatedDependencies);
   }
-  for (const state of removed) {
-    const set = getOrInitDependentsSet(state, data);
-    set.delete(selector);
+  if (isPromiseLike(result)) {
+    allDepsThisEval = new Set(updatedDepsArray);
+    pendingAsyncDeps.set(result, allDepsThisEval);
   }
-  data.stateDependencies.set(selector, updatedDependencies);
+  circularDependencySet.delete(selector);
   return result;
 };
 var handleSelectorResult = (value, selector, data) => {
   if (value instanceof SuspendAndWaitForResolveError) {
-    value.promise.then(() => {
+    data.abortControllers.delete(selector);
+    const promise = value.promise;
+    promise.then(() => {
+      if (!data.stateDependencies.has(selector))
+        return;
+      if (data.values.has(selector) && data.values.get(selector) !== promise)
+        return;
       const initializedAtomsSet = new Set;
       const res = initSelector(selector, data, initializedAtomsSet);
       if (initializedAtomsSet.size > 0) {
         propagateUpdatedAtoms([...initializedAtomsSet], data);
       }
       return res;
+    }).catch(() => {
+      cleanUpRejectedPromise(selector, data, promise);
     });
-    return value.promise;
+    return promise;
   } else if (isPromiseLike(value)) {
     value.then((resolved) => {
+      if (!data.stateDependencies.has(selector)) {
+        pendingAsyncDeps.delete(value);
+        return;
+      }
+      if (data.values.has(selector) && data.values.get(selector) !== value) {
+        pendingAsyncDeps.delete(value);
+        return;
+      }
+      const evalDeps = pendingAsyncDeps.get(value);
+      if (evalDeps) {
+        pendingAsyncDeps.delete(value);
+        const currentDeps = data.stateDependencies.get(selector);
+        if (currentDeps) {
+          for (const dep of currentDeps) {
+            if (!evalDeps.has(dep)) {
+              currentDeps.delete(dep);
+              const dependents2 = data.stateDependents.get(dep);
+              if (dependents2)
+                dependents2.delete(selector);
+              unmountOrphanedDeps(dep, data);
+            }
+          }
+        }
+      }
       setValueInData(selector, resolved, 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);
       }
+    }).catch(() => {
+      pendingAsyncDeps.delete(value);
+      cleanUpRejectedPromise(selector, data, value);
     });
     return value;
   } else {
+    data.abortControllers.set(selector, false);
     return value;
   }
 };
-var initSelector = (selector, data, initializedAtomsSet, circularDependencySet = new WeakSet) => {
+var initSelectorDirect = (selector, data, initializedAtomsSet, circularDependencySet) => {
   const existingValue = data.values.get(selector);
-  const udpatedValue = evaluate(selector, data, initializedAtomsSet, circularDependencySet);
-  if (selector.equal(existingValue, udpatedValue)) {
+  const updatedValue = evaluate(selector, data, initializedAtomsSet, circularDependencySet);
+  const areEqual = isPromiseLike(existingValue) || isPromiseLike(updatedValue) ? existingValue === updatedValue : selector.equal(existingValue, updatedValue);
+  if (areEqual) {
     return false;
   } else {
-    setValueInData(selector, udpatedValue, data);
+    setValueInData(selector, updatedValue, data);
     return true;
   }
 };
+var initSelectorTrampoline = (selector, data, initializedAtomsSet, circularDependencySet) => {
+  const stack = [selector];
+  const inStack = new Set([selector]);
+  while (stack.length > 0) {
+    const current = stack[stack.length - 1];
+    if (data.values.has(current)) {
+      stack.pop();
+      inStack.delete(current);
+      continue;
+    }
+    try {
+      initSelectorDirect(current, data, initializedAtomsSet, circularDependencySet);
+      stack.pop();
+      inStack.delete(current);
+    } catch (e) {
+      if (e instanceof NeedsInitError) {
+        if (inStack.has(e.selector)) {
+          throw new SelectorCircularDependencyError;
+        }
+        stack.push(e.selector);
+        inStack.add(e.selector);
+      } else {
+        throw e;
+      }
+    }
+  }
+};
+var initSelector = (selector, data, initializedAtomsSet, circularDependencySet = sharedCircularDepSet) => {
+  const isTopLevel = _evalDepth === 0 && !_inTrampoline;
+  _evalDepth++;
+  const existingValue = data.values.get(selector);
+  try {
+    return initSelectorDirect(selector, data, initializedAtomsSet, circularDependencySet);
+  } catch (e) {
+    if (e instanceof NeedsInitError && isTopLevel) {
+      _inTrampoline = true;
+      try {
+        initSelectorTrampoline(selector, data, initializedAtomsSet, circularDependencySet);
+      } finally {
+        _inTrampoline = false;
+      }
+      const newValue = data.values.get(selector);
+      const areEqual = isPromiseLike(existingValue) || isPromiseLike(newValue) ? existingValue === newValue : selector.equal(existingValue, newValue);
+      return !areEqual;
+    }
+    throw e;
+  } finally {
+    _evalDepth--;
+  }
+};
 var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
   let tmpValue;
   try {
@@ -401,20 +645,55 @@ var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
 // src/lib/propagateUpdatedAtoms.ts
 var reEvaluteSelector = (selector, data, updatedAtoms) => {
   const existingValue = data.values.get(selector);
+  const addedDeps = new Set;
+  const removedDeps = new Set;
   try {
-    const udpatedValue = evaluateSelector(selector, data, updatedAtoms);
-    if (selector.equal(existingValue, udpatedValue, updatedAtoms)) {
-      return [false, false];
+    const rawValue = evaluateSelector(selector, data, updatedAtoms, undefined, addedDeps, removedDeps);
+    const udpatedValue = handleSelectorResult(rawValue, selector, data);
+    const areEqual = isPromiseLike(existingValue) || isPromiseLike(udpatedValue) ? existingValue === udpatedValue : selector.equal(existingValue, udpatedValue, updatedAtoms);
+    if (areEqual) {
+      return [false, false, undefined, addedDeps, removedDeps];
     } else {
       setValueInData(selector, udpatedValue, data);
-      return [true, false];
+      return [true, false, undefined, addedDeps, removedDeps];
     }
   } catch (error) {
-    data.expiredValues.set(selector, data.values.get(selector));
     data.values.delete(selector);
-    return [true, true, error];
+    return [true, true, error, addedDeps, removedDeps];
   }
 };
+var callSubscribers = (subscriptions, families) => {
+  let firstError;
+  let hasError = false;
+  for (const subscription of subscriptions) {
+    if ("state" in subscription) {
+      const updatedFamilyAtoms = families?.get(subscription.state);
+      if (updatedFamilyAtoms) {
+        for (const atom of updatedFamilyAtoms) {
+          try {
+            subscription.callback(...atom.familyArgs);
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+      }
+    } else {
+      try {
+        subscription.callback();
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+      }
+    }
+  }
+  if (hasError)
+    throw firstError;
+};
 var addSetToSet = (fromSet, toSet) => {
   if (fromSet && fromSet.size > 0) {
     for (const item of fromSet) {
@@ -422,30 +701,7 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var findClosestStoreWithAtomInitialized2 = (atom, data) => {
-  if ("parent" in data === false)
-    return data;
-  if (data.values.has(atom))
-    return data;
-  return findClosestStoreWithAtomInitialized2(atom, data.parent);
-};
-var findInClosestStore = (state, data) => {
-  const store = findClosestStoreWithAtomInitialized2(state, data);
-  return store.values.get(state);
-};
-var addFamilyAtomsToSet = (family, familyAtoms, data) => {
-  const currentAtoms = findInClosestStore(family, data) || [];
-  const atomsToAdd = [];
-  for (const familyAtom of familyAtoms) {
-    if (!currentAtoms.includes(familyAtom)) {
-      atomsToAdd.push(familyAtom);
-    }
-  }
-  if (atomsToAdd.length > 0) {
-    data.values.set(family, [...currentAtoms, ...atomsToAdd]);
-  }
-};
-var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now()) => {
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
@@ -463,103 +719,398 @@ var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = ne
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
         throw new Error("Should not be possible");
-      addFamilyAtomsToSet(family, familyAtoms, data);
+      deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
+    }
+  }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
+  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) {
+      propagateUpdatedAtoms(familiesInScope, scope, undefined, undefined, false, timestamp, true);
+    }
+  }
+};
+var propagateUpdatedAtoms = (atoms, data, subscriptions, families, isRecursive = false, timestamp = performance.now(), selectorsOnly = false, isInitOnly = false) => {
+  if (atoms.length === 1 && !isRecursive && !selectorsOnly) {
+    const atom = atoms[0];
+    if (!isFamilyAtom(atom) && !isAtomFamily(atom)) {
+      const dependents = data.stateDependents.get(atom);
+      if ((!dependents || dependents.size === 0) && (!data.scopes || data.scopes.size === 0)) {
+        const subs = data.subscriptions.get(atom);
+        if (subs && subs.size > 0) {
+          callSubscribers(subs);
+        }
+        return;
+      }
+    }
+  }
+  if (!subscriptions)
+    subscriptions = new Set;
+  if (!families)
+    families = new Map;
+  const selectors = new Set;
+  for (const atom of atoms) {
+    addSetToSet(data.stateDependents.get(atom), selectors);
+    if (!selectorsOnly) {
+      addSetToSet(data.subscriptions.get(atom), subscriptions);
+      if (isFamilyAtom(atom)) {
+        if (!families.has(atom.family)) {
+          families.set(atom.family, new Set);
+        }
+        families.get(atom.family).add(atom);
+      }
+    }
+  }
+  if (families.size > 0) {
+    for (const [family, familyAtoms] of families) {
+      addSetToSet(data.stateDependents.get(family), selectors);
+      addSetToSet(data.subscriptions.get(family), subscriptions);
+      if (familyAtoms.size === 0)
+        throw new Error("Should not be possible");
+      addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
     }
   }
   if (!isRecursive) {
-    propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
+    propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly);
+    if (data.scopes && data.scopes.size > 0) {
+      if (atoms.length === 1) {
+        const atom = atoms[0];
+        const shadowingScopes = isAtomFamily(atom) ? undefined : data.scopeValueIndex.get(atom);
+        for (const [, scope] of data.scopes) {
+          if (!shadowingScopes || !shadowingScopes.has(scope)) {
+            propagateUpdatedAtoms(atoms, scope, undefined, undefined, false, timestamp, true, isInitOnly);
+          }
+        }
+      } else {
+        let anyShadowed = false;
+        let atomShadows;
+        for (const atom of atoms) {
+          if (!isAtomFamily(atom)) {
+            const s = data.scopeValueIndex.get(atom);
+            if (s && s.size > 0) {
+              if (!atomShadows)
+                atomShadows = new Map;
+              atomShadows.set(atom, s);
+              anyShadowed = true;
+            }
+          }
+        }
+        if (!anyShadowed) {
+          for (const [, scope] of data.scopes) {
+            propagateUpdatedAtoms(atoms, scope, undefined, undefined, false, timestamp, true, isInitOnly);
+          }
+        } else {
+          for (const [, scope] of data.scopes) {
+            const atomsToUpdateInScope = [];
+            for (const atom of atoms) {
+              if (isAtomFamily(atom)) {
+                atomsToUpdateInScope.push(atom);
+              } else {
+                const s = atomShadows.get(atom);
+                if (!s || !s.has(scope)) {
+                  atomsToUpdateInScope.push(atom);
+                }
+              }
+            }
+            if (atomsToUpdateInScope.length > 0) {
+              propagateUpdatedAtoms(atomsToUpdateInScope, scope, undefined, undefined, false, timestamp, true, isInitOnly);
+            }
+          }
+        }
+      }
+    }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families) => {
-  const initialUpdatedAtoms = new Set(updatedAtoms);
-  const updatedInitializedAtoms = new Set(initialUpdatedAtoms);
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false) => {
+  const updatedInitializedAtoms = new Set(updatedAtoms);
   if (selectors.size > 0) {
-    recursivlyHandleSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms);
-  }
-  const addedAtoms = initialUpdatedAtoms.symmetricDifference(updatedInitializedAtoms);
-  if (addedAtoms.size) {
-    console.log("addedAtoms", addedAtoms);
-    console.log("Valdres TODO: Support this case with new atoms added");
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly);
   }
   if (subscriptions.size > 0) {
-    for (const subscription of subscriptions) {
-      if ("state" in subscription) {
-        const updatedFamilyAtoms = families.get(subscription.state);
-        if (updatedFamilyAtoms) {
-          for (const atom of updatedFamilyAtoms) {
-            subscription.callback(...atom.familyArgs);
+    callSubscribers(subscriptions, families);
+  }
+};
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
+  let currentSelectors = selectors;
+  while (currentSelectors.size > 0) {
+    const selectorsForNextPass = new Set;
+    for (const selector of currentSelectors) {
+      const currentValue = data.values.get(selector);
+      if (isPromiseLike(currentValue) && isInitOnly) {
+        continue;
+      }
+      const dependents = data.stateDependents.get(selector);
+      const subscribers = data.subscriptions.get(selector);
+      if (!isPromiseLike(currentValue) && (!dependents || dependents.size === 0) && (!subscribers || subscribers.size === 0)) {
+        data.values.delete(selector);
+      } else {
+        const [wasValueUpdated, didEvalCrash, error, addedDeps, removedDeps] = reEvaluteSelector(selector, data, updatedInitializedAtoms);
+        if ((addedDeps.size > 0 || removedDeps.size > 0) && isTransitivelySubscribed(selector, data)) {
+          for (const dep of addedDeps) {
+            mountTransitiveDeps(dep, data);
+          }
+          for (const dep of removedDeps) {
+            unmountOrphanedDeps(dep, data);
           }
         }
-      } else {
-        subscription.callback();
+        if (!wasValueUpdated)
+          continue;
+        addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
+        addSetToSet(subscribers, collectedSubscribers);
       }
     }
+    currentSelectors = selectorsForNextPass;
   }
 };
-var recursivlyHandleSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, seen = new Set) => {
-  const selectorsForNextPass = new Set;
-  for (const selector of selectors) {
-    const currentValue = data.values.get(selector);
-    if (isPromiseLike(currentValue)) {
-      continue;
+
+// src/lib/isFunction.ts
+var isFunction = (value) => typeof value === "function";
+
+// src/lib/setAtom.ts
+var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
+  const emptyAtomPromise = currentValue?.__isEmptyAtomPromise__ ? currentValue : currentValue?.__emptyAtomPromiseOrigin__ ?? null;
+  if (emptyAtomPromise) {
+    promise.__emptyAtomPromiseOrigin__ = emptyAtomPromise;
+  }
+  setValueInData(atom, promise, data);
+  promise.then((resolvedValue) => {
+    if (data.values.get(atom) !== promise)
+      return;
+    setValueInData(atom, resolvedValue, data);
+    if (atom.onSet && !skipOnSet)
+      atom.onSet(resolvedValue, data);
+    if (emptyAtomPromise) {
+      emptyAtomPromise.__resolveEmptyAtomPromise__(resolvedValue);
     }
-    seen.add(selector);
-    const dependents = data.stateDependents.get(selector);
-    const subscribers = data.subscriptions.get(selector);
-    if ((!dependents || dependents.size === 0) && (!subscribers || subscribers.size === 0)) {
-      data.expiredValues.set(selector, data.values.get(selector));
-      data.values.delete(selector);
+    propagateUpdatedAtoms([atom], data);
+  }).catch(() => {
+    if (data.values.get(atom) !== promise)
+      return;
+    setValueInData(atom, currentValue, data);
+    propagateUpdatedAtoms([atom], data);
+  });
+};
+var setAtom = (atom, newValue, data, skipOnSet = false) => {
+  let initializedAtomsSet;
+  let currentValue;
+  if (data.values.has(atom)) {
+    currentValue = data.values.get(atom);
+  } else {
+    initializedAtomsSet = new Set;
+    currentValue = getState(atom, data, initializedAtomsSet);
+  }
+  if (isFunction(newValue)) {
+    newValue = newValue(currentValue);
+  }
+  if (isPromiseLike(newValue)) {
+    const promise = Promise.resolve(newValue);
+    if (currentValue === promise)
+      return promise;
+    handlePromise(atom, promise, currentValue, data, skipOnSet);
+    if (initializedAtomsSet && initializedAtomsSet.size > 0) {
+      initializedAtomsSet.add(atom);
+      propagateUpdatedAtoms([...initializedAtomsSet], data);
     } else {
-      const [wasValueUpdated, didEvalCrash, error] = reEvaluteSelector(selector, data, updatedInitializedAtoms);
-      if (!wasValueUpdated)
-        continue;
-      addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
-      addSetToSet(subscribers, collectedSubscribers);
+      propagateUpdatedAtoms([atom], data);
     }
+    return promise;
+  }
+  let syncValue = newValue;
+  const areEqual = isPromiseLike(currentValue) ? currentValue === syncValue : atom.equal(currentValue, syncValue);
+  if (areEqual)
+    return syncValue;
+  syncValue = setValueInData(atom, syncValue, data);
+  if (atom.onSet && !skipOnSet)
+    atom.onSet(syncValue, data);
+  if (currentValue?.__isEmptyAtomPromise__) {
+    currentValue.__resolveEmptyAtomPromise__(syncValue);
   }
-  if (selectorsForNextPass.size > 0) {
-    recursivlyHandleSelectorUpdates(selectorsForNextPass, data, collectedSubscribers, updatedInitializedAtoms, seen);
+  if (initializedAtomsSet && initializedAtomsSet.size > 0) {
+    initializedAtomsSet.add(atom);
+    propagateUpdatedAtoms([...initializedAtomsSet], data);
+  } else {
+    propagateUpdatedAtoms([atom], data);
   }
+  return syncValue;
+};
+
+// src/lib/initAtom.ts
+var getAtomInitValue = (atom, data, initializedAtomsSet) => {
+  if (atom.defaultValue === undefined) {
+    let promiseResolve;
+    const promise = new Promise((resolve) => {
+      promiseResolve = resolve;
+    });
+    promise.__isEmptyAtomPromise__ = true;
+    promise.__resolveEmptyAtomPromise__ = promiseResolve;
+    return promise;
+  } else if (typeof atom.defaultValue === "function") {
+    const value = atom.defaultValue();
+    if (isPromiseLike(value)) {
+      value.then((resolvedValue) => {
+        if (data.values.get(atom) !== value)
+          return;
+        setValueInData(atom, resolvedValue, data);
+        propagateUpdatedAtoms([atom], data);
+      }, () => {
+        if (data.values.get(atom) === value) {
+          data.values.delete(atom);
+        }
+      });
+    }
+    return value;
+  } else if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data, initializedAtomsSet);
+  } else {
+    return atom.defaultValue;
+  }
+};
+var initAtom = (atom, data, initializedAtomsSet) => {
+  const tmpVal = getAtomInitValue(atom, data, initializedAtomsSet);
+  let value = setValueInData(atom, tmpVal, data);
+  if (atom.onInit)
+    atom.onInit((newVal) => {
+      value = newVal;
+      setAtom(atom, newVal, data, true);
+    }, data);
+};
+
+// src/lib/getState.ts
+function getState(state, data, initializedAtomsSet, circularDependencySet) {
+  if (data.values.has(state))
+    return data.values.get(state);
+  if (isAtom(state)) {
+    if ("parent" in data)
+      return getState(state, data.parent, initializedAtomsSet, circularDependencySet);
+    if (isFamilyAtom(state)) {
+      const familyValue = data.values.get(state.family);
+      if (familyValue?.__index) {
+        if (isAtomDeletedInFamilyIndex(state, familyValue.__index)) {
+          return state.defaultValue;
+        }
+      }
+    }
+    initAtom(state, data, initializedAtomsSet);
+    initializedAtomsSet.add(state);
+    return data.values.get(state);
+  }
+  if (isSelector(state)) {
+    if (_evalDepth >= MAX_EVAL_DEPTH) {
+      throw new NeedsInitError(state);
+    }
+    initSelector(state, data, initializedAtomsSet, circularDependencySet);
+    return data.values.get(state);
+  }
+  if (isAtomFamily(state)) {
+    if ("parent" in data) {
+      const closestData = findClosestStoreWithAtomInitialized(state, data);
+      return getState(state, closestData, initializedAtomsSet, circularDependencySet);
+    }
+    data.values.set(state, renderAtomFamilyIndex(createAtomFamilyIndex()));
+    initializedAtomsSet.add(state);
+    return data.values.get(state);
+  }
+  if (isSelectorFamily(state)) {
+    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
+    if (equal(array, state._keyArray))
+      return state._keyArray;
+    state._keyArray = array;
+    return array;
+  }
+  throw new Error("Invalid object passed to get");
+}
+var findClosestStoreWithAtomInitialized = (atom, data) => {
+  if ("parent" in data === false)
+    return data;
+  if (data.values.has(atom))
+    return data;
+  return findClosestStoreWithAtomInitialized(atom, data.parent);
+};
+var isAtomDeletedInFamilyIndex = (atom, index) => {
+  if (index.deleted.has(atom))
+    return true;
+  if (index.created.has(atom))
+    return false;
+  if (index.parentIndex)
+    return isAtomDeletedInFamilyIndex(atom, index.parentIndex);
+  return false;
+};
+
+// src/utils/resolveReactive.ts
+var isReactive = (value) => typeof value === "object" && value !== null && (isAtom(value) || isSelector(value));
+var resolveReactive = (value, data) => {
+  if (typeof value === "object" && value !== null && (isAtom(value) || isSelector(value))) {
+    if (data.values.has(value))
+      return data.values.get(value);
+    return getState(value, data, new Set);
+  }
+  return value;
 };
 
 // src/lib/createStoreData.ts
-var generateId = () => (Math.random() + 1).toString(36).substring(7);
-var generateStoreData = (id = generateId()) => {
+var nextId = 0;
+var generateId = () => "__valdres_store_" + nextId++;
+function makeLazyGetter(key) {
   return {
-    id,
-    values: new WeakMap,
-    expiredValues: new WeakMap,
-    subscriptions: new WeakMap,
-    subscriptionsRequireEqualCheck: new WeakMap,
-    stateDependents: new WeakMap,
-    stateDependencies: new WeakMap,
-    scopes: {}
+    get() {
+      const map = new WeakMap;
+      Object.defineProperty(this, key, {
+        value: map,
+        writable: true,
+        configurable: true
+      });
+      return map;
+    },
+    configurable: true
   };
-};
-function createStoreData(id, parent) {
+}
+var lazyProto = Object.create(Object.prototype);
+Object.defineProperties(lazyProto, {
+  subscriptions: makeLazyGetter("subscriptions"),
+  subscriptionsRequireEqualCheck: makeLazyGetter("subscriptionsRequireEqualCheck"),
+  stateDependents: makeLazyGetter("stateDependents"),
+  stateDependencies: makeLazyGetter("stateDependencies"),
+  mounts: makeLazyGetter("mounts"),
+  abortControllers: makeLazyGetter("abortControllers"),
+  lastValueWriteAt: makeLazyGetter("lastValueWriteAt")
+});
+function createStoreData(id, parent, options) {
+  const data = Object.create(lazyProto);
+  data.id = id ?? generateId();
+  data.values = new WeakMap;
+  data.scopes = new Map;
+  data.scopeValueIndex = new WeakMap;
+  if (options?.batchUpdates) {
+    data.batchUpdates = true;
+  }
   if (parent) {
-    return {
-      ...generateStoreData(id),
-      parent,
-      scopeConsumers: parent ? new Set : undefined
-    };
-  } else {
-    return generateStoreData(id);
+    data.parent = parent;
+    data.scopeConsumers = new Set;
+    data.scopeIndexKeys = new Set;
   }
+  return data;
 }
 
 // src/lib/deleteFamilyAtom.ts
 var deleteFamilyAtom = (atom, data) => {
-  const array = data.values.get(atom.family);
-  const index = array.indexOf(atom);
-  const newArray = [
-    ...array.slice(0, index),
-    ...array.slice(index + 1)
-  ];
   data.values.delete(atom);
-  propagateUpdatedAtoms([atom], data);
-  setValueInData(atom.family, newArray, data);
-  propagateUpdatedAtoms([atom.family], data);
+  if (atom.family) {
+    atom.family.release(...atom.familyArgs);
+  }
+  propagateDeletedAtoms([atom], data);
 };
 
 // src/lib/resetAtom.ts
@@ -579,8 +1130,25 @@ var resetAtom = (atom, data) => {
 // src/utils/isFamily.ts
 var isFamily = (state) => isAtomFamily(state) || isSelectorFamily(state);
 
+// src/lib/maxAgeCleanups.ts
+var maxAgeCleanups = new WeakMap;
+var setMaxAgeCleanup = (data, state, cleanup) => {
+  let storeMap = maxAgeCleanups.get(data);
+  if (!storeMap) {
+    storeMap = new WeakMap;
+    maxAgeCleanups.set(data, storeMap);
+  }
+  storeMap.set(state, cleanup);
+};
+var getMaxAgeCleanup = (data, state) => {
+  return maxAgeCleanups.get(data)?.get(state);
+};
+var deleteMaxAgeCleanup = (data, state) => {
+  maxAgeCleanups.get(data)?.delete(state);
+};
+
 // src/lib/unsubscribe.ts
-var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
+var unsubscribe = (state, subscription, data) => {
   const subscribers = data.subscriptions.get(state);
   if (subscribers) {
     subscribers.delete(subscription);
@@ -597,17 +1165,40 @@ var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
       }
     }
     if (subscribers.size === 0) {
-      if (maxAgeCleanup)
+      const maxAgeCleanup = getMaxAgeCleanup(data, state);
+      if (maxAgeCleanup) {
         maxAgeCleanup();
+        deleteMaxAgeCleanup(data, state);
+      }
       data.subscriptions.delete(state);
+      unmountOrphanedDeps(state, data);
+      cleanupOrphanedDeps(state, data);
     }
-    if (mount) {
-      if (subscribers.size === mount.mountSubscriptions.size) {
-        if (typeof mount.onUnmount === "function") {
-          mount.onUnmount();
-        }
+  }
+};
+var cleanupOrphanedDeps = (state, data, visited = new Set) => {
+  if (visited.has(state))
+    return;
+  visited.add(state);
+  if (isTransitivelySubscribed(state, data))
+    return;
+  const deps = data.stateDependencies.get(state);
+  if (deps) {
+    for (const dep of deps) {
+      const depDependents = data.stateDependents.get(dep);
+      if (depDependents) {
+        depDependents.delete(state);
       }
     }
+    data.stateDependencies.delete(state);
+    data.values.delete(state);
+    data.abortControllers.delete(state);
+  }
+  const dependents = data.stateDependents.get(state);
+  if (dependents) {
+    for (const dep of [...dependents]) {
+      cleanupOrphanedDeps(dep, data, visited);
+    }
   }
 };
 
@@ -617,6 +1208,203 @@ var initSubscribers = (state, data) => {
   data.subscriptions.set(state, set);
   return set;
 };
+var installMaxAgeTimer = (state, data) => {
+  if (!state.maxAge)
+    return;
+  const globalState = isGlobalAtom(state) ? state : undefined;
+  const existing = globalState?.maxAgeInterval;
+  if (existing) {
+    existing.refCount++;
+    const metaAtom2 = state.__cacheMeta ??= { equal, defaultValue: null };
+    for (const s of globalState.stores) {
+      if (s !== data && s.values.has(metaAtom2)) {
+        setValueInData(metaAtom2, s.values.get(metaAtom2), data);
+        propagateUpdatedAtoms([metaAtom2], data);
+        break;
+      }
+    }
+    setMaxAgeCleanup(data, state, () => {
+      if (existing.refCount <= 0)
+        return;
+      existing.refCount--;
+      if (existing.refCount === 0) {
+        existing.cleanup();
+        if (globalState.maxAgeInterval === existing) {
+          globalState.maxAgeInterval = undefined;
+        }
+      }
+    });
+    return;
+  }
+  const pendingTimeouts = new Set;
+  let revalidating = false;
+  let cancelled = false;
+  let lastSuccessTime = Date.now();
+  const NO_VALUE = Symbol();
+  let lastGoodValue = NO_VALUE;
+  let currentInterval;
+  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 updateMeta = () => {
+    const meta = {
+      isRevalidating: revalidating,
+      lastSuccessAt: lastSuccessTime,
+      maxAge: getMaxAge(),
+      staleWhileRevalidate: getSWR(),
+      staleIfError: getStaleIfError()
+    };
+    if (globalState) {
+      for (const store of globalState.stores) {
+        setValueInData(metaAtom, meta, store);
+        propagateUpdatedAtoms([metaAtom], store);
+      }
+    } else {
+      setValueInData(metaAtom, meta, data);
+      propagateUpdatedAtoms([metaAtom], data);
+    }
+  };
+  const isPastStaleIfErrorWindow = () => {
+    const elapsed = Date.now() - lastSuccessTime;
+    return elapsed >= getMaxAge() + getStaleIfError();
+  };
+  const setAndPropagate = (atom, val) => {
+    if (globalState) {
+      for (const store of globalState.stores) {
+        setValueInData(atom, val, store);
+        propagateUpdatedAtoms([atom], store);
+      }
+    } else {
+      setValueInData(atom, val, data);
+      propagateUpdatedAtoms([atom], data);
+    }
+  };
+  const getValueStore = () => {
+    if (globalState) {
+      for (const s of globalState.stores)
+        return s;
+    }
+    return data;
+  };
+  const tick = () => {
+    if (revalidating)
+      return;
+    if (typeof state.defaultValue !== "function")
+      return;
+    const valueStore = getValueStore();
+    if (valueStore.values.has(state)) {
+      const currentValue = valueStore.values.get(state);
+      if (!isPromiseLike(currentValue)) {
+        lastGoodValue = currentValue;
+      }
+    }
+    const value = state.defaultValue();
+    if (isPromiseLike(value)) {
+      revalidating = true;
+      updateMeta();
+      const swr = getSWR();
+      const handleResolve = (resolved) => {
+        if (cancelled)
+          return;
+        revalidating = false;
+        lastSuccessTime = Date.now();
+        lastGoodValue = resolved;
+        setAndPropagate(state, resolved);
+        updateMeta();
+      };
+      const handleReject = () => {
+        if (cancelled)
+          return;
+        revalidating = false;
+        if (!isPastStaleIfErrorWindow() && lastGoodValue !== NO_VALUE) {
+          setAndPropagate(state, lastGoodValue);
+        } else {
+          setAndPropagate(state, value);
+        }
+        updateMeta();
+      };
+      if (swr > 0) {
+        let timeoutRef;
+        if (Number.isFinite(swr)) {
+          timeoutRef = setTimeout(() => {
+            pendingTimeouts.delete(timeoutRef);
+            if (cancelled || !revalidating)
+              return;
+            setAndPropagate(state, value);
+          }, swr);
+          pendingTimeouts.add(timeoutRef);
+        }
+        value.then((resolved) => {
+          if (timeoutRef !== undefined) {
+            clearTimeout(timeoutRef);
+            pendingTimeouts.delete(timeoutRef);
+          }
+          handleResolve(resolved);
+        }, () => {
+          if (timeoutRef !== undefined) {
+            clearTimeout(timeoutRef);
+            pendingTimeouts.delete(timeoutRef);
+          }
+          handleReject();
+        });
+      } else {
+        setAndPropagate(state, value);
+        value.then(handleResolve, handleReject);
+      }
+    } else {
+      lastSuccessTime = Date.now();
+      lastGoodValue = value;
+      setAndPropagate(state, value);
+      updateMeta();
+    }
+  };
+  const startInterval = () => {
+    currentInterval = setInterval(tick, getMaxAge());
+  };
+  startInterval();
+  updateMeta();
+  const configUnsubs = [];
+  if (isReactive(state.maxAge)) {
+    configUnsubs.push(subscribe(state.maxAge, () => {
+      clearInterval(currentInterval);
+      startInterval();
+      updateMeta();
+    }, false, data));
+  }
+  if (state.staleWhileRevalidate && isReactive(state.staleWhileRevalidate)) {
+    configUnsubs.push(subscribe(state.staleWhileRevalidate, () => updateMeta(), false, data));
+  }
+  if (state.staleIfError && isReactive(state.staleIfError)) {
+    configUnsubs.push(subscribe(state.staleIfError, () => updateMeta(), false, data));
+  }
+  const cleanup = () => {
+    cancelled = true;
+    clearInterval(currentInterval);
+    for (const t of pendingTimeouts)
+      clearTimeout(t);
+    pendingTimeouts.clear();
+    for (const unsub of configUnsubs)
+      unsub();
+  };
+  if (globalState) {
+    const entry = { cleanup, refCount: 1 };
+    globalState.maxAgeInterval = entry;
+    setMaxAgeCleanup(data, state, () => {
+      if (entry.refCount <= 0)
+        return;
+      entry.refCount--;
+      if (entry.refCount === 0) {
+        entry.cleanup();
+        if (globalState.maxAgeInterval === entry) {
+          globalState.maxAgeInterval = undefined;
+        }
+      }
+    });
+  } else {
+    setMaxAgeCleanup(data, state, cleanup);
+  }
+};
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
   let parentUnsubscribe;
   if ("parent" in data && (!data.values.has(state) && isAtom(state) || isAtomFamily(state))) {
@@ -657,45 +1445,12 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
     };
   }
   subscribers.add(subscription);
-  let mount;
-  let maxAgeCleanup;
   if (subscribers.size === 1) {
     if (isAtom(state) && state.maxAge) {
-      let timeout;
-      const interval = setInterval(() => {
-        let value = getAtomInitValue(state, data);
-        if (isPromiseLike(value)) {
-          if (state.staleWhileRevalidate) {
-            const oldValue = data.values.get(state);
-            timeout = setTimeout(() => {
-              const nowValue = data.values.get(state);
-              console.log("todo", oldValue);
-            }, state.staleWhileRevalidate);
-            value.then((res) => clearTimeout(timeout));
-          }
-        } else {
-          setValueInData(state, value, data);
-          propagateUpdatedAtoms([state], data);
-        }
-      }, state.maxAge);
-      maxAgeCleanup = () => {
-        clearInterval(interval);
-        if (timeout)
-          clearTimeout(timeout);
-      };
+      installMaxAgeTimer(state, data);
     }
-    if (state.onMount) {
-      const store = storeFromStoreData(data);
-      const mountSubscriptions = new Set;
-      const originalSub = store.sub;
-      store.sub = (state2, callback2) => {
-        mountSubscriptions.add(callback2);
-        return originalSub(state2, callback2);
-      };
-      mount = {
-        onUnmount: state.onMount(store, state),
-        mountSubscriptions
-      };
+    if (!isFamily(state)) {
+      mountTransitiveDeps(state, data);
     }
   }
   if (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state) !== true) {
@@ -705,7 +1460,7 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
     if (parentUnsubscribe) {
       parentUnsubscribe();
     }
-    unsubscribe(state, subscription, data, mount, maxAgeCleanup);
+    unsubscribe(state, subscription, data);
   };
 };
 
@@ -714,188 +1469,264 @@ var setAtoms = (pairs, data, initializedAtomsSet) => {
   const updatedAtoms = [];
   for (let [atom, value] of pairs) {
     const currentValue = getState(atom, data, initializedAtomsSet);
-    if (!atom.equal(currentValue, value)) {
+    const areEqual = isPromiseLike(currentValue) || isPromiseLike(value) ? currentValue === value : atom.equal(currentValue, value);
+    if (!areEqual) {
       updatedAtoms.push(atom);
       value = setValueInData(atom, value, data);
       if (atom.onSet)
         atom.onSet(value, data);
+    } else {
+      setValueInData(atom, value, data);
     }
   }
-  const result = new Set([...updatedAtoms, ...initializedAtomsSet]);
-  if (result.size > 0) {
-    propagateUpdatedAtoms([...result], data);
-  }
-};
-
-// src/lib/transaction.ts
-var findDependencies = (state, data, result = new Set) => {
-  const dependents = data.stateDependents.get(state);
-  if (dependents?.size) {
-    for (const dependent of dependents) {
-      if (!result.has(dependent)) {
-        result.add(dependent);
-        findDependencies(dependent, data, result);
-      }
+  if (initializedAtomsSet.size > 0) {
+    for (const atom of initializedAtomsSet) {
+      updatedAtoms.push(atom);
     }
   }
-  return result;
-};
-var recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache) => {
-  for (const dep of txnSubscribers.get(state)) {
-    txnSelectorCache.delete(dep);
-    if (txnSubscribers.get(dep)?.size) {
-      recursivlyResetTxnSelectorCache(dep, txnSubscribers, txnSelectorCache);
-    }
+  if (updatedAtoms.length > 0) {
+    propagateUpdatedAtoms(updatedAtoms, data);
   }
 };
-var captureScopedTransaction = (scopedData, parentGetInTxnOrData) => {
-  let txn;
-  transaction((scopedTxn) => {
-    txn = scopedTxn;
-  }, scopedData, false, parentGetInTxnOrData);
-  return txn;
-};
+
+// src/lib/transaction.ts
 var deleteAtomFamilyAtoms = (set, data) => {
   set.forEach((atom) => {
     data.values.delete(atom);
   });
 };
-var transaction = (callback, data, autoCommit = true, parentGetInTxnOrData) => {
-  const txnAtomMap = new Map;
-  const txnAtomDeleteSet = new Set;
-  const txnSelectorCache = new Map;
-  const txnSubscribers = new Map;
-  const dirtySelectors = new Set;
-  let scopedTransactions;
-  const getInTxnOrData = (state) => {
-    if (txnAtomMap.has(state)) {
-      return txnAtomMap.get(state);
+
+class Transaction {
+  data;
+  parentTransaction;
+  dirty;
+  _scopedTransactions;
+  _initializedAtomsSet;
+  _deleteSet;
+  _selectorDependencies;
+  _selectorCache;
+  _atomMap;
+  constructor(data, parentTransaction, childTransaction) {
+    this.data = data;
+    this.parentTransaction = parentTransaction;
+    this.dirty = false;
+    this._atomMap = new Map;
+    if (childTransaction) {
+      this._scopedTransactions = new Map([
+        [childTransaction.data.id, childTransaction]
+      ]);
     }
-    if (data.values.has(state)) {
-      return data.values.get(state);
+  }
+  hasTxnOrData = (state) => {
+    if (this._atomMap.has(state))
+      return true;
+    if (this.data.values.has(state))
+      return true;
+    if (this.parentTransaction)
+      return this.parentTransaction.hasTxnOrData(state);
+    return false;
+  };
+  valueFromTxnOrData = (state) => {
+    if (this._atomMap.has(state)) {
+      return this._atomMap.get(state);
+    }
+    if (this.data.values.has(state)) {
+      return this.data.values.get(state);
     }
-    if (parentGetInTxnOrData) {
-      return parentGetInTxnOrData(state);
+    if (this.parentTransaction) {
+      return this.parentTransaction.valueFromTxnOrData(state);
     }
   };
-  const initializedAtomsSet = new Set;
-  const txnGet = (state) => {
-    if (isAtom(state)) {
-      const value = getInTxnOrData(state);
-      if (value)
-        return value;
-      return getState(state, data, initializedAtomsSet);
+  get = (state) => {
+    if (isAtom(state) || isAtomFamily(state)) {
+      if (this.hasTxnOrData(state)) {
+        return this.valueFromTxnOrData(state);
+      }
+      return getState(state, this.data, this.initializedAtomsSet);
     } else if (isSelector(state)) {
-      if (txnSelectorCache.has(state)) {
-        return txnSelectorCache.get(state);
+      if (this.dirty) {
+        this.selectorCache.clear();
+        this.selectorDependencies.clear();
+        this.dirty = false;
+      } else if (this.selectorCache.has(state)) {
+        return this.selectorCache.get(state);
       }
-      const deps = new Set;
       const res = state.get((s) => {
-        deps.add(s);
-        return txnGet(s);
-      }, data.id);
-      for (const dep of deps) {
-        if (!txnSubscribers.has(dep)) {
-          txnSubscribers.set(dep, new Set);
+        if (!this.selectorDependencies.has(s)) {
+          this.selectorDependencies.add(s);
         }
-        txnSubscribers.get(dep).add(state);
-      }
-      txnSelectorCache.set(state, res);
+        return this.get(s);
+      }, this.data.id);
+      this.selectorCache.set(state, res);
       return res;
-    } else if (isAtomFamily(state)) {
-      const value = getInTxnOrData(state);
-      if (value)
-        return value;
-      return getState(state, data, initializedAtomsSet);
     } else {
       throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom, value) => {
+  set = (atom, value) => {
     if (!isAtom(atom))
       throw new Error("Not an atom");
     if (isFunction(value)) {
-      const currentValue = txnGet(atom);
+      const currentValue = this.get(atom);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom, data)) {
-      dirtySelectors.add(selector);
-      txnSelectorCache.delete(selector);
-    }
-    if (txnSubscribers.get(atom)?.size) {
-      recursivlyResetTxnSelectorCache(atom, txnSubscribers, txnSelectorCache);
-    }
-    if (isProd()) {
-      txnAtomMap.set(atom, value);
-    } else {
-      txnAtomMap.set(atom, deepFreeze(value));
+    if (!atom.mutable && !isProd() && value !== null && (typeof value === "object" || typeof value === "function")) {
+      value = deepFreeze(value);
     }
+    this._atomMap.set(atom, value);
+    if (!this.dirty)
+      this.dirty = true;
     if (isFamilyAtom(atom)) {
-      const currentFamilyList = txnGet(atom.family);
-      if (!currentFamilyList.includes(atom)) {
-        const newArr = [...currentFamilyList, atom];
-        txnAtomMap.set(atom.family, newArr);
+      if (!this._atomMap.has(atom.family)) {
+        this.cloneFamilyIntoTxn(atom.family);
       }
+      const index = this._atomMap.get(atom.family).__index;
+      index.created.set(atom, performance.now());
+      index.deleted.delete(atom);
+      index.rendered = null;
+      index.renderedArray = null;
+      this.recursivelyUpdateAtomFamilyIndexes(atom.family);
     }
     return value;
   };
-  const txnReset = (atom) => {
-    const value = getAtomInitValue(atom, data, initializedAtomsSet);
-    txnAtomMap.set(atom, value);
+  batchSetFamilyAtoms = (family, pairs) => {
+    if (!this._atomMap.has(family)) {
+      this.cloneFamilyIntoTxn(family);
+    }
+    const index = this._atomMap.get(family).__index;
+    for (const [atom, value] of pairs) {
+      if (atom.family !== family) {
+        throw new Error("Atom does not belong to the provided family");
+      }
+      index.created.set(atom, performance.now());
+      if (index.deleted.has(atom))
+        index.deleted.delete(atom);
+      this._atomMap.set(atom, value);
+    }
+    index.rendered = null;
+    index.renderedArray = null;
+    this.recursivelyUpdateAtomFamilyIndexes(family);
+  };
+  del = (atom) => {
+    if (!this._atomMap.has(atom.family)) {
+      this.cloneFamilyIntoTxn(atom.family);
+    }
+    const index = this._atomMap.get(atom.family).__index;
+    index.created.delete(atom);
+    index.deleted.set(atom, performance.now());
+    index.rendered = null;
+    index.renderedArray = null;
+    this._atomMap.set(atom.family, renderAtomFamilyIndex(index));
+    this.recursivelyUpdateAtomFamilyIndexes(atom.family);
+    if (this.data.values.has(atom)) {
+      this.deleteSet.add(atom);
+    }
+    if (this._atomMap.has(atom)) {
+      this._atomMap.delete(atom);
+    }
+  };
+  scope = (scopeId, callback) => {
+    if (this.data.scopes.has(scopeId)) {
+      return this.scopedTransaction(scopeId).execute(callback, false);
+    } else {
+      throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${[...this.data.scopes.keys()].join(", ")}`);
+    }
+  };
+  parentScope = (callback) => {
+    if (!this.parentTransaction) {
+      this.parentTransaction = new Transaction(this.data.parent, undefined, this);
+    }
+    return this.parentTransaction.execute(callback, false);
+  };
+  reset = (atom) => {
+    const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
+    this._atomMap.set(atom, value);
     return value;
   };
-  const txnDel = (atom) => {
-    const array = txnGet(atom.family);
-    const index = array.indexOf(atom);
-    const newArr = [
-      ...array.slice(0, index),
-      ...array.slice(index + 1)
-    ];
-    txnAtomMap.set(atom.family, newArr);
-    if (data.values.has(atom)) {
-      txnAtomDeleteSet.add(atom);
-    }
-    if (txnAtomMap.has(atom)) {
-      txnAtomMap.delete(atom);
+  execute = (callback, autoCommit = true) => {
+    const result = callback(this);
+    if (autoCommit)
+      this.txnCommit();
+    return result;
+  };
+  txnCommit = () => {
+    if (this.parentTransaction) {
+      this.parentTransaction.txnCommit();
+    } else {
+      this.commit();
     }
   };
-  const commit = () => {
-    setAtoms(txnAtomMap, data, initializedAtomsSet);
-    if (txnAtomDeleteSet.size) {
-      deleteAtomFamilyAtoms(txnAtomDeleteSet, data);
-    }
-    dirtySelectors.clear();
-    if (scopedTransactions) {
-      for (const scopedTxn of Object.values(scopedTransactions)) {
+  commit = () => {
+    const initializedAtomsSet = new Set;
+    setAtoms(this._atomMap, this.data, initializedAtomsSet);
+    if (this.deleteSet?.size) {
+      deleteAtomFamilyAtoms(this.deleteSet, this.data);
+      propagateDeletedAtoms([...this.deleteSet], this.data);
+    }
+    if (this._scopedTransactions) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
         scopedTxn.commit();
       }
     }
   };
-  const result = callback({
-    set: txnSet,
-    get: txnGet,
-    del: txnDel,
-    reset: txnReset,
-    commit,
-    scope: (scopeId, callback2) => {
-      if (scopeId in data.scopes) {
-        const scopedData = data.scopes[scopeId];
-        if (scopedTransactions === undefined) {
-          scopedTransactions = {};
-        }
-        if (scopedTransactions[scopeId] === undefined) {
-          scopedTransactions[scopeId] = captureScopedTransaction(scopedData, getInTxnOrData);
-        }
-        return callback2(scopedTransactions[scopeId]);
-      } else {
-        throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(data.scopes).join(", ")}`);
+  get selectorCache() {
+    if (!this._selectorCache)
+      this._selectorCache = new Map;
+    return this._selectorCache;
+  }
+  get selectorDependencies() {
+    if (!this._selectorDependencies)
+      this._selectorDependencies = new Set;
+    return this._selectorDependencies;
+  }
+  get deleteSet() {
+    if (!this._deleteSet)
+      this._deleteSet = new Set;
+    return this._deleteSet;
+  }
+  get initializedAtomsSet() {
+    if (!this._initializedAtomsSet)
+      this._initializedAtomsSet = new Set;
+    return this._initializedAtomsSet;
+  }
+  scopedTransaction(scopeId) {
+    if (!this._scopedTransactions)
+      this._scopedTransactions = new Map;
+    if (!this._scopedTransactions.has(scopeId)) {
+      const scopedData = this.data.scopes.get(scopeId);
+      const scopedTransaction = new Transaction(scopedData, this);
+      this._scopedTransactions.set(scopeId, scopedTransaction);
+    }
+    return this._scopedTransactions.get(scopeId);
+  }
+  cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent = true) {
+    if (moveUpIfParent && this.parentTransaction)
+      return this.parentTransaction.cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent);
+    const currentFamilyList = this.get(family);
+    const clonedIndex = cloneAtomFamilyIndex(currentFamilyList.__index, parentIndex);
+    if (this._scopedTransactions?.size) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
+        scopedTxn.cloneFamilyIntoTxn(family, clonedIndex, false);
       }
-    },
-    data
-  });
-  if (autoCommit)
-    commit();
-  return result;
+    }
+    this._atomMap.set(family, renderAtomFamilyIndex(clonedIndex));
+  }
+  recursivelyUpdateAtomFamilyIndexes(atomFamily) {
+    const currentIndex = this._atomMap.get(atomFamily).__index;
+    currentIndex.rendered = null;
+    currentIndex.renderedArray = null;
+    const updatedValue = renderAtomFamilyIndex(currentIndex);
+    this._atomMap.set(atomFamily, updatedValue);
+    if (this._scopedTransactions?.size) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
+        scopedTxn.recursivelyUpdateAtomFamilyIndexes(atomFamily);
+      }
+    }
+  }
+}
+var transaction = (callback, data) => {
+  const txn = new Transaction(data);
+  return txn.execute(callback);
 };
 
 // src/lib/storeFromStoreData.ts
@@ -906,43 +1737,150 @@ Only \`atom\` cam be set.
 var InvalidStateSetError = `Invalid state object passed to set().
 Only \`atom\` can be set.
 `;
+var isCachedValueStale = (state, data) => {
+  const atom = state;
+  const maxAge = atom.maxAge;
+  if (maxAge === undefined)
+    return false;
+  if (isGlobalAtom(atom)) {
+    if (atom.maxAgeInterval !== undefined)
+      return false;
+  } else {
+    const subs = data.subscriptions.get(state);
+    if (subs && subs.size > 0)
+      return false;
+  }
+  const lastWrite = data.lastValueWriteAt.get(state);
+  if (lastWrite === undefined)
+    return false;
+  const ttl = typeof maxAge === "number" ? maxAge : resolveReactive(maxAge, data);
+  return Date.now() - lastWrite > ttl;
+};
 function storeFromStoreData(data, detach) {
-  const get = (state) => {
-    const set2 = new Set;
-    const res = getState(state, data, set2);
-    if (set2.size) {
-      propagateUpdatedAtoms([...set2], data);
+  const _initSet = new Set;
+  let _pendingTxn = null;
+  const flushPendingTxn = () => {
+    if (_pendingTxn) {
+      const txnToCommit = _pendingTxn;
+      _pendingTxn = null;
+      txnToCommit.commit();
+    }
+  };
+  const ensurePendingTxn = () => {
+    if (!_pendingTxn) {
+      _pendingTxn = new Transaction(data);
+      queueMicrotask(() => {
+        try {
+          flushPendingTxn();
+        } catch (error) {
+          setTimeout(() => {
+            throw error;
+          }, 0);
+        }
+      });
+    }
+    return _pendingTxn;
+  };
+  const getDefault = (state) => {
+    if (data.values.has(state)) {
+      if (!isCachedValueStale(state, data)) {
+        return data.values.get(state);
+      }
+      data.values.delete(state);
+      data.lastValueWriteAt.delete(state);
+    }
+    let res;
+    try {
+      res = getState(state, data, _initSet);
+    } finally {
+      if (_initSet.size) {
+        const atoms = [..._initSet];
+        _initSet.clear();
+        propagateUpdatedAtoms(atoms, data, undefined, undefined, false, undefined, false, true);
+      }
     }
     return res;
   };
-  const set = (state, value) => {
+  const getBatched = (state) => {
+    if (_pendingTxn) {
+      return _pendingTxn.get(state);
+    }
+    return getDefault(state);
+  };
+  const get = data.batchUpdates ? getBatched : getDefault;
+  const setDefault = (state, value) => {
     if (isAtom(state))
       return setAtom(state, value, data);
     if (isSelector(state))
       throw new Error(SelectorProvidedToSetError);
     throw new Error(InvalidStateSetError);
   };
-  const reset = (atom) => resetAtom(atom, data);
-  const del = (atom) => deleteFamilyAtom(atom, data);
+  const setBatched = (state, value) => {
+    if (isAtom(state)) {
+      return ensurePendingTxn().set(state, value);
+    }
+    if (isSelector(state))
+      throw new Error(SelectorProvidedToSetError);
+    throw new Error(InvalidStateSetError);
+  };
+  const set = data.batchUpdates ? setBatched : setDefault;
+  const reset = (atom) => {
+    if (data.batchUpdates)
+      flushPendingTxn();
+    return resetAtom(atom, data);
+  };
+  const del = (atom) => {
+    if (data.batchUpdates)
+      flushPendingTxn();
+    return deleteFamilyAtom(atom, data);
+  };
   const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
-  const txn = (callback) => transaction(callback, data);
-  const scope = (scopeId) => {
-    let scopedStoreData;
-    if (scopeId in data.scopes) {
-      scopedStoreData = data.scopes[scopeId];
+  const txn = (callback) => {
+    if (data.batchUpdates)
+      flushPendingTxn();
+    return transaction(callback, data);
+  };
+  const scope = (scopeId, callback) => {
+    if (callback) {
+      if (!data.scopes.has(scopeId)) {
+        throw new Error(`Scope ${scopeId} does not exist`);
+      }
+      const scopedStoreData = data.scopes.get(scopeId);
+      const scopedStore = storeFromStoreData(scopedStoreData);
+      const res = callback(scopedStore);
+      return res;
     } else {
-      scopedStoreData = createStoreData(scopeId, data);
-      data.scopes[scopeId] = scopedStoreData;
-    }
-    const detach2 = () => {
-      scopedStoreData.scopeConsumers.delete(detach2);
-      if (scopedStoreData.scopeConsumers.size === 0) {
-        delete data.scopes[scopeId];
+      let scopedStoreData;
+      if (data.scopes.has(scopeId)) {
+        scopedStoreData = data.scopes.get(scopeId);
+      } else {
+        scopedStoreData = createStoreData(scopeId, data, data.batchUpdates ? { batchUpdates: true } : undefined);
+        data.scopes.set(scopeId, scopedStoreData);
       }
-    };
-    scopedStoreData.scopeConsumers.add(detach2);
-    const newStore = storeFromStoreData(data.scopes[scopeId], detach2);
-    return newStore;
+      const detach2 = (expectedToDestroy = false) => {
+        scopedStoreData.scopeConsumers.delete(detach2);
+        if (scopedStoreData.scopeConsumers.size === 0) {
+          data.scopes.delete(scopeId);
+          for (const key of scopedStoreData.scopeIndexKeys) {
+            const set2 = data.scopeValueIndex.get(key);
+            if (set2) {
+              set2.delete(scopedStoreData);
+              if (set2.size === 0)
+                data.scopeValueIndex.delete(key);
+            }
+          }
+          scopedStoreData.scopeIndexKeys.clear();
+          return true;
+        }
+        if (expectedToDestroy) {
+          console.warn(`Scope ${scopeId} still has ${scopedStoreData.scopeConsumers.size} consumers, will not detach`);
+        }
+        return false;
+      };
+      scopedStoreData.scopeConsumers.add(detach2);
+      const newStore = storeFromStoreData(data.scopes.get(scopeId), detach2);
+      return newStore;
+    }
   };
   if (detach) {
     return {
@@ -970,9 +1908,114 @@ function storeFromStoreData(data, detach) {
   }
 }
 
+// src/lib/mountAtom.ts
+var isTransitivelySubscribed = (state, data, visited = new Set) => {
+  const stack = [state];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const subs = data.subscriptions.get(current);
+    if (subs && subs.size > 0)
+      return true;
+    const dependents = data.stateDependents.get(current);
+    if (dependents) {
+      for (const dep of dependents) {
+        if (!visited.has(dep))
+          stack.push(dep);
+      }
+    }
+  }
+  return false;
+};
+var mountAtom = (state, data) => {
+  const onMountFn = state.__valdresOnMount ?? state.onMount;
+  if (!onMountFn || data.mounts.has(state))
+    return;
+  const mountEntry = {};
+  data.mounts.set(state, mountEntry);
+  const store = data.storeRef ?? storeFromStoreData(data);
+  try {
+    mountEntry.cleanup = onMountFn(store, state);
+  } catch (error) {
+    data.mounts.delete(state);
+    throw error;
+  }
+};
+var unmountAtom = (state, data) => {
+  const mount = data.mounts.get(state);
+  if (!mount)
+    return;
+  data.mounts.delete(state);
+  if (typeof mount.cleanup === "function") {
+    mount.cleanup();
+  }
+};
+var mountTransitiveDeps = (state, data, visited = new Set) => {
+  let firstError = null;
+  const stack = [state];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    if (current.__valdresOnMount || current.onMount) {
+      try {
+        mountAtom(current, data);
+      } catch (error) {
+        if (!firstError)
+          firstError = { value: error };
+      }
+    }
+    const deps = data.stateDependencies.get(current);
+    if (deps) {
+      for (const dep of deps) {
+        if (!visited.has(dep))
+          stack.push(dep);
+      }
+    }
+  }
+  if (firstError) {
+    throw firstError.value;
+  }
+};
+var unmountOrphanedDeps = (state, data, visited = new Set) => {
+  let firstError = null;
+  const stack = [state];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    if ((current.__valdresOnMount || current.onMount) && data.mounts.has(current)) {
+      if (!isTransitivelySubscribed(current, data)) {
+        try {
+          unmountAtom(current, data);
+        } catch (error) {
+          if (!firstError)
+            firstError = { value: error };
+        }
+      }
+    }
+    const deps = data.stateDependencies.get(current);
+    if (deps) {
+      for (const dep of deps) {
+        if (!visited.has(dep))
+          stack.push(dep);
+      }
+    }
+  }
+  if (firstError) {
+    throw firstError.value;
+  }
+};
+
 // src/store.ts
-var store = (id) => {
-  const data = createStoreData(id);
+var store = (idOrOptions) => {
+  const id = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
+  const options = typeof idOrOptions === "object" ? idOrOptions : undefined;
+  const data = createStoreData(id, undefined, options);
   return storeFromStoreData(data);
 };
 
@@ -985,61 +2028,114 @@ var globalStore = Object.assign(store("valdres-global-store"), {
 // src/lib/globalAtom.ts
 var globalAtom = (defaultValue, options) => {
   const stores = new Set;
-  let value;
-  let initialized = false;
-  let onReset;
   if (options.onSet)
     throw new Error("onSet on globalAtom is currently not supported");
   const onInit = (setSelf2, data) => {
     setSelf2(globalStore.get(atom));
-    if (!initialized && options.onInit) {
-      onReset = options.onInit((newVal) => {
-        setSelf2(newVal);
-        value = newVal;
-      }, data);
-      initialized = true;
-    }
     stores.add(data);
   };
   const onSet = (newValue, currentStore) => {
-    value = newValue;
     if (stores.size > 1) {
       for (const store2 of stores) {
         if (store2.id !== currentStore.id) {
-          setAtom(atom, value, store2, true);
+          setAtom(atom, newValue, store2, true);
         }
       }
     }
   };
+  let mountCount = 0;
+  let userCleanup;
+  const userOnMount = options.onMount;
+  const onMount = userOnMount ? (...args) => {
+    mountCount++;
+    if (mountCount === 1) {
+      try {
+        userCleanup = userOnMount(...args);
+      } catch (error) {
+        mountCount--;
+        userCleanup = undefined;
+        throw error;
+      }
+    }
+    return () => {
+      if (mountCount <= 0)
+        return;
+      mountCount--;
+      if (mountCount === 0 && typeof userCleanup === "function") {
+        const cleanup = userCleanup;
+        userCleanup = undefined;
+        cleanup();
+      }
+    };
+  } : undefined;
   const getSelf = () => globalStore.get(atom);
   const setSelf = (newValue) => globalStore.set(atom, newValue);
   const resetSelf = () => {
-    value = undefined;
-    initialized = false;
-    for (const store2 of stores) {
-      if (store2.stateDependencies.has(atom)) {
-        throw new Error("TODO: Reset support for stateDependencies");
+    const snapshot = [...stores];
+    const subscribedStores = [];
+    for (const s of snapshot) {
+      if (isTransitivelySubscribed(atom, s)) {
+        subscribedStores.push(s);
       }
-      store2.values.delete(atom);
-      store2.expiredValues.delete(atom);
-      propagateUpdatedAtoms([atom], store2);
+    }
+    let firstError;
+    const recordError = (e) => {
+      if (!firstError)
+        firstError = e;
+    };
+    for (const s of snapshot) {
+      try {
+        unmountAtom(atom, s);
+      } catch (e) {
+        recordError(e);
+      }
+    }
+    if (atom.maxAgeInterval) {
+      atom.maxAgeInterval.cleanup();
+      atom.maxAgeInterval.refCount = 0;
+      atom.maxAgeInterval = undefined;
+    }
+    for (const store2 of snapshot) {
       stores.delete(store2);
-      onReset?.();
+      store2.values.delete(atom);
+      try {
+        propagateUpdatedAtoms([atom], store2);
+      } catch (e) {
+        recordError(e);
+      }
+    }
+    for (const s of subscribedStores) {
+      stores.add(s);
+      if (atom.maxAge && (s.subscriptions.get(atom)?.size ?? 0) > 0) {
+        installMaxAgeTimer(atom, s);
+      }
+      try {
+        mountAtom(atom, s);
+      } catch (e) {
+        recordError(e);
+      }
     }
+    if (firstError)
+      throw firstError;
+  };
+  const detach = (storeData) => {
+    stores.delete(storeData);
   };
   const atom = {
     equal,
     ...options,
     defaultValue,
-    name: options?.name,
     onInit,
     onSet,
+    onMount,
     setSelf,
     getSelf,
     resetSelf,
+    detach,
     get stores() {
       return stores;
-    }
+    },
+    maxAgeInterval: undefined
   };
   return atom;
 };
@@ -1057,17 +2153,6 @@ function atom(defaultValue, options) {
     ...options
   };
 }
-// src/lib/atomFamilyAtom.ts
-function atomFamilyAtom(defaultValue, options) {
-  if (options.global) {
-    return globalAtom(defaultValue, options);
-  }
-  return {
-    ...options,
-    defaultValue
-  };
-}
-
 // src/lib/stableStringify.ts
 var stableStringifyRecurse = (x, key) => {
   if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
@@ -1127,47 +2212,66 @@ var stringifyFamilyArgs = (args) => {
   return args.length === 1 ? stableStringify(args[0]) : stableStringify(args);
 };
 
-// src/lib/createAtomFamily.ts
-var createOptions = (options = {}, family, familyArgs, familyArgsStringified) => {
-  if (options.name) {
-    return {
-      equal,
-      ...options,
-      name: options?.name + "_" + familyArgsStringified,
-      family,
-      familyArgs,
-      familyArgsStringified
-    };
-  } else {
-    return { equal, ...options, family, familyArgs, familyArgsStringified };
-  }
-};
-var handleDefaultValue = (defaultValue, ...args) => {
-  if (isSelectorFamily(defaultValue))
-    return defaultValue(...args);
-  if (typeof defaultValue === "function")
-    return () => defaultValue(...args);
-  return defaultValue;
+// src/lib/familyKey.ts
+var familyKey = (args) => {
+  if (args.length === 1) {
+    const a = args[0];
+    const t = typeof a;
+    if (t === "string" || t === "number" || t === "boolean")
+      return a;
+  }
+  return stringifyFamilyArgs(args);
 };
+
+// src/lib/createAtomFamily.ts
 var createAtomFamily = (defaultValue, options) => {
   const map = new Map;
+  const isSelectorFamilyDefault = isSelectorFamily(defaultValue);
+  const isFunctionDefault = !isSelectorFamilyDefault && typeof defaultValue === "function";
+  const hasName = !!options?.name;
+  const isGlobal = !!options?.global;
   const atomFamily = (...args) => {
-    const argsStringified = stringifyFamilyArgs(args);
-    if (map.has(argsStringified)) {
-      return map.get(argsStringified);
+    const key = familyKey(args);
+    const cached = map.get(key);
+    if (cached !== undefined)
+      return cached;
+    let dv;
+    if (isSelectorFamilyDefault) {
+      dv = defaultValue(...args);
+    } else if (isFunctionDefault) {
+      dv = () => defaultValue(...args);
+    } else {
+      dv = defaultValue;
+    }
+    const memberName = hasName ? options.name + "_" + key : undefined;
+    let familyAtom;
+    if (isGlobal) {
+      familyAtom = globalAtom(dv, {
+        ...options,
+        name: memberName
+      });
+    } else {
+      familyAtom = {
+        equal,
+        ...options,
+        defaultValue: dv,
+        name: memberName
+      };
     }
-    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, ...args), createOptions(options, atomFamily, args, argsStringified));
-    map.set(argsStringified, familyAtom);
+    familyAtom.family = atomFamily;
+    familyAtom.familyArgs = args;
+    familyAtom.familyArgsStringified = key;
+    map.set(key, familyAtom);
     return familyAtom;
   };
-  if (options?.name)
+  if (hasName)
     Object.defineProperty(atomFamily, "name", {
       value: options.name,
       writable: false
     });
   return Object.assign(atomFamily, {
     __valdresAtomFamilyMap: map,
-    release: (...args) => map.delete(stringifyFamilyArgs(args)),
+    release: (...args) => map.delete(familyKey(args)),
     equal
   });
 };
@@ -1190,30 +2294,26 @@ function atomFamily(defaultValue, options) {
     return createGlobalAtomFamily(defaultValue, options);
   return createAtomFamily(defaultValue, options);
 }
-// src/createStoreWithSelectorSet.ts
-var setSelector = (selector, values, store2) => {
-  return selector.set(store2.set, store2.get, store2.reset, ...values);
-};
-var createStoreWithSelectorSet = (id) => {
-  const data = createStoreData(id);
-  const store2 = storeFromStoreData(data);
-  store2.set = (state, value, ...rest) => {
-    if (isAtom(state))
-      return setAtom(state, value, data);
-    if (isSelector(state))
-      return setSelector(state, [value, ...rest], store2);
-    throw new Error("Invalid state object");
-  };
-  store2.kind = "storeWithSelectorSet";
-  return store2;
-};
 // src/selector.ts
 var selector = (get, options) => {
+  if (get.constructor?.name === "AsyncFunction") {
+    throw new Error("selector() does not accept async functions. " + "Use a sync function that returns a Promise instead.");
+  }
   if (!options)
     return { equal, get };
   return { equal, ...options, get };
 };
 
+// src/cacheMeta.ts
+var cacheMeta = (sourceAtom) => {
+  if (sourceAtom.__cacheMetaSelector)
+    return sourceAtom.__cacheMetaSelector;
+  if (!sourceAtom.__cacheMeta) {
+    sourceAtom.__cacheMeta = { equal, defaultValue: null };
+  }
+  sourceAtom.__cacheMetaSelector = selector((get) => get(sourceAtom.__cacheMeta));
+  return sourceAtom.__cacheMetaSelector;
+};
 // src/indexConstructor.ts
 var index = (family, callback, options) => {
   const map = new Map;
@@ -1264,32 +2364,30 @@ var index = (family, callback, options) => {
   });
 };
 // src/selectorFamily.ts
-var createOptions2 = (options = {}, family, familyArgs, familyArgsStringified) => {
-  if (options.name) {
-    return {
-      equal,
-      ...options,
-      name: options?.name + "_" + familyArgsStringified,
-      family,
-      familyArgs,
-      familyArgsStringified
-    };
-  } else {
-    return { equal, ...options, family, familyArgs, familyArgsStringified };
-  }
-};
 var selectorFamily = (callback, options) => {
   const map = new Map;
+  const hasName = !!options?.name;
   const selectorFamily2 = (...args) => {
-    const argsStringified = stringifyFamilyArgs(args);
-    if (map.has(argsStringified))
-      return map.get(argsStringified);
-    const newSelector = selector((selectorArgs) => callback(...args)(selectorArgs), createOptions2(options, selectorFamily2, args, argsStringified));
-    map.set(argsStringified, newSelector);
+    const key = familyKey(args);
+    const cached = map.get(key);
+    if (cached !== undefined)
+      return cached;
+    const get = (selectorArgs) => callback(...args)(selectorArgs);
+    const newSelector = {
+      equal,
+      ...options,
+      get,
+      family: selectorFamily2,
+      familyArgs: args,
+      familyArgsStringified: key,
+      name: hasName ? options.name + "_" + key : undefined
+    };
+    map.set(key, newSelector);
     return newSelector;
   };
   selectorFamily2.__valdresSelectorFamilyMap = map;
-  if (options?.name)
+  selectorFamily2.release = (...args) => map.delete(familyKey(args));
+  if (hasName)
     Object.defineProperty(selectorFamily2, "name", {
       value: options.name,
       writable: false
@@ -1301,14 +2399,15 @@ 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: ${"0.2.0-pre.8"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.0"}`);
 } else {
-  globalThis.__valdres__ = "0.2.0-pre.8";
+  globalThis.__valdres__ = "1.0.0-beta.0";
 }
 export {
   store,
   selectorFamily,
   selector,
+  isSuspendError,
   isSelectorFamily,
   isSelector,
   isPromiseLike,
@@ -1321,7 +2420,8 @@ export {
   index,
   globalStore,
   deepFreeze,
-  createStoreWithSelectorSet,
+  cacheMeta,
   atomFamily,
-  atom
+  atom,
+  Transaction
 };