valdres 0.2.0-y.0 → 1.0.0-beta.0

package/dist/index.js

@@ -1,12 +1,13 @@
-// src/index.ts
-import { version } from "../package.json";
-
 // src/lib/equal.ts
 var hasElementType = typeof Element !== "undefined";
 var hasMap = typeof Map === "function";
 var hasSet = typeof Set === "function";
 var hasArrayBuffer = typeof ArrayBuffer === "function" && !!ArrayBuffer.isView;
-var deepEqualFn = (a, b) => {
+var deepEqualFn = (a, b, updatedAtomsSet) => {
+  if (updatedAtomsSet) {
+    if (updatedAtomsSet.has(a) || updatedAtomsSet.has(b))
+      return false;
+  }
   if (a === b)
     return true;
   if (a && b && typeof a == "object" && typeof b == "object") {
@@ -18,7 +19,7 @@ var deepEqualFn = (a, b) => {
       if (length != b.length)
         return false;
       for (i = length;i-- !== 0; )
-        if (!deepEqualFn(a[i], b[i]))
+        if (!deepEqualFn(a[i], b[i], updatedAtomsSet))
           return false;
       return true;
     }
@@ -32,7 +33,7 @@ var deepEqualFn = (a, b) => {
           return false;
       it = a.entries();
       while (!(i = it.next()).done)
-        if (!deepEqualFn(i.value[1], b.get(i.value[0])))
+        if (!deepEqualFn(i.value[1], b.get(i.value[0]), updatedAtomsSet))
           return false;
       return true;
     }
@@ -40,9 +41,12 @@ var deepEqualFn = (a, b) => {
       if (a.size !== b.size)
         return false;
       it = a.entries();
-      while (!(i = it.next()).done)
+      while (!(i = it.next()).done) {
         if (!b.has(i.value[0]))
           return false;
+        if (updatedAtomsSet?.has(i.value[0]))
+          return false;
+      }
       return true;
     }
     if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
@@ -73,16 +77,16 @@ var deepEqualFn = (a, b) => {
       if ((keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) {
         continue;
       }
-      if (!deepEqualFn(a[keys[i]], b[keys[i]]))
+      if (!deepEqualFn(a[keys[i]], b[keys[i]], updatedAtomsSet))
         return false;
     }
     return true;
   }
   return a !== a && b !== b;
 };
-var equal = (a, b) => {
+var equal = (a, b, updatedAtomsSet) => {
   try {
-    return deepEqualFn(a, b);
+    return deepEqualFn(a, b, updatedAtomsSet);
   } catch (error) {
     if ((error.message || "").match(/stack|recursion/i)) {
       console.warn("react-fast-compare cannot handle circular refs");
@@ -95,154 +99,203 @@ var equal = (a, b) => {
 // 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/lib/updateStateSubscribers.ts
-var updateStateSubscribers = (state, data) => {
-  const subscribtions = data.subscriptions.get(state);
-  if (subscribtions?.size) {
-    for (const subscribtion of subscribtions) {
-      subscribtion.callback();
-    }
-  }
-  if (isFamilyState(state)) {
-    const familySubscriptions = data.subscriptions.get(state.family);
-    if (familySubscriptions?.size) {
-      for (const subscribtion of familySubscriptions) {
-        subscribtion.callback(state.familyKey);
-      }
-    }
-  }
-};
+// 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/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/utils/deepFreeze.ts
+var deepFreeze = (obj, seen = new WeakSet) => {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object" && typeof obj !== "function")
+    return 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") {
+        deepFreeze(item, seen);
+      }
+    }
+  } else {
+    const propNames = Object.getOwnPropertyNames(obj);
+    for (const name of propNames) {
+      const value = obj[name];
+      if (value && typeof value === "object") {
+        deepFreeze(value, seen);
+      }
+    }
+  }
+  return Object.freeze(obj);
+};
 
-// src/lib/isFunction.ts
-var isFunction = (value) => typeof value === "function";
+// src/lib/isProd.ts
+var isProd = () => {
+  return false;
+};
 
-// src/lib/setAtom.ts
-var setAtom = (atom, newValue, data, skipOnSet = false) => {
-  const currentValue = getState(atom, data);
-  if (isFunction(newValue)) {
-    newValue = newValue(currentValue);
-    if (isPromiseLike(newValue) || isPromiseLike(currentValue))
-      throw new Error("Todo, how should we handle this?");
+// 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);
   }
-  if (atom.equal(currentValue, newValue))
-    return newValue;
-  data.values.set(atom, newValue);
-  if (atom.onSet && !skipOnSet)
-    atom.onSet(newValue, data);
-  if (currentValue?.__isEmptyAtomPromise__) {
-    currentValue.__resolveEmptyAtomPromise__(newValue);
+  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);
+    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);
+  if (atom.maxAge !== undefined) {
+    data.lastValueWriteAt.set(atom, Date.now());
   }
-  propagateUpdatedAtoms([atom], data);
-  return newValue;
+  return written;
 };
 
-// src/lib/initAtom.ts
-var getAtomInitValue = (atom, data) => {
-  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) => {
-        data.values.set(atom, resolvedValue);
-        propagateUpdatedAtoms([atom], data);
-      });
-    }
-    return value;
-  } else if (isSelector(atom.defaultValue)) {
-    return getState(atom.defaultValue, data);
-  } else {
-    return atom.defaultValue;
+// 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 initAtom = (atom, data) => {
-  let value = getAtomInitValue(atom, data);
-  data.values.set(atom, value);
-  if (isFamilyAtom(atom)) {
-    const currentKeySet = getState(atom.family.__keysAtom, data);
-    if (!currentKeySet.has(atom.familyKey)) {
-      const newSet = new Set(currentKeySet);
-      newSet.add(atom.familyKey);
-      setAtom(atom.family.__keysAtom, newSet, data);
-    }
+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;
   }
-  if (atom.onInit)
-    atom.onInit((newVal) => {
-      value = newVal;
-      setAtom(atom, newVal, data, true);
-    }, data);
-  return value;
+  const renderedMap = getAtomFamilyRenderedMap(index);
+  const array = getSortedKeysByValues(renderedMap);
+  array.__index = index;
+  index.renderedArray = array;
+  return array;
 };
