valdres 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/index.js

@@ -123,17 +123,18 @@ var isPromiseLike = (object) => {
 };
 
 // src/utils/deepFreeze.ts
-var deepFreeze = (obj, seen = new WeakSet) => {
+var deepFreeze = (obj, seen) => {
   if (obj === null || obj === undefined)
     return obj;
   if (typeof obj !== "object" && typeof obj !== "function")
     return obj;
-  if (seen.has(obj) || Object.isFrozen(obj))
+  if (Object.isFrozen(obj) || seen?.has(obj))
     return obj;
-  seen.add(obj);
   if (Array.isArray(obj)) {
     for (const item of obj) {
       if (item && typeof item === "object") {
+        seen ??= new WeakSet;
+        seen.add(obj);
         deepFreeze(item, seen);
       }
     }
@@ -142,6 +143,8 @@ var deepFreeze = (obj, seen = new WeakSet) => {
     for (const name of propNames) {
       const value = obj[name];
       if (value && typeof value === "object") {
+        seen ??= new WeakSet;
+        seen.add(obj);
         deepFreeze(value, seen);
       }
     }
@@ -149,10 +152,8 @@ var deepFreeze = (obj, seen = new WeakSet) => {
   return Object.freeze(obj);
 };
 
-// src/lib/isProd.ts
-var isProd = () => {
-  return false;
-};
+// src/lib/IS_PROD.ts
+var IS_PROD = typeof process !== "undefined" && process.env != null && process.env.NODE_ENV === "production";
 
 // src/lib/setValueInData.ts
 var trackScopeValue = (key, data) => {
@@ -172,7 +173,7 @@ var trackScopeValue = (key, data) => {
 var setValueInData = (atom, value, data) => {
   const isNewAtomInScope = data.parent && Object.hasOwn(atom, "defaultValue") && !data.values.has(atom);
   let written;
-  if (atom.mutable || isProd()) {
+  if (atom.mutable || IS_PROD) {
     data.values.set(atom, value);
     written = value;
   } else {
@@ -180,8 +181,14 @@ var setValueInData = (atom, value, data) => {
     data.values.set(atom, frozenValue);
     written = frozenValue;
   }
-  if (isNewAtomInScope)
+  if (isNewAtomInScope) {
     trackScopeValue(atom, data);
+    const subs = data.subscriptions.get(atom);
+    if (subs) {
+      for (const sub of subs)
+        sub.reRoot?.();
+    }
+  }
   if (atom.maxAge !== undefined) {
     data.lastValueWriteAt.set(atom, Date.now());
   }
@@ -275,8 +282,10 @@ var recursivelyUpdateIndexes = (data, family) => {
   const childScopesWithFamily = data.scopeValueIndex.get(family);
   if (!childScopesWithFamily || childScopesWithFamily.size === 0)
     return;
+  const parentIndex = data.values.get(family).__index;
   for (const scopedData of childScopesWithFamily) {
     const index = scopedData.values.get(family).__index;
+    index.parentIndex = parentIndex;
     index.rendered = null;
     index.renderedArray = null;
     scopedData.values.set(family, renderAtomFamilyIndex(index));
@@ -672,7 +681,7 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now()) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now(), evaluatedSelectors) => {
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
@@ -693,7 +702,7 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, false, evaluatedSelectors);
   if (families.size > 0 && data.scopes && data.scopes.size > 0) {
     const scopeFamilies = new Map;
     for (const family of families.keys()) {
@@ -710,11 +719,11 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       }
     }
     for (const [scope, familiesInScope] of scopeFamilies) {
-      propagateInScope(familiesInScope, scope);
+      propagateInScope(familiesInScope, scope, false, evaluatedSelectors);
     }
   }
 };
-var propagateAtomUpdate = (atoms, data, isInitOnly = false) => {
+var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
   if (atoms.length === 1) {
     const atom = atoms[0];
     if (!isFamilyAtom(atom) && !isAtomFamily(atom)) {
@@ -751,30 +760,37 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false) => {
       addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly);
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly);
+    for (const atom of atoms) {
+      if (isAtomFamily(atom) && !families.has(atom)) {
+        recursivelyUpdateIndexes(data, atom);
+      }
+    }
+  }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, evaluatedSelectors);
+  if (data.scopes && data.scopes.size > 0) {
+    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
   }
 };
-var propagateInScope = (atoms, data, isInitOnly = false) => {
+var propagateInScope = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
   const subscriptions = new Set;
   const families = new Map;
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly);
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, evaluatedSelectors);
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly);
+    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
   }
 };
-var propagateToScopes = (atoms, data, isInitOnly) => {
+var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
   if (atoms.length === 1) {
     const atom = atoms[0];
     const shadowingScopes = isAtomFamily(atom) ? undefined : data.scopeValueIndex.get(atom);
     for (const [, scope] of data.scopes) {
       if (!shadowingScopes || !shadowingScopes.has(scope)) {
-        propagateInScope(atoms, scope, isInitOnly);
+        propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
       }
     }
     return;
@@ -794,7 +810,7 @@ var propagateToScopes = (atoms, data, isInitOnly) => {
   }
   if (!anyShadowed) {
     for (const [, scope] of data.scopes) {
-      propagateInScope(atoms, scope, isInitOnly);
+      propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
     }
     return;
   }
@@ -811,20 +827,20 @@ var propagateToScopes = (atoms, data, isInitOnly) => {
       }
     }
     if (atomsToUpdateInScope.length > 0) {
-      propagateInScope(atomsToUpdateInScope, scope, isInitOnly);
+      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, evaluatedSelectors);
     }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false) => {
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, evaluatedSelectors) => {
   const updatedInitializedAtoms = new Set(updatedAtoms);
   if (selectors.size > 0) {
-    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly);
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
   }
   if (subscriptions.size > 0) {
     callSubscribers(subscriptions, families);
   }
 };
