valdres 0.2.0-alpha.9 → 0.2.0-pre.10

package/dist/index.js

@@ -1,40 +1,230 @@
-// src/lib/setAtom.ts
-import equal4 from "fast-deep-equal";
+// 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, 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") {
+    if (a.constructor !== b.constructor)
+      return false;
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length;i-- !== 0; )
+        if (!deepEqualFn(a[i], b[i], updatedAtomsSet))
+          return false;
+      return true;
+    }
+    var it;
+    if (hasMap && a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size)
+        return false;
+      it = a.entries();
+      while (!(i = it.next()).done)
+        if (!b.has(i.value[0]))
+          return false;
+      it = a.entries();
+      while (!(i = it.next()).done)
+        if (!deepEqualFn(i.value[1], b.get(i.value[0]), updatedAtomsSet))
+          return false;
+      return true;
+    }
+    if (hasSet && a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size)
+        return false;
+      it = a.entries();
+      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)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length;i-- !== 0; )
+        if (a[i] !== b[i])
+          return false;
+      return true;
+    }
+    if (a.constructor === RegExp)
+      return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === "function" && typeof b.valueOf === "function")
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString && typeof a.toString === "function" && typeof b.toString === "function")
+      return a.toString() === b.toString();
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length;i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    if (hasElementType && a instanceof Element)
+      return false;
+    for (i = length;i-- !== 0; ) {
+      if ((keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) {
+        continue;
+      }
+      if (!deepEqualFn(a[keys[i]], b[keys[i]], updatedAtomsSet))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+};
+var equal = (a, b, updatedAtomsSet) => {
+  try {
+    return deepEqualFn(a, b, updatedAtomsSet);
+  } catch (error) {
+    if ((error.message || "").match(/stack|recursion/i)) {
+      console.warn("react-fast-compare cannot handle circular refs");
+      return false;
+    }
+    throw error;
+  }
+};
+
+// src/utils/isAtom.ts
+var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+
+// src/utils/isFamilyState.ts
+var isFamilyState = (state) => state && Object.hasOwn(state, "family");
+
+// src/utils/isFamilyAtom.ts
+var isFamilyAtom = (state) => isFamilyState(state) && isAtom(state);
 
 // src/utils/isPromiseLike.ts
 var isPromiseLike = (object) => {
   return object && object.then && typeof object.then === "function";
 };
 
-// src/lib/updateStateSubscribers.ts
-var updateStateSubscribers = (state, data) => {
-  const subscribtions = data.subscriptions.get(state);
-  if (subscribtions?.size) {
-    for (const subscribtion of subscribtions) {
-      subscribtion.callback();
+// src/errors/lib/generateSelectorTrace.ts
+var generateSelectorTrace = (selectors) => {
+  const lastIndex = selectors.length - 1;
+  return [...selectors].reverse().map((selector, index) => {
+    const name = selector.name ?? "Anonymous Selector";
+    if (index === 0) {
+      return `[START] ${name}`;
+    } else if (index === lastIndex) {
+      return `[CRASH] ${name}`;
+    } else {
+      return `        ${" ".repeat(index)}${name}`;
     }
+  }).join(`
+`);
+};
+
+// src/errors/SelectorEvaluationError.ts
+class SelectorEvaluationError extends Error {
+  selectors;
+  constructor(cause) {
+    super();
+    this.cause = cause;
+    this.selectors = [];
+  }
+  track(selector) {
+    this.selectors.push(selector);
   }
-  if (state.family) {
-    const familySubscriptions = data.subscriptions.get(state.family);
-    if (familySubscriptions?.size) {
-      for (const subscribtion of familySubscriptions) {
-        subscribtion.callback(state.familyKey);
+  get message() {
+    const firstSelectorName = this.selectors[0].name ?? "Anonymous Selector";
+    return `Selector eval crashed in '${firstSelectorName}'
+${generateSelectorTrace(this.selectors)}`;
+  }
+}
+
+// src/utils/isAtomFamily.ts
+var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
+
+// src/utils/isSelector.ts
+var isSelector = (state) => state && Object.hasOwn(state, "get");
+
+// src/utils/isSelectorFamily.ts
+var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
+
+// src/lib/isFunction.ts
+var isFunction = (value) => typeof value === "function";
+
+// src/utils/deepFreeze.ts
+var deepFreeze = (obj, seen = new WeakSet) => {
+  if (obj === null || obj === undefined || seen.has(obj))
+    return obj;
+  if (obj && typeof obj === "object")
+    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/updateSelectorSubscribers.ts
-import equal3 from "fast-deep-equal";
+// src/lib/isProd.ts
+var isProd = () => {
+  return false;
+};
 
-// src/lib/initSelector.ts
-import equal2 from "fast-deep-equal";
+// src/lib/setValueInData.ts
+var setValueInData = (atom, value, data) => {
+  if (atom.mutable || isProd()) {
+    data.values.set(atom, value);
+    return value;
+  } else {
+    const frozenValue = deepFreeze(value);
+    data.values.set(atom, frozenValue);
+    return frozenValue;
+  }
+};
 
-// src/lib/getState.ts
-import equal from "fast-deep-equal";
+// src/lib/setAtom.ts
+var setAtom = (atom, newValue, data, skipOnSet = false) => {
+  const initializedAtomsSet = new Set;
+  const currentValue = getState(atom, data, initializedAtomsSet);
+  if (isFunction(newValue)) {
+    newValue = newValue(currentValue);
+    if (isPromiseLike(newValue) || isPromiseLike(currentValue))
+      throw new Error("Todo, how should we handle this?");
+  }
+  if (atom.equal(currentValue, newValue))
+    return newValue;
+  newValue = setValueInData(atom, newValue, data);
+  if (atom.onSet && !skipOnSet)
+    atom.onSet(newValue, data);
+  if (currentValue?.__isEmptyAtomPromise__) {
+    currentValue.__resolveEmptyAtomPromise__(newValue);
+  }
+  if (initializedAtomsSet.size > 0) {
+    const all = new Set([...initializedAtomsSet, atom]);
+    propagateUpdatedAtoms([...all], data);
+  } else {
+    propagateUpdatedAtoms([atom], data);
+  }
+  return newValue;
+};
 
 // src/lib/initAtom.ts
-var getAtomInitValue = (atom, data) => {
+var getAtomInitValue = (atom, data, initializedAtomsSet) => {
   if (atom.defaultValue === undefined) {
     let promiseResolve;
     const promise = new Promise((resolve) => {
@@ -47,45 +237,53 @@ var getAtomInitValue = (atom, data) => {
     const value = atom.defaultValue();
     if (isPromiseLike(value)) {
       value.then((resolvedValue) => {
-        data.values.set(atom, resolvedValue);
+        setValueInData(atom, resolvedValue, data);
         propagateUpdatedAtoms([atom], data);
       });
     }
     return value;
+  } else if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data, initializedAtomsSet);
   } else {
     return atom.defaultValue;
   }
 };
-var initAtom = (atom, data) => {
-  let value = getAtomInitValue(atom, data);
-  data.values.set(atom, value);
+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);
-  return value;
 };
 
-// src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
-
-// src/utils/isSelector.ts
-var isSelector = (state) => Object.hasOwn(state, "get");
-
-// src/utils/isFamily.ts
-var isFamily = (state) => Object.hasOwn(state, "_map");
-
 // src/lib/getState.ts
-function getState(state, data) {
+function getState(state, data, initializedAtomsSet, circularDependencySet) {
   if (data.values.has(state))
     return data.values.get(state);
-  if (isAtom(state))
-    return initAtom(state, data);
-  if (isSelector(state))
-    return initSelector(state, data);
-  if (isFamily(state)) {
-    const array = Array.from(state._map.keys());
+  if (isAtom(state)) {
+    if ("parent" in data)
+      return getState(state, data.parent, initializedAtomsSet, circularDependencySet);
+    initAtom(state, data, initializedAtomsSet);
+    initializedAtomsSet.add(state);
+    return data.values.get(state);
+  }
+  if (isSelector(state)) {
+    initSelector(state, data, initializedAtomsSet, circularDependencySet);
+    return data.values.get(state);
+  }
+  if (isAtomFamily(state)) {
+    if ("parent" in data) {
+      const closestData = findClosestStoreWithAtomInitialized(state, data);
+      return getState(state, closestData, initializedAtomsSet, circularDependencySet);
+    }
+    data.values.set(state, []);
+    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;
@@ -93,6 +291,13 @@ function getState(state, 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);
+};
 
 // src/lib/initSelector.ts
 class SuspendAndWaitForResolveError extends Error {
@@ -102,20 +307,22 @@ class SuspendAndWaitForResolveError extends Error {
     this.promise = promise;
   }
 }
-var getOrInitConsumersSet = (state, data) => {
-  const set = data.stateConsumers.get(state);
+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) => {
+var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencySet = new WeakSet) => {
   const updatedDependencies = new Set;
+  if (circularDependencySet.has(selector)) {}
+  circularDependencySet.add(selector);
   let result;
   try {
     result = selector.get((state) => {
-      const value = getState(state, data);
+      const value = getState(state, data, initializedAtomsSet, circularDependencySet);
       updatedDependencies.add(state);
       if (isPromiseLike(value))
         throw new SuspendAndWaitForResolveError(value);
@@ -124,19 +331,21 @@ var evaluateSelector = (selector, data) => {
   } catch (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);
+    const set = getOrInitDependentsSet(state, data);
     set.add(selector);
   }
   for (const state of removed) {
-    const set = getOrInitConsumersSet(state, data);
+    const set = getOrInitDependentsSet(state, data);
     set.delete(selector);
   }
   data.stateDependencies.set(selector, updatedDependencies);
@@ -144,248 +353,234 @@ var evaluateSelector = (selector, data) => {
 };
 var handleSelectorResult = (value, selector, data) => {
   if (value instanceof SuspendAndWaitForResolveError) {
-    value.promise.then(() => initSelector(selector, data));
+    value.promise.then(() => {
+      const initializedAtomsSet = new Set;
+      const res = initSelector(selector, data, initializedAtomsSet);
+      if (initializedAtomsSet.size > 0) {
+        propagateUpdatedAtoms([...initializedAtomsSet], data);
+      }
+      return res;
+    });
     return value.promise;
   } else if (isPromiseLike(value)) {
     value.then((resolved) => {
-      data.values.set(selector, resolved);
-      updateStateSubscribers(selector, data);
-      console.log("Should we reEvaluate?");
+      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);
+      }
     });
     return value;
   } else {
     return value;
   }
 };
-var initSelector = (selector, data) => {
-  const tmpValue = evaluateSelector(selector, data);
-  const value = handleSelectorResult(tmpValue, selector, data);
-  if (data.expiredValues.has(selector)) {
-    const expiredValue = data.expiredValues.get(selector);
-    if (equal2(expiredValue, value)) {
-      data.values.set(selector, expiredValue);
-      return expiredValue;
-    }
+var initSelector = (selector, data, initializedAtomsSet, circularDependencySet = new WeakSet) => {
+  const existingValue = data.values.get(selector);
+  const udpatedValue = evaluate(selector, data, initializedAtomsSet, circularDependencySet);
+  if (selector.equal(existingValue, udpatedValue)) {
+    return false;
+  } else {
+    setValueInData(selector, udpatedValue, data);
+    return true;
   }
-  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 (equal3(newValue, oldValue))
-        return;
-    } catch (e) {
-    }
+var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
+  let tmpValue;
+  try {
+    tmpValue = evaluateSelector(selector, data, initializedAtomsSet, circularDependencySet);
+  } catch (e) {
+    if (e instanceof SelectorEvaluationError)
+      e.track(selector);
+    throw e;
   }
-  if (subscribtions?.size) {
-    for (const subscribtion of subscribtions) {
-      subscribtion.callback();
+  return handleSelectorResult(tmpValue, selector, data);
+};
+
+// src/lib/propagateUpdatedAtoms.ts
+var reEvaluteSelector = (selector, data, updatedAtoms) => {
+  const existingValue = data.values.get(selector);
+  try {
+    const udpatedValue = evaluateSelector(selector, data, updatedAtoms);
+    if (selector.equal(existingValue, udpatedValue, updatedAtoms)) {
+      return [false, false];
+    } else {
+      setValueInData(selector, udpatedValue, data);
+      return [true, false];
     }
+  } catch (error) {
+    data.expiredValues.set(selector, data.values.get(selector));
+    data.values.delete(selector);
+    return [true, true, error];
   }
-  if (familySubscriptions?.size) {
-    for (const subscribtion of familySubscriptions) {
-      subscribtion.callback(selector.familyKey);
+};
+var addSetToSet = (fromSet, toSet) => {
+  if (fromSet && fromSet.size > 0) {
+    for (const item of fromSet) {
+      toSet.add(item);
     }
   }
 };
-
-// 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 findClosestStoreWithAtomInitialized2 = (atom, data) => {
+  if ("parent" in data === false)
+    return data;
+  if (data.values.has(atom))
+    return data;
+  return findClosestStoreWithAtomInitialized2(atom, data.parent);
+};
+var findInClosestStore = (state, data) => {
+  const store = findClosestStoreWithAtomInitialized2(state, data);
+  return store.values.get(state);
+};
+var addFamilyAtomsToSet = (family, familyAtoms, data) => {
+  const currentAtoms = findInClosestStore(family, data) || [];
+  const atomsToAdd = [];
+  for (const familyAtom of familyAtoms) {
+    if (!currentAtoms.includes(familyAtom)) {
+      atomsToAdd.push(familyAtom);
     }
   }
+  if (atomsToAdd.length > 0) {
+    data.values.set(family, [...currentAtoms, ...atomsToAdd]);
+  }
 };
-var propagateUpdatedAtoms = (atoms, data) => {
-  const clearedSelectors = new Set;
+var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false) => {
+  const selectors = new Set;
   for (const atom of atoms) {
-    const consumers = data.stateConsumers.get(atom);
-    if (consumers && consumers.size) {
-      recursivlyResetSelectorTree(consumers, data, clearedSelectors);
-    }
-    if (atom.family) {
-      const consumersFamily = data.stateConsumers.get(atom.family);
-      if (consumersFamily?.size) {
-        recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
+    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);
     }
   }
-  for (const selector of clearedSelectors) {
-    updateSelectorSubscribers(selector, data);
+  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);
+    }
   }
-  for (const atom of atoms) {
-    updateStateSubscribers(atom, data);
+  if (!isRecursive) {
+    propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
   }
 };
-
-// src/lib/setAtom.ts
-var setAtom = (atom, newValue, data, skipOnSet = false) => {
-  const currentValue = getState(atom, data);
-  if (typeof newValue === "function") {
-    newValue = newValue(currentValue);
-    if (isPromiseLike(newValue) || isPromiseLike(currentValue))
-      throw new Error("Todo, how should we handle this?");
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families) => {
+  const initialUpdatedAtoms = new Set(updatedAtoms);
+  const updatedInitializedAtoms = new Set(initialUpdatedAtoms);
+  if (selectors.size > 0) {
+    recursivlyHandleSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms);
   }
-  if (equal4(currentValue, newValue))
-    return;
-  data.values.set(atom, newValue);
-  if (atom.onSet && !skipOnSet)
-    atom.onSet(newValue, data);
-  if (currentValue?.__isEmptyAtomPromise__) {
-    currentValue.__resolveEmptyAtomPromise__(newValue);
+  const addedAtoms = initialUpdatedAtoms.symmetricDifference(updatedInitializedAtoms);
+  if (addedAtoms.size) {
+    console.log("addedAtoms", addedAtoms);
+    console.log("Valdres TODO: Support this case with new atoms added");
   }
-  propagateUpdatedAtoms([atom], data);
-};
-
-// src/atom.ts
-var globalAtom = (defaultValue, options) => {
-  const stores = new Set;
-  let value = defaultValue;
-  const onSet = (newValue, currentStore) => {
-    value = newValue;
-    if (stores.size > 1) {
-      for (const store of stores) {
-        if (store.id !== currentStore.id) {
-          setAtom(newAtom, value, store, true);
+  if (subscriptions.size > 0) {
+    for (const subscription of subscriptions) {
+      if ("state" in subscription) {
+        const updatedFamilyAtoms = families.get(subscription.state);
+        if (updatedFamilyAtoms) {
+          for (const atom of updatedFamilyAtoms) {
+            subscription.callback(...atom.familyArgs);
+          }
         }
+      } else {
+        subscription.callback();
       }
     }
-  };
-  const newAtom = {
-    defaultValue,
-    ...options,
-    onInit: (setSelf, store) => {
-      setSelf(value);
-      stores.add(store);
-    },
-    onSet,
-    label: options?.label
-  };
-  return newAtom;
-};
-var atom = (defaultValue, options) => {
-  if (!options)
-    return { defaultValue };
-  if (options.global)
-    return globalAtom(defaultValue, options);
-  return {
-    defaultValue,
-    ...options
-  };
-};
-// src/lib/stableStringify.ts
-var stableStringifyRecurse = (x, key) => {
-  if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
-    return `"${x}"`;
-  }
-  switch (typeof x) {
-    case "undefined":
-      return "";
-    case "boolean":
-      return x ? "true" : "false";
-    case "number":
-    case "symbol":
-      return String(x);
-    case "string":
-      return JSON.stringify(x);
-    case "function":
-      return `__FUNCTION(${x.toString()})__`;
   }
-  if (x === null) {
-    return "null";
-  }
-  if (typeof x !== "object") {
-    return JSON.stringify(x) ?? "";
-  }
-  if (isPromiseLike(x)) {
-    return "__PROMISE__";
-  }
-  if (Array.isArray(x)) {
-    return `[${x.map((v, i) => stableStringifyRecurse(v, i.toString()))}]`;
-  }
-  if (typeof x.toJSON === "function") {
-    return stableStringifyRecurse(x.toJSON(key), key);
-  }
-  if (x instanceof Map) {
-    const obj = {};
-    for (const [k, v] of x) {
-      obj[typeof k === "string" ? k : stringify(k, opt)] = v;
+};
+var recursivlyHandleSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, seen = new Set) => {
+  const selectorsForNextPass = new Set;
+  for (const selector of selectors) {
+    const currentValue = data.values.get(selector);
+    if (isPromiseLike(currentValue)) {
+      continue;
+    }
+    seen.add(selector);
+    const dependents = data.stateDependents.get(selector);
+    const subscribers = data.subscriptions.get(selector);
+    if ((!dependents || dependents.size === 0) && (!subscribers || subscribers.size === 0)) {
+      data.expiredValues.set(selector, data.values.get(selector));
+      data.values.delete(selector);
+    } else {
+      const [wasValueUpdated, didEvalCrash, error] = reEvaluteSelector(selector, data, updatedInitializedAtoms);
+      if (!wasValueUpdated)
+        continue;
+      addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
+      addSetToSet(subscribers, collectedSubscribers);
     }
-    return stableStringifyRecurse(obj, key);
-  }
-  if (x instanceof Set) {
-    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
   }
-  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
-    return stableStringifyRecurse(Array.from(x), key);
+  if (selectorsForNextPass.size > 0) {
+    recursivlyHandleSelectorUpdates(selectorsForNextPass, data, collectedSubscribers, updatedInitializedAtoms, seen);
   }
-  return `{${Object.keys(x).filter((k) => x[k] !== undefined).sort().map((k) => `${stableStringifyRecurse(k)}:${stableStringifyRecurse(x[k], k)}`).join(",")}}`;
-};
-var stableStringify = (x) => {
-  if (typeof x === "string" || typeof x === "boolean" || typeof x === "number")
-    return x;
-  return stableStringifyRecurse(x);
 };
 
-// src/atomFamily.ts
-var atomFamily = (defaultValue, debugLabel) => {
-  const map = new Map;
-  const atomFamily2 = (key, defaultOverride) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified)) {
-      return map.get(keyStringified);
-    }
-    const atomDebugLabel = debugLabel && debugLabel + "_" + keyStringified;
-    const newAtom = atom(typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue, {
-      label: atomDebugLabel
-    });
-    newAtom.family = atomFamily2;
-    newAtom.familyKey = Object.freeze(key);
-    map.set(keyStringified, newAtom);
-    return newAtom;
-  };
-  atomFamily2._map = map;
-  return atomFamily2;
-};
 // src/lib/createStoreData.ts
 var generateId = () => (Math.random() + 1).toString(36).substring(7);
-var createStoreData = (id = generateId()) => ({
-  id,
-  values: new WeakMap,
-  expiredValues: new WeakMap,
-  subscriptions: new WeakMap,
-  subscriptionsRequireEqualCheck: new WeakMap,
-  stateConsumers: new WeakMap,
-  stateDependencies: new WeakMap
-});
+var generateStoreData = (id = generateId()) => {
+  return {
+    id,
+    values: new WeakMap,
+    expiredValues: new WeakMap,
+    subscriptions: new WeakMap,
+    subscriptionsRequireEqualCheck: new WeakMap,
+    stateDependents: new WeakMap,
+    stateDependencies: new WeakMap,
+    scopes: {}
+  };
+};
+function createStoreData(id, parent) {
+  if (parent) {
+    return {
+      ...generateStoreData(id),
+      parent,
+      scopeConsumers: parent ? new Set : undefined
+    };
+  } else {
+    return generateStoreData(id);
+  }
+}
+
+// src/lib/deleteFamilyAtom.ts
+var deleteFamilyAtom = (atom, data) => {
+  const array = data.values.get(atom.family);
+  const index = array.indexOf(atom);
+  const newArray = [
+    ...array.slice(0, index),
+    ...array.slice(index + 1)
+  ];
+  data.values.delete(atom);
+  propagateUpdatedAtoms([atom], data);
+  setValueInData(atom.family, newArray, data);
+  propagateUpdatedAtoms([atom.family], data);
+};
 
 // src/lib/resetAtom.ts
-var resetAtom = (atom2, data) => {
-  const res = initAtom(atom2, data);
-  if (!isPromiseLike(res)) {
-    propagateUpdatedAtoms([atom2], data);
+var resetAtom = (atom, data) => {
+  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 res;
+  return value;
 };
 
+// src/utils/isFamily.ts
+var isFamily = (state) => isAtomFamily(state) || isSelectorFamily(state);
+
 // src/lib/unsubscribe.ts
-var unsubscribe = (state, subscription, data, mount) => {
+var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
   const subscribers = data.subscriptions.get(state);
   if (subscribers) {
     subscribers.delete(subscription);
@@ -401,6 +596,11 @@ var unsubscribe = (state, subscription, data, mount) => {
         data.subscriptionsRequireEqualCheck.delete(state);
       }
     }
+    if (subscribers.size === 0) {
+      if (maxAgeCleanup)
+        maxAgeCleanup();
+      data.subscriptions.delete(state);
+    }
     if (mount) {
       if (subscribers.size === mount.mountSubscriptions.size) {
         if (typeof mount.onUnmount === "function") {
@@ -418,12 +618,33 @@ var initSubscribers = (state, data) => {
   return set;
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
-  const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
+  let parentUnsubscribe;
+  if ("parent" in data && (!data.values.has(state) && isAtom(state) || isAtomFamily(state))) {
+    const originalCallback = callback;
+    parentUnsubscribe = subscribe(state, originalCallback, requireDeepEqualCheckBeforeCallback, data.parent);
+    callback = (arg) => {
+      if (parentUnsubscribe) {
+        parentUnsubscribe();
+        parentUnsubscribe = undefined;
+      }
+      originalCallback(arg);
+    };
+  } else if (!data.values.has(state) && isAtom(state)) {
+    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,
@@ -437,206 +658,667 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   }
   subscribers.add(subscription);
   let mount;
-  if (subscribers.size === 1 && 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
-    };
+  let maxAgeCleanup;
+  if (subscribers.size === 1) {
+    if (isAtom(state) && state.maxAge) {
+      let timeout;
+      const interval = setInterval(() => {
+        let value = getAtomInitValue(state, data);
+        if (isPromiseLike(value)) {
+          if (state.staleWhileRevalidate) {
+            const oldValue = data.values.get(state);
+            timeout = setTimeout(() => {
+              const nowValue = data.values.get(state);
+              console.log("todo", oldValue);
+            }, state.staleWhileRevalidate);
+            value.then((res) => clearTimeout(timeout));
+          }
+        } else {
+          setValueInData(state, value, data);
+          propagateUpdatedAtoms([state], data);
+        }
+      }, state.maxAge);
+      maxAgeCleanup = () => {
+        clearInterval(interval);
+        if (timeout)
+          clearTimeout(timeout);
+      };
+    }
+    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 (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state) !== true) {
     data.subscriptionsRequireEqualCheck.set(state, true);
   }
-  return () => unsubscribe(state, subscription, data, mount);
+  return () => {
+    if (parentUnsubscribe) {
+      parentUnsubscribe();
+    }
+    unsubscribe(state, subscription, data, mount, maxAgeCleanup);
+  };
 };
 
 // src/lib/setAtoms.ts
-import equal5 from "fast-deep-equal";
-var setAtoms = (pairs, data) => {
+var setAtoms = (pairs, data, initializedAtomsSet) => {
   const updatedAtoms = [];
-  for (let [atom2, value] of pairs) {
-    const currentValue = getState(atom2, data);
-    if (!equal5(currentValue, value)) {
-      updatedAtoms.push(atom2);
-      data.values.set(atom2, value);
+  for (let [atom, value] of pairs) {
+    const currentValue = getState(atom, data, initializedAtomsSet);
+    if (!atom.equal(currentValue, value)) {
+      updatedAtoms.push(atom);
+      value = setValueInData(atom, value, data);
+      if (atom.onSet)
+        atom.onSet(value, data);
     }
   }
-  propagateUpdatedAtoms(updatedAtoms, data);
+  const result = new Set([...updatedAtoms, ...initializedAtomsSet]);
+  if (result.size > 0) {
+    propagateUpdatedAtoms([...result], data);
+  }
 };
 
 // src/lib/transaction.ts
-var findDependencies = (state, data, result = new Set) => {
-  const 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) {
+    this.data = data;
+    this.parentTransaction = parentTransaction;
+    this.dirty = false;
   }
-};
-var transaction = (callback, data) => {
-  let txnAtomMap = new Map;
-  let txnSelectorCache = new Map;
-  let txnSubscribers = new Map;
-  let dirtySelectors = new Set;
-  const txnGet = (state) => {
-    if (isAtom(state)) {
-      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState(state, data);
+  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)) {
+      const value = this.valueFromTxnOrData(state);
+      if (value)
+        return value;
+      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 {
       throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom2, value) => {
-    if (!isAtom(atom2))
+  set = (atom, value) => {
+    if (!isAtom(atom))
       throw new Error("Not an atom");
-    if (typeof value === "function") {
-      const currentValue = txnGet(atom2);
+    if (isFunction(value)) {
+      const currentValue = this.get(atom);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom2, data)) {
-      dirtySelectors.add(selector);
-      txnSelectorCache.delete(selector);
+    if (isProd()) {
+      this.atomMap.set(atom, value);
+    } else {
+      this.atomMap.set(atom, deepFreeze(value));
+    }
+    if (!this.dirty)
+      this.dirty = true;
+    if (isFamilyAtom(atom)) {
+      const currentFamilyList = this.get(atom.family);
+      if (!currentFamilyList.includes(atom)) {
+        const newArr = [...currentFamilyList, atom];
+        this.atomMap.set(atom.family, newArr);
+      }
+    }
+    return value;
+  };
+  del = (atom) => {
+    const array = this.get(atom.family);
+    const index = array.indexOf(atom);
+    const newArr = [
+      ...array.slice(0, index),
+      ...array.slice(index + 1)
+    ];
+    this.atomMap.set(atom.family, newArr);
+    if (this.data.values.has(atom)) {
+      this.deleteSet.add(atom);
+    }
+    if (this.atomMap.has(atom)) {
+      this.atomMap.delete(atom);
     }
-    if (txnSubscribers.get(atom2)?.size) {
-      recursivlyResetTxnSelectorCache(atom2, txnSubscribers, txnSelectorCache);
+  };
+  scope = (scopeId, callback) => {
+    if (scopeId in this.data.scopes) {
+      return this.scopedTransaction(scopeId).execute(callback, false);
+    } else {
+      throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(this.data.scopes).join(", ")}`);
     }
-    txnAtomMap.set(atom2, value);
   };
-  const txnReset = (atom2) => {
-    const value = getAtomInitValue(atom2, data);
-    txnAtomMap.set(atom2, value);
+  reset = (atom) => {
+    const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
+    this.atomMap.set(atom, value);
     return value;
   };
-  const commit = () => {
-    setAtoms(txnAtomMap, data);
-    dirtySelectors.clear();
+  execute = (callback, autoCommit = true) => {
+    const result = callback(this);
+    if (autoCommit)
+      this.commit();
+    return result;
   };
-  const result = callback(txnSet, txnGet, txnReset, commit);
-  commit();
-  return result;
+  commit = () => {
+    const initializedAtomsSet = new Set;
+    setAtoms(this.atomMap, this.data, initializedAtomsSet);
+    if (this.deleteSet?.size) {
+      deleteAtomFamilyAtoms(this.deleteSet, this.data);
+    }
+    if (this._scopedTransactions) {
+      for (const scopedTxn of Object.values(this._scopedTransactions)) {
+        scopedTxn.commit();
+      }
+    }
+  };
+  get atomMap() {
+    if (!this._atomMap)
+      this._atomMap = new Map;
+    return this._atomMap;
+  }
+  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 = {};
+    if (!this._scopedTransactions[scopeId]) {
+      const scopedData = this.data.scopes[scopeId];
+      const scopedTransaction = new Transaction(scopedData, this);
+      this._scopedTransactions[scopeId] = scopedTransaction;
+    }
+    return this._scopedTransactions[scopeId];
+  }
+}
+var transaction = (callback, data) => {
+  const txn = new Transaction(data);
+  return txn.execute(callback);
 };
 
 // src/lib/storeFromStoreData.ts
-var storeFromStoreData = (data) => {
-  const get = (state) => getState(state, data);
+var SelectorProvidedToSetError = `Invalid state object passed to set().
+You provided a \`selector\`.
+Only \`atom\` cam be set.
+`;
+var InvalidStateSetError = `Invalid state object passed to set().
+Only \`atom\` can be set.
+`;
+function storeFromStoreData(data, detach) {
+  const get = (state) => {
+    const set2 = new Set;
+    const res = getState(state, data, set2);
+    if (set2.size) {
+      propagateUpdatedAtoms([...set2], data);
+    }
+    return res;
+  };
   const set = (state, value) => {
-    if (!isAtom(state))
-      throw new Error("Invalid state object");
-    return setAtom(state, value, data);
+    if (isAtom(state))
+      return setAtom(state, value, data);
+    if (isSelector(state))
+      throw new Error(SelectorProvidedToSetError);
+    throw new Error(InvalidStateSetError);
   };
-  const reset = (atom2) => resetAtom(atom2, data);
+  const reset = (atom) => resetAtom(atom, data);
+  const del = (atom) => deleteFamilyAtom(atom, data);
   const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
   const txn = (callback) => transaction(callback, data);
-  return {
-    get,
-    set,
-    sub,
-    txn,
-    reset,
-    data
+  const scope = (scopeId) => {
+    let scopedStoreData;
+    if (scopeId in data.scopes) {
+      scopedStoreData = data.scopes[scopeId];
+    } else {
+      scopedStoreData = createStoreData(scopeId, data);
+      data.scopes[scopeId] = scopedStoreData;
+    }
+    const detach2 = () => {
+      scopedStoreData.scopeConsumers.delete(detach2);
+      if (scopedStoreData.scopeConsumers.size === 0) {
+        delete data.scopes[scopeId];
+      }
+    };
+    scopedStoreData.scopeConsumers.add(detach2);
+    const newStore = storeFromStoreData(data.scopes[scopeId], detach2);
+    return newStore;
   };
-};
+  if (detach) {
+    return {
+      get,
+      set,
+      sub,
+      txn,
+      reset,
+      del,
+      data,
+      scope,
+      detach
+    };
+  } else {
+    return {
+      get,
+      set,
+      sub,
+      txn,
+      reset,
+      del,
+      data,
+      scope
+    };
+  }
+}
 
-// src/createStore.ts
-var createStore = (id) => {
+// src/store.ts
+var store = (id) => {
   const data = createStoreData(id);
   return storeFromStoreData(data);
 };
+
+// src/globalStore.ts
+var globalStore = Object.assign(store("valdres-global-store"), {
+  atoms: new Map,
+  atomFamilies: new Map
+});
+
+// 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);
+        }
+      }
+    }
+  };
+  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");
+      }
+      store2.values.delete(atom);
+      store2.expiredValues.delete(atom);
+      propagateUpdatedAtoms([atom], store2);
+      stores.delete(store2);
+      onReset?.();
+    }
+  };
+  const atom = {
+    equal,
+    ...options,
+    defaultValue,
+    name: options?.name,
+    onInit,
+    onSet,
+    setSelf,
+    getSelf,
+    resetSelf,
+    get stores() {
+      return stores;
+    }
+  };
+  return atom;
+};
+
+// src/atom.ts
+function atom(defaultValue, options) {
+  if (!options)
+    return { equal, defaultValue };
+  if (options.global) {
+    return globalAtom(defaultValue, options);
+  }
+  return {
+    equal,
+    defaultValue,
+    ...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("\\")) {
+    return `"${x}"`;
+  }
+  switch (typeof x) {
+    case "undefined":
+      return "";
+    case "boolean":
+      return x ? "true" : "false";
+    case "number":
+    case "symbol":
+      return String(x);
+    case "string":
+      return JSON.stringify(x);
+    case "function":
+      return `__FUNCTION(${x.toString()})__`;
+  }
+  if (x === null) {
+    return "null";
+  }
+  if (typeof x !== "object") {
+    return JSON.stringify(x) ?? "";
+  }
+  if (isPromiseLike(x)) {
+    return "__PROMISE__";
+  }
+  if (Array.isArray(x)) {
+    return `[${x.map((v, i) => stableStringifyRecurse(v, i.toString()))}]`;
+  }
+  if (typeof x.toJSON === "function") {
+    return stableStringifyRecurse(x.toJSON(key), key);
+  }
+  if (x instanceof Map) {
+    const obj = {};
+    for (const [k, v] of x) {
+      obj[typeof k === "string" ? k : stringify(k, opt)] = v;
+    }
+    return stableStringifyRecurse(obj, key);
+  }
+  if (x instanceof Set) {
+    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
+  }
+  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
+    return stableStringifyRecurse(Array.from(x), key);
+  }
+  return `{${Object.keys(x).filter((k) => x[k] !== undefined).sort().map((k) => `${stableStringifyRecurse(k)}:${stableStringifyRecurse(x[k], k)}`).join(",")}}`;
+};
+var stableStringify = (x) => {
+  if (typeof x === "string" || typeof x === "boolean" || typeof x === "number")
+    return x;
+  return stableStringifyRecurse(x);
+};
+
+// src/lib/stringifyFamilyArgs.ts
+var stringifyFamilyArgs = (args) => {
+  return args.length === 1 ? stableStringify(args[0]) : stableStringify(args);
+};
+
+// src/lib/createAtomFamily.ts
+var createOptions = (options = {}, family, familyArgs, familyArgsStringified) => {
+  if (options.name) {
+    return {
+      equal,
+      ...options,
+      name: options?.name + "_" + familyArgsStringified,
+      family,
+      familyArgs,
+      familyArgsStringified
+    };
+  } else {
+    return { equal, ...options, family, familyArgs, familyArgsStringified };
+  }
+};
+var handleDefaultValue = (defaultValue, ...args) => {
+  if (isSelectorFamily(defaultValue))
+    return defaultValue(...args);
+  if (typeof defaultValue === "function")
+    return () => defaultValue(...args);
+  return defaultValue;
+};
+var createAtomFamily = (defaultValue, options) => {
+  const map = new Map;
+  const atomFamily = (...args) => {
+    const argsStringified = stringifyFamilyArgs(args);
+    if (map.has(argsStringified)) {
+      return map.get(argsStringified);
+    }
+    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, ...args), createOptions(options, atomFamily, args, argsStringified));
+    map.set(argsStringified, familyAtom);
+    return familyAtom;
+  };
+  if (options?.name)
+    Object.defineProperty(atomFamily, "name", {
+      value: options.name,
+      writable: false
+    });
+  return Object.assign(atomFamily, {
+    __valdresAtomFamilyMap: map,
+    release: (...args) => map.delete(stringifyFamilyArgs(args)),
+    equal
+  });
+};
+
+// src/lib/createGlobalAtomFamily.ts
+var createGlobalAtomFamily = (defaultValue, options) => {
+  if (!options.name)
+    throw new Error(`Missing name for global atomFamiliy`);
+  if (globalStore.atomFamilies.has(options.name)) {
+    return globalStore.atomFamilies.get(options.name);
+  }
+  const family = createAtomFamily(defaultValue, options);
+  globalStore.atomFamilies.set(options.name, family);
+  return family;
+};
+
+// src/atomFamily.ts
+function atomFamily(defaultValue, options) {
+  if (options?.global)
+    return createGlobalAtomFamily(defaultValue, options);
+  return createAtomFamily(defaultValue, options);
+}
 // src/createStoreWithSelectorSet.ts
-var setSelector = (selector, values, store) => {
-  return selector.set(store.set, store.get, store.reset, ...values);
+var setSelector = (selector, values, store2) => {
+  return selector.set(store2.set, store2.get, store2.reset, ...values);
 };
 var createStoreWithSelectorSet = (id) => {
   const data = createStoreData(id);
-  const store = storeFromStoreData(data);
-  store.set = (state, value, ...rest) => {
+  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], store);
+      return setSelector(state, [value, ...rest], store2);
     throw new Error("Invalid state object");
   };
-  store.kind = "storeWithSelectorSet";
-  return store;
+  store2.kind = "storeWithSelectorSet";
+  return store2;
 };
-// src/getDefaultStore.ts
-if (!globalThis._valdresStore) {
-  globalThis._valdresStore = createStore("default");
-}
-var getDefaultStore = () => globalThis._valdresStore;
-var resetDefaultStore = () => globalThis._valdresStore = createStore();
 // src/selector.ts
-var selector = (get, debugLabel) => ({
-  get,
-  debugLabel
-});
+var selector = (get, options) => {
+  if (!options)
+    return { equal, get };
+  return { equal, ...options, get };
+};
+
+// 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;
+  };
+  return Object.assign(index2, {
+    map,
+    callback
+  });
+};
 // src/selectorFamily.ts
-var selectorFamily = (get, debugLabel) => {
+var createOptions2 = (options = {}, family, familyArgs, familyArgsStringified) => {
+  if (options.name) {
+    return {
+      equal,
+      ...options,
+      name: options?.name + "_" + familyArgsStringified,
+      family,
+      familyArgs,
+      familyArgsStringified
+    };
+  } else {
+    return { equal, ...options, family, familyArgs, familyArgsStringified };
+  }
+};
+var selectorFamily = (callback, options) => {
   const map = new Map;
-  const selectorFamily2 = (key) => {
-    let keyStringified;
-    try {
-      keyStringified = stableStringify(key);
-    } catch (e) {
-      console.log(`errro`, { key, debugLabel, e });
-      throw e;
-    }
-    if (map.has(keyStringified))
-      return map.get(keyStringified);
-    const selectorDebugLabel = debugLabel ? debugLabel + "_" + keyStringified : undefined;
-    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), selectorDebugLabel);
-    newSelector.family = selectorFamily2;
-    map.set(keyStringified, newSelector);
+  const selectorFamily2 = (...args) => {
+    const argsStringified = stringifyFamilyArgs(args);
+    if (map.has(argsStringified))
+      return map.get(argsStringified);
+    const newSelector = selector((selectorArgs) => callback(...args)(selectorArgs), createOptions2(options, selectorFamily2, args, argsStringified));
+    map.set(argsStringified, newSelector);
     return newSelector;
   };
-  selectorFamily2._map = map;
+  selectorFamily2.__valdresSelectorFamilyMap = map;
+  if (options?.name)
+    Object.defineProperty(selectorFamily2, "name", {
+      value: options.name,
+      writable: false
+    });
   return selectorFamily2;
 };
+// src/utils/isFamilySelector.ts
+var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
+
+// src/index.ts
+if (globalThis.__valdres__) {
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"0.2.0-pre.10"}`);
+} else {
+  globalThis.__valdres__ = "0.2.0-pre.10";
+}
 export {
+  store,
   selectorFamily,
   selector,
-  resetDefaultStore,
+  isSelectorFamily,
   isSelector,
   isPromiseLike,
+  isFamilyState,
+  isFamilySelector,
+  isFamilyAtom,
   isFamily,
+  isAtomFamily,
   isAtom,
-  getDefaultStore,
+  index,
+  globalStore,
+  deepFreeze,
   createStoreWithSelectorSet,
-  createStore,
   atomFamily,
   atom
 };