-
-// src/lib/getState.ts
-function getState(state, data, circularDependencySet) {
-  if (data.values.has(state))
-    return data.values.get(state);
-  if (isAtom(state)) {
-    if ("parent" in data)
-      return getState(state, data.parent, circularDependencySet);
-    return initAtom(state, data);
+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);
   }
-  if (isSelector(state))
-    return initSelector(state, data, circularDependencySet);
-  if (isAtomFamily(state)) {
-    if ("parent" in data) {
-      const closestData = findClosestStoreWithAtomInitialized(state.__keysAtom, data);
-      return getState(state.__keysSelector, closestData, circularDependencySet);
-    }
-    return getState(state.__keysSelector, data, circularDependencySet);
+  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");
   }
-  if (isSelectorFamily(state)) {
-    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
-    if (equal(array, state._keyArray))
-      return state._keyArray;
-    state._keyArray = array;
-    return array;
+  const index = createAtomFamilyIndex(parentIndex);
+  data.values.set(family, renderAtomFamilyIndex(index));
+  if ("parent" in data) {
+    trackScopeValue(family, data);
   }
-  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);
+  return index;
 };
-
-// src/lib/initSelector.ts
-class SuspendAndWaitForResolveError extends Error {
-  promise;
-  constructor(promise) {
-    super();
-    this.promise = promise;
+var findFamilyIndex = (family, data) => {
+  if (!data.values.has(family)) {
+    initFamilyIndex(family, data);
   }
-}
+  const value = data.values.get(family);
+  if (!value?.__index) {
+    throw new Error("Family index is missing");
+  }
+  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);
+  }
+};
+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/errors/lib/generateSelectorTrace.ts
 var generateSelectorTrace = (selectors) => {
   const lastIndex = selectors.length - 1;
   return [...selectors].reverse().map((selector, index) => {
@@ -258,205 +311,844 @@ var generateSelectorTrace = (selectors) => {
 `);
 };
 
-class CircularDependencyError extends Error {
+// src/errors/SelectorEvaluationError.ts
+class SelectorEvaluationError extends Error {
   selectors;
-  constructor() {
+  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/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)}`;
   }
 }
-var getOrInitConsumersSet = (state, data) => {
-  const set = data.stateConsumers.get(state);
+
+// src/lib/asyncDependencyTracking.ts
+var pendingAsyncDeps = new WeakMap;
+var latestEvalContext = new WeakMap;
+
+class SuspendAndWaitForResolveError extends Error {
+  promise;
+  constructor(promise) {
+    super();
+    this.promise = promise;
+  }
+}
+var isSuspendError = (e) => {
+  return e instanceof SuspendAndWaitForResolveError;
+};
+var getOrInitDependentsSet = (state, data) => {
+  const set = data.stateDependents.get(state);
   if (set)
     return set;
   const newSet = new Set;
-  data.stateConsumers.set(state, newSet);
+  data.stateDependents.set(state, newSet);
   return newSet;
 };
-var evaluateSelector = (selector, data, circularDependencyMap = new WeakSet) => {
-  const updatedDependencies = new Set;
-  if (circularDependencyMap.has(selector)) {
-    throw new CircularDependencyError;
+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);
+    }
   }
-  circularDependencyMap.add(selector);
+};
+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) => {
-      const value = getState(state, data, circularDependencyMap);
-      updatedDependencies.add(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);
+      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 {
+    } else if (error instanceof SelectorEvaluationError) {
       throw error;
+    } else {
+      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 = getOrInitConsumersSet(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 = getOrInitConsumersSet(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(() => initSelector(selector, data));
-    return value.promise;
+    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 promise;
   } else if (isPromiseLike(value)) {
     value.then((resolved) => {
-      data.values.set(selector, resolved);
-      updateStateSubscribers(selector, data);
-      console.log("Should we reEvaluate?");
+      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, circularDependencySet = new WeakSet) => {
+var initSelectorDirect = (selector, data, initializedAtomsSet, circularDependencySet) => {
+  const existingValue = data.values.get(selector);
+  const updatedValue = evaluate(selector, data, initializedAtomsSet, circularDependencySet);
+  const areEqual = isPromiseLike(existingValue) || isPromiseLike(updatedValue) ? existingValue === updatedValue : selector.equal(existingValue, updatedValue);
+  if (areEqual) {
+    return false;
+  } else {
+    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 {
-    tmpValue = evaluateSelector(selector, data, circularDependencySet);
+    tmpValue = evaluateSelector(selector, data, initializedAtomsSet, circularDependencySet);
   } catch (e) {
-    if (e instanceof CircularDependencyError)
+    if (e instanceof SelectorEvaluationError)
       e.track(selector);
     throw e;
   }
-  const value = handleSelectorResult(tmpValue, selector, data);
-  if (data.expiredValues.has(selector)) {
-    const expiredValue = data.expiredValues.get(selector);
-    if (selector.equal(expiredValue, value)) {
-      data.values.set(selector, expiredValue);
-      return expiredValue;
+  return handleSelectorResult(tmpValue, selector, data);
+};
+
+// 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 rawValue = evaluateSelector(selector, data, updatedAtoms, undefined, addedDeps, removedDeps);
+    const udpatedValue = handleSelectorResult(rawValue, selector, data);
+    const areEqual = isPromiseLike(existingValue) || isPromiseLike(udpatedValue) ? existingValue === udpatedValue : selector.equal(existingValue, udpatedValue, updatedAtoms);
+    if (areEqual) {
+      return [false, false, undefined, addedDeps, removedDeps];
+    } else {
+      setValueInData(selector, udpatedValue, data);
+      return [true, false, undefined, addedDeps, removedDeps];
     }
+  } catch (error) {
+    data.values.delete(selector);
+    return [true, true, error, addedDeps, removedDeps];
   }
-  data.values.set(selector, value);
-  return value;
 };
-
-// src/lib/updateSelectorSubscribers.ts
-var updateSelectorSubscribers = (selector, data) => {
-  const subscribtions = data.subscriptions.get(selector);
-  const familySubscriptions = selector.family && data.subscriptions.get(selector.family);
-  if (!subscribtions?.size && !familySubscriptions?.size)
-    return;
-  if (subscribtions?.size && data.subscriptionsRequireEqualCheck.get(selector) || familySubscriptions?.size && selector.family && data.subscriptionsRequireEqualCheck.get(selector.family)) {
-    try {
-      const oldValue = data.expiredValues.get(selector);
-      const newValue = initSelector(selector, data);
-      if (selector.equal(newValue, oldValue))
+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) {
+      toSet.add(item);
+    }
+  }
+};
+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);
+    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");
+      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;
-    } catch (e) {
+      }
     }
   }
-  if (subscribtions?.size) {
-    for (const subscribtion of subscribtions) {
-      subscribtion.callback();
+  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 (familySubscriptions?.size) {
-    for (const subscribtion of familySubscriptions) {
-      subscribtion.callback(selector.familyKey);
+  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, 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);
+            }
+          }
+        }
+      }
     }
   }
 };