-var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly) => {
+var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors) => {
   const closure = new Set(seeds);
   {
     const stack = [...seeds];
@@ -857,13 +873,22 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       ready.push(s);
   }
   const needsEval = new Set(seeds);
+  let graphMutated = false;
   const advance = (selector, propagateChange) => {
     const downstream = data.stateDependents.get(selector);
     if (!downstream)
       return;
     for (const d of downstream) {
-      if (!closure.has(d))
+      if (!closure.has(d)) {
+        if (propagateChange) {
+          graphMutated = true;
+          closure.add(d);
+          pending.set(d, 0);
+          needsEval.add(d);
+          ready.push(d);
+        }
         continue;
+      }
       const c = (pending.get(d) ?? 0) - 1;
       pending.set(d, c);
       if (propagateChange)
@@ -876,6 +901,10 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
   let head = 0;
   while (head < ready.length) {
     const selector = ready[head++];
+    if (evaluatedSelectors !== undefined && evaluatedSelectors.has(selector)) {
+      advance(selector, false);
+      continue;
+    }
     const currentValue = data.values.get(selector);
     if (isPromiseLike(currentValue) && isInitOnly) {
       advance(selector, false);
@@ -895,19 +924,24 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     depsChange.added = undefined;
     depsChange.removed = undefined;
     const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+    if (evaluatedSelectors !== undefined)
+      evaluatedSelectors.add(selector);
     const added = depsChange.added;
     const removed = depsChange.removed;
-    if ((added || removed) && isLive(selector, data)) {
-      if (added) {
-        for (const dep of added) {
-          onLiveDependencyAdded(dep, data);
-          mountTransitiveDeps(dep, data);
+    if (added || removed) {
+      graphMutated = true;
+      if (isLive(selector, data)) {
+        if (added) {
+          for (const dep of added) {
+            onLiveDependencyAdded(dep, data);
+            mountTransitiveDeps(dep, data);
+          }
         }
-      }
-      if (removed) {
-        for (const dep of removed) {
-          onLiveDependencyRemoved(dep, data);
-          unmountOrphanedDeps(dep, data);
+        if (removed) {
+          for (const dep of removed) {
+            onLiveDependencyRemoved(dep, data);
+            unmountOrphanedDeps(dep, data);
+          }
         }
       }
     }
@@ -916,13 +950,74 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       addSetToSet(subscribers, collectedSubscribers);
     }
   }
+  if (!graphMutated)
+    return;
+  let stranded;
+  for (const s of closure) {
+    if (needsEval.has(s) && (pending.get(s) ?? 0) > 0) {
+      if (!stranded)
+        stranded = new Set;
+      stranded.add(s);
+    }
+  }
+  if (!stranded)
+    return;
+  let work = stranded;
+  while (work.size > 0) {
+    const next = new Set;
+    for (const selector of work) {
+      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);
+        continue;
+      }
+      depsChange.added = undefined;
+      depsChange.removed = undefined;
+      const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+      if (evaluatedSelectors !== undefined)
+        evaluatedSelectors.add(selector);
+      const added = depsChange.added;
+      const removed = depsChange.removed;
+      if ((added || removed) && isLive(selector, data)) {
+        if (added) {
+          for (const dep of added) {
+            onLiveDependencyAdded(dep, data);
+            mountTransitiveDeps(dep, data);
+          }
+        }
+        if (removed) {
+          for (const dep of removed) {
+            onLiveDependencyRemoved(dep, data);
+            unmountOrphanedDeps(dep, data);
+          }
+        }
+      }
+      if (wasValueUpdated) {
+        if (subscribers)
+          addSetToSet(subscribers, collectedSubscribers);
+        const downstream = data.stateDependents.get(selector);
+        if (downstream) {
+          for (const d of downstream)
+            next.add(d);
+        }
+      }
+    }
+    work = next;
+  }
 };
-var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false, evaluatedSelectors) => {
   if (selectors.size === 0)
     return;
   let downstreamSeeds;
   const depsChange = {};
   for (const selector of selectors) {
+    if (evaluatedSelectors !== undefined && evaluatedSelectors.has(selector)) {
+      continue;
+    }
     const currentValue = data.values.get(selector);
     if (isPromiseLike(currentValue) && isInitOnly)
       continue;
@@ -935,6 +1030,8 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     depsChange.added = undefined;
     depsChange.removed = undefined;
     const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
+    if (evaluatedSelectors !== undefined)
+      evaluatedSelectors.add(selector);
     const added = depsChange.added;
     const removed = depsChange.removed;
     if ((added || removed) && isLive(selector, data)) {
@@ -964,7 +1061,7 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     }
   }
   if (downstreamSeeds && downstreamSeeds.size > 0) {
-    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly);
+    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
   }
 };
 
@@ -1504,14 +1601,18 @@ var installMaxAgeTimer = (state, data) => {
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
   let parentUnsubscribe;
+  let dropDelegate;
   if (data.parent && (!data.values.has(state) && isAtom(state) || isAtomFamily(state))) {
     const originalCallback = callback;
     parentUnsubscribe = subscribe(state, originalCallback, requireDeepEqualCheckBeforeCallback, data.parent);
-    callback = (arg) => {
+    dropDelegate = () => {
       if (parentUnsubscribe) {
         parentUnsubscribe();
         parentUnsubscribe = undefined;
       }
+    };
+    callback = (arg) => {
+      dropDelegate();
       originalCallback(arg);
     };
   } else if (!data.values.has(state) && isAtom(state)) {
@@ -1533,12 +1634,14 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
     subscription = {
       callback,
       state,
-      requireDeepEqualCheckBeforeCallback
+      requireDeepEqualCheckBeforeCallback,
+      reRoot: dropDelegate
     };
   } else {
     subscription = {
       callback,
-      requireDeepEqualCheckBeforeCallback
+      requireDeepEqualCheckBeforeCallback,
+      reRoot: dropDelegate
     };
   }
   subscribers.add(subscription);
@@ -1562,8 +1665,8 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   };
 };
 
-// src/lib/setAtoms.ts
-var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
+// src/lib/writeAtoms.ts
+var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueue) => {
   const updatedAtoms = [];
   for (let [atom, value] of pairs) {
     const currentValue = getState(atom, data, initializedAtomsSet);
@@ -1571,8 +1674,12 @@ var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
     if (!areEqual) {
       updatedAtoms.push(atom);
       value = setValueInData(atom, value, data);
-      if (atom.onSet && !skipOnSet)
-        atom.onSet(value, data);
+      if (atom.onSet && !skipOnSet) {
+        if (onSetQueue)
+          onSetQueue.push([atom, value, data]);
+        else
+          atom.onSet(value, data);
+      }
     } else {
       setValueInData(atom, value, data);
     }
@@ -1582,6 +1689,12 @@ var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
       updatedAtoms.push(atom);
     }
   }
+  return updatedAtoms;
+};
+
+// src/lib/setAtoms.ts
+var setAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false) => {
+  const updatedAtoms = writeAtoms(pairs, data, initializedAtomsSet, skipOnSet);
   if (updatedAtoms.length > 0) {
     propagateAtomUpdate(updatedAtoms, data);
   }
@@ -1671,7 +1784,7 @@ class Transaction {
     } else {
       resolved = value;
     }
-    if (!atom.mutable && !isProd() && resolved !== null && (typeof resolved === "object" || typeof resolved === "function")) {
+    if (!atom.mutable && !IS_PROD && resolved !== null && (typeof resolved === "object" || typeof resolved === "function")) {
       resolved = deepFreeze(resolved);
     }
     this._atomMap.set(atom, resolved);
@@ -1761,15 +1874,58 @@ class Transaction {
     }
   };
   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) {
+      const initializedAtomsSet = new Set;
+      if (this._deleteSet?.size) {
+        const evaluatedSelectors2 = new Set;
+        const updatedAtoms = writeAtoms(this._atomMap, this.data, initializedAtomsSet);
+        if (updatedAtoms.length > 0) {
+          propagateAtomUpdate(updatedAtoms, this.data, false, evaluatedSelectors2);
+        }
+        deleteAtomFamilyAtoms(this._deleteSet, this.data);
+        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, evaluatedSelectors2);
+      } else {
+        setAtoms(this._atomMap, this.data, initializedAtomsSet);
+      }
+      return;
+    }
+    const plan = [];
+    this.collectStores(plan);
+    for (let i = plan.length - 1;i >= 0; i--) {
+      const entry = plan[i];
+      const txn = entry.txn;
+      entry.updatedAtoms = writeAtoms(txn._atomMap, entry.data, new Set, false, entry.onSets);
+      if (txn._deleteSet?.size) {
+        deleteAtomFamilyAtoms(txn._deleteSet, entry.data);
+        entry.deleted = [...txn._deleteSet];
+      }
     }