-
-// src/lib/propagateUpdatedAtoms.ts
-var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
-  for (const selector of selectors) {
-    if (!clearedSelectors.has(selector)) {
-      clearedSelectors.add(selector);
-      data.expiredValues.set(selector, data.values.get(selector));
-      data.values.delete(selector);
-      const consumers = data.stateConsumers.get(selector);
-      if (consumers?.size) {
-        recursivlyResetSelectorTree(consumers, data, clearedSelectors);
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false) => {
+  const updatedInitializedAtoms = new Set(updatedAtoms);
+  if (selectors.size > 0) {
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly);
+  }
+  if (subscriptions.size > 0) {
+    callSubscribers(subscriptions, families);
+  }
+};
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
+  let currentSelectors = selectors;
+  while (currentSelectors.size > 0) {
+    const selectorsForNextPass = new Set;
+    for (const selector of currentSelectors) {
+      const currentValue = data.values.get(selector);
+      if (isPromiseLike(currentValue) && isInitOnly) {
+        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);
+          }
+        }
+        if (!wasValueUpdated)
+          continue;
+        addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
+        addSetToSet(subscribers, collectedSubscribers);
       }
     }
+    currentSelectors = selectorsForNextPass;
   }
 };
-var propagateUpdatedAtoms = (atoms, data) => {
-  const clearedSelectors = new Set;
-  for (const atom of atoms) {
-    const consumers = data.stateConsumers.get(atom);
-    if (consumers && consumers.size) {
-      recursivlyResetSelectorTree(consumers, data, clearedSelectors);
+
+// 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);
     }
-    if (isFamilyAtom(atom)) {
-      const consumersFamily = data.stateConsumers.get(atom.family);
-      if (consumersFamily?.size) {
-        recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
+    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 {
+      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 (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);
   }
-  for (const selector of clearedSelectors) {
-    updateSelectorSubscribers(selector, data);
+  if (isSelector(state)) {
+    if (_evalDepth >= MAX_EVAL_DEPTH) {
+      throw new NeedsInitError(state);
+    }
+    initSelector(state, data, initializedAtomsSet, circularDependencySet);
+    return data.values.get(state);
   }
-  for (const atom of atoms) {
-    updateStateSubscribers(atom, data);
+  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,
-    stateConsumers: 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) => {
+  data.values.delete(atom);
+  if (atom.family) {
+    atom.family.release(...atom.familyArgs);
+  }
+  propagateDeletedAtoms([atom], data);
+};
+
 // src/lib/resetAtom.ts
 var resetAtom = (atom, data) => {
-  let value = getAtomInitValue(atom, data);
-  data.values.set(atom, value);
+  const initializedAtomsSet = new Set;
+  let value = getAtomInitValue(atom, data, initializedAtomsSet);
+  setValueInData(atom, value, data);
   if (!isPromiseLike(value)) {
     propagateUpdatedAtoms([atom], data);
   }
+  if (initializedAtomsSet.size > 0) {
+    throw new Error("Todo - propagateUpdatedAtoms on reset");
+  }
   return value;
 };
 
 // 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);
@@ -472,26 +1164,246 @@ var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
         data.subscriptionsRequireEqualCheck.delete(state);
       }
     }
-    if (subscribers.size === 0) {
-      if (maxAgeCleanup)
-        maxAgeCleanup();
-      data.subscriptions.delete(state);
+    if (subscribers.size === 0) {
+      const maxAgeCleanup = getMaxAgeCleanup(data, state);
+      if (maxAgeCleanup) {
+        maxAgeCleanup();
+        deleteMaxAgeCleanup(data, state);
+      }
+      data.subscriptions.delete(state);
+      unmountOrphanedDeps(state, data);
+      cleanupOrphanedDeps(state, data);
+    }
+  }
+};
+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);
+    }
+  }
+};
+
+// src/lib/subscribe.ts
+var initSubscribers = (state, data) => {
+  const set = new Set;
+  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;
+      }
     }
-    if (mount) {
-      if (subscribers.size === mount.mountSubscriptions.size) {
-        if (typeof mount.onUnmount === "function") {
-          mount.onUnmount();
+    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);
   }
-};
-
-// src/lib/subscribe.ts
-var initSubscribers = (state, data) => {
-  const set = new Set;
-  data.subscriptions.set(state, set);
-  return set;
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
   let parentUnsubscribe;
@@ -506,14 +1418,21 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
       originalCallback(arg);
     };
   } else if (!data.values.has(state) && isAtom(state)) {
-    initAtom(state, data);
+    const initializedAtomsSet = new Set;
+    initAtom(state, data, initializedAtomsSet);
+    if (initializedAtomsSet.size) {
+      throw new Error("This should not be possible");
+    }
   }
   if (isSelector(state) && !data.values.has(state)) {
-    initSelector(state, data);
+    initSelector(state, data, new Set, new WeakSet);
   }
   const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
   let subscription;
   if (isFamily(state)) {
+    if (isSelectorFamily(state)) {
+      throw new Error("Subscribe to selectorFammily is currently not supported");
+    }
     subscription = {
       callback,
       state,
@@ -526,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 {
-          data.values.set(state, value);
-          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) {
@@ -574,140 +1460,273 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
     if (parentUnsubscribe) {
       parentUnsubscribe();
     }
-    unsubscribe(state, subscription, data, mount, maxAgeCleanup);
+    unsubscribe(state, subscription, data);
   };
 };
 
 // src/lib/setAtoms.ts
-var setAtoms = (pairs, data) => {
+var setAtoms = (pairs, data, initializedAtomsSet) => {
   const updatedAtoms = [];
   for (let [atom, value] of pairs) {
-    const currentValue = getState(atom, data);
-    if (!atom.equal(currentValue, value)) {
+    const currentValue = getState(atom, data, initializedAtomsSet);
+    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);
-      data.values.set(atom, value);
+    } else {
+      setValueInData(atom, value, data);
+    }
+  }
+  if (initializedAtomsSet.size > 0) {
+    for (const atom of initializedAtomsSet) {
+      updatedAtoms.push(atom);
     }
   }
-  propagateUpdatedAtoms(updatedAtoms, data);
+  if (updatedAtoms.length > 0) {
+    propagateUpdatedAtoms(updatedAtoms, data);
+  }
 };
 
 // src/lib/transaction.ts
-var findDependencies = (state, data, result = new Set) => {
-  const consumers = data.stateConsumers.get(state);
-  if (consumers?.size) {
-    for (const consumer of consumers) {
-      if (!result.has(consumer)) {
-        result.add(consumer);
-        findDependencies(consumer, data, result);
-      }
-    }
-  }
-  return result;
+var deleteAtomFamilyAtoms = (set, data) => {
+  set.forEach((atom) => {
+    data.values.delete(atom);
+  });
 };
-var recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache) => {
-  for (const dep of txnSubscribers.get(state)) {
-    txnSelectorCache.delete(dep);
-    if (txnSubscribers.get(dep)?.size) {
-      recursivlyResetTxnSelectorCache(dep, txnSubscribers, txnSelectorCache);
+
+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]
+      ]);
     }
   }