+    for (const entry of plan) {
+      for (const [atom, value, data] of entry.onSets) {
+        atom.onSet(value, data);
+      }
+    }
+    const evaluatedSelectors = new Set;
+    for (const { data, updatedAtoms, deleted } of plan) {
+      if (updatedAtoms.length > 0) {
+        propagateAtomUpdate(updatedAtoms, data, false, evaluatedSelectors);
+      }
+      if (deleted) {
+        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, evaluatedSelectors);
+      }
+    }
+  };
+  collectStores = (plan) => {
+    plan.push({
+      txn: this,
+      data: this.data,
+      updatedAtoms: [],
+      deleted: undefined,
+      onSets: []
+    });
     if (this._scopedTransactions) {
       for (const [, scopedTxn] of this._scopedTransactions) {
-        scopedTxn.commit();
+        scopedTxn.collectStores(plan);
       }
     }
   };
@@ -2592,9 +2748,9 @@ var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 
 // src/index.ts
 if (globalThis.__valdres__) {
-  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.4"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.5"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.4";
+  globalThis.__valdres__ = "1.0.0-beta.5";
 }
 export {
   store,

package/dist/types/lib/IS_PROD.d.ts

@@ -0,0 +1 @@
+export declare const IS_PROD: boolean;

package/dist/types/lib/atomFamilyIndex.d.ts

@@ -14,4 +14,5 @@ export type AtomFamilyIndex = {
 export declare const cloneAtomFamilyIndex: (index: AtomFamilyIndex, parentIndexOverride?: AtomFamilyIndex) => AtomFamilyIndex;
 export declare const createAtomFamilyIndex: (parentIndex?: AtomFamilyIndex) => AtomFamilyIndex;
 export declare const deleteFamilyAtomsFromSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: number) => void;
+export declare const recursivelyUpdateIndexes: (data: StoreData, family: Family<any>) => void;
 export declare const addFamilyAtomsToSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: number) => void;