-};
-var captureScopedTransaction = (scopedData) => {
-  let txn;
-  transaction((scopedTxn) => {
-    txn = scopedTxn;
-  }, scopedData, false);
-  return txn;
-};
-var transaction = (callback, data, autoCommit = true) => {
-  let txnAtomMap = new Map;
-  let txnSelectorCache = new Map;
-  let txnSubscribers = new Map;
-  let dirtySelectors = new Set;
-  let scopedTransactions;
-  const txnGet = (state) => {
-    if (isAtom(state)) {
-      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState(state, data);
+  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 (this.parentTransaction) {
+      return this.parentTransaction.valueFromTxnOrData(state);
+    }
+  };
+  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 (isFamily(state)) {
-      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState(state.__keysSelector, data);
     } 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 (!atom.mutable && !isProd() && value !== null && (typeof value === "object" || typeof value === "function")) {
+      value = deepFreeze(value);
     }
-    if (txnSubscribers.get(atom)?.size) {
-      recursivlyResetTxnSelectorCache(atom, txnSubscribers, txnSelectorCache);
+    this._atomMap.set(atom, value);
+    if (!this.dirty)
+      this.dirty = true;
+    if (isFamilyAtom(atom)) {
+      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);
     }
-    txnAtomMap.set(atom, value);
     return value;
   };
-  const txnReset = (atom) => {
-    const value = getAtomInitValue(atom, data);
-    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 commit = () => {
-    setAtoms(txnAtomMap, data);
-    dirtySelectors.clear();
-    if (scopedTransactions) {
-      for (const scopedTxn of Object.values(scopedTransactions)) {
+  execute = (callback, autoCommit = true) => {
+    const result = callback(this);
+    if (autoCommit)
+      this.txnCommit();
+    return result;
+  };
+  txnCommit = () => {
+    if (this.parentTransaction) {
+      this.parentTransaction.txnCommit();
+    } else {
+      this.commit();
+    }
+  };
+  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,
-    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);
-        }
-        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
@@ -718,35 +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) => getState(state, data);
-  const set = (state, value) => {
+  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 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 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 {
@@ -755,6 +1889,7 @@ function storeFromStoreData(data, detach) {
       sub,
       txn,
       reset,
+      del,
       data,
       scope,
       detach
@@ -766,15 +1901,121 @@ function storeFromStoreData(data, detach) {
       sub,
       txn,
       reset,
+      del,
       data,
       scope
     };
   }
 }
 
+// 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);
 };
 
@@ -787,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;
 };
@@ -859,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("\\")) {
@@ -924,57 +2207,73 @@ var stableStringify = (x) => {
   return stableStringifyRecurse(x);
 };
 
-// src/selector.ts
-var selector = (get, options) => {
-  if (!options)
-    return { equal, get };
-  return { equal, ...options, get };
+// src/lib/stringifyFamilyArgs.ts
+var stringifyFamilyArgs = (args) => {
+  return args.length === 1 ? stableStringify(args[0]) : stableStringify(args);
 };
 
-// src/lib/createAtomFamily.ts
-var createOptions = (options = {}, family, familyKey, keyStringified) => {
-  if (options.name) {
-    return {
-      equal,
-      ...options,
-      name: options?.name + "_" + keyStringified,
-      family,
-      familyKey
-    };
-  } else {
-    return { equal, ...options, family, familyKey };
+// 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);
 };
-var handleDefaultValue = (defaultValue, key) => {
-  if (isSelectorFamily(defaultValue))
-    return defaultValue(key);
-  if (typeof defaultValue === "function")
-    return () => defaultValue(key);
-  return defaultValue;
-};
+
+// src/lib/createAtomFamily.ts
 var createAtomFamily = (defaultValue, options) => {
   const map = new Map;
-  const keysAtom = atom(new Set);
-  const atomFamily = Object.assign((key) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified)) {
-      return map.get(keyStringified);
-    }
-    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, key), createOptions(options, atomFamily, Object.freeze(key), keyStringified));
-    map.set(keyStringified, familyAtom);
+  const isSelectorFamilyDefault = isSelectorFamily(defaultValue);
+  const isFunctionDefault = !isSelectorFamilyDefault && typeof defaultValue === "function";
+  const hasName = !!options?.name;
+  const isGlobal = !!options?.global;
+  const atomFamily = (...args) => {
+    const key = familyKey(args);
+    const cached = map.get(key);
+    if (cached !== undefined)
+      return cached;
+    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
+      };
+    }
+    familyAtom.family = atomFamily;
+    familyAtom.familyArgs = args;
+    familyAtom.familyArgsStringified = key;
+    map.set(key, familyAtom);
     return familyAtom;