package/dist/types/lib/propagateUpdatedAtoms.d.ts

@@ -7,7 +7,7 @@ import type { Subscription } from "../types/Subscription";
 export type { AtomFamilyIndex, } from "./atomFamilyIndex";
 export { cloneAtomFamilyIndex, createAtomFamilyIndex, renderAtomFamilyIndex, } from "./atomFamilyIndex";
 type AtomInput = Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>;
-export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number) => void;
-export declare const propagateAtomUpdate: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean) => void;
-export declare const propagateInScope: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean) => void;
-export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isInitOnly?: boolean) => void;
+export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number, evaluatedSelectors?: Set<Selector>) => void;
+export declare const propagateAtomUpdate: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, evaluatedSelectors?: Set<Selector>) => void;
+export declare const propagateInScope: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, evaluatedSelectors?: Set<Selector>) => void;
+export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isInitOnly?: boolean, evaluatedSelectors?: Set<Selector>) => void;

package/dist/types/lib/transaction.d.ts

@@ -26,6 +26,7 @@ export declare class Transaction {
     execute: (callback: TransactionFn, autoCommit?: boolean) => any;
     private txnCommit;
     commit: () => void;
+    private collectStores;
     private get selectorCache();
     private get selectorDependencies();
     private get deleteSet();

package/dist/types/lib/writeAtoms.d.ts

@@ -0,0 +1,21 @@
+import type { Atom } from "../types/Atom";
+import type { StoreData } from "../types/StoreData";
+/** A deferred onSet invocation: the hook, the written value, and the store it
+ *  was written to. Collected during the write phase of a cross-scope commit so
+ *  hooks fire only once the whole tree has been written. */
+export type DeferredOnSet = [Atom<any>, any, StoreData];
+/**
+ * Write phase for a single store. Applies every value in `pairs` to
+ * `data.values`, returning the atoms whose value actually changed (the
+ * propagation set), merged with any atoms lazily initialized during the
+ * equality checks. This does NOT propagate — see `setAtoms` (single-store
+ * fast path) or `Transaction.commit` (cross-scope path) for the notify pass.
+ *
+ * onSet handling:
+ *  - `skipOnSet` true     → never fire onSet.
+ *  - `onSetQueue` given    → defer onSet by pushing `[atom, value, data]`. The
+ *    cross-scope commit uses this so a hook never observes a half-applied
+ *    transaction — it fires only after every store's writes have landed.
+ *  - otherwise             → fire onSet inline (single-store path, unchanged).
+ */
+export declare const writeAtoms: (pairs: Map<Atom<any>, any>, data: StoreData, initializedAtomsSet: Set<Atom>, skipOnSet?: boolean, onSetQueue?: DeferredOnSet[]) => Atom[];

package/dist/types/types/Subscription.d.ts

@@ -3,9 +3,16 @@ export type AtomFamilySubscription<Value extends any = any, Args extends [any, .
     state: AtomFamily<Value, Args>;
     callback: (...args: Args) => void;
     requireDeepEqualCheckBeforeCallback: boolean;
+    /** Present only on a scope subscription that is delegating to an ancestor.
+     *  Drops the ancestor delegate (idempotent). Called eagerly when the scope
+     *  shadows the state so an ancestor write in the same transaction commit
+     *  does not also notify this subscription. */
+    reRoot?: () => void;
 };
 export type SimpleSubscription = {
     requireDeepEqualCheckBeforeCallback: boolean;
     callback: () => void;
+    /** See AtomFamilySubscription.reRoot. */
+    reRoot?: () => void;
 };
 export type Subscription = SimpleSubscription | AtomFamilySubscription;

package/dist/types/utils/deepFreeze.d.ts

@@ -1 +1 @@
-export declare const deepFreeze: (obj: any, seen?: WeakSet<WeakKey>) => any;
+export declare const deepFreeze: (obj: any, seen?: WeakSet<object>) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "1.0.0-beta.4",
+    "version": "1.0.0-beta.5",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"

package/dist/types/lib/isProd.d.ts

@@ -1 +0,0 @@
-export declare const isProd: () => boolean;