-  }, {
-    __valdresAtomFamilyMap: map,
-    release: (key) => map.delete(key),
-    __keysAtom: keysAtom,
-    __keysSelector: selector((get) => Array.from(get(keysAtom)))
-  });
-  if (options?.name)
+  };
+  if (hasName)
     Object.defineProperty(atomFamily, "name", {
       value: options.name,
       writable: false
     });
-  return atomFamily;
+  return Object.assign(atomFamily, {
+    __valdresAtomFamilyMap: map,
+    release: (...args) => map.delete(familyKey(args)),
+    equal
+  });
 };
 
 // src/lib/createGlobalAtomFamily.ts
@@ -995,49 +2294,100 @@ function atomFamily(defaultValue, options) {
     return createGlobalAtomFamily(defaultValue, options);
   return createAtomFamily(defaultValue, options);
 }
-// src/createStoreWithSelectorSet.ts
-var setSelector = (selector2, values, store2) => {
-  return selector2.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");
+// 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;
+  const index2 = (term) => {
+    const termKey = stableStringify(term);
+    if (map.has(termKey))
+      return map.get(termKey);
+    const termIndexSelectorSet = new Set;
+    const termIndexSelectorMap = new Map;
+    const termIndexSelector = selector((get) => {
+      const allFamilyAtoms = new Set(get(family));
+      const deletedAtoms = termIndexSelectorSet.symmetricDifference(allFamilyAtoms);
+      const addedAtoms = allFamilyAtoms.difference(termIndexSelectorSet);
+      if (deletedAtoms.size || addedAtoms.size) {
+        deletedAtoms.forEach((atom2) => {
+          termIndexSelectorSet.delete(atom2);
+          termIndexSelectorMap.delete(atom2);
+        });
+        addedAtoms.forEach((atom2) => {
+          termIndexSelectorSet.add(atom2);
+          termIndexSelectorMap.set(atom2, selector((get2) => callback(get2(atom2), term), {
+            name: `index:callback:selector:${atom2.name}`
+          }));
+        });
+        return new Set(termIndexSelectorSet);
+      } else {
+        return termIndexSelectorSet;
+      }
+    }, { name: `index:${options?.name}(${termKey})` });
+    const filteredSelector = selector((get) => {
+      const set = get(termIndexSelector);
+      const res = [];
+      set.forEach((atom2) => {
+        if (get(termIndexSelectorMap.get(atom2))) {
+          res.push(atom2);
+        }
+      });
+      return res;
+    }, {
+      name: `index:${options?.name}:${termKey}:termSelector`
+    });
+    map.set(termKey, filteredSelector);
+    return filteredSelector;
   };
-  store2.kind = "storeWithSelectorSet";
-  return store2;
+  return Object.assign(index2, {
+    map,
+    callback
+  });
 };
 // src/selectorFamily.ts
-var createOptions2 = (options = {}, family, familyKey, keyStringified) => {
-  if (options.name) {
-    return {
+var selectorFamily = (callback, options) => {
+  const map = new Map;
+  const hasName = !!options?.name;
+  const selectorFamily2 = (...args) => {
+    const key = familyKey(args);
+    const cached = map.get(key);
+    if (cached !== undefined)
+      return cached;
+    const get = (selectorArgs) => callback(...args)(selectorArgs);
+    const newSelector = {
       equal,
       ...options,
-      name: options?.name + "_" + keyStringified,
-      family,
-      familyKey
+      get,
+      family: selectorFamily2,
+      familyArgs: args,
+      familyArgsStringified: key,
+      name: hasName ? options.name + "_" + key : undefined
     };
-  } else {
-    return { equal, ...options, family, familyKey };
-  }
-};
-var selectorFamily = (get, options) => {
-  const map = new Map;
-  const selectorFamily2 = (key) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified))
-      return map.get(keyStringified);
-    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), createOptions2(options, selectorFamily2, key, keyStringified));
-    map.set(keyStringified, newSelector);
+    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
@@ -1049,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: ${version}`);
+  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__ = version;
+  globalThis.__valdres__ = "1.0.0-beta.0";
 }
 export {
   store,
   selectorFamily,
   selector,
+  isSuspendError,
   isSelectorFamily,
   isSelector,
   isPromiseLike,
@@ -1066,8 +2417,11 @@ export {
   isFamily,
   isAtomFamily,
   isAtom,
+  index,
   globalStore,
-  createStoreWithSelectorSet,
+  deepFreeze,
+  cacheMeta,
   atomFamily,
-  atom
+  atom,
+  Transaction
 };