valdres 1.0.0-beta.14 → 1.0.0-beta.15

package/dist/index.js

@@ -112,15 +112,15 @@ var equal = (a, b, updatedAtomsSet) => {
   }
 };
 
+// src/utils/isSelector.ts
+var isSelector = (state) => state && Object.hasOwn(state, "get");
+
 // src/utils/isAtom.ts
 var isAtom = (state) => state && Object.hasOwn(state, "defaultValue");
 
 // src/utils/isGlobalAtom.ts
 var isGlobalAtom = (state) => 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");
 
@@ -346,6 +346,14 @@ ${generateSelectorTrace(this.selectors)}`;
   }
 }
 
+// src/lib/noteDependencyGraphChanged.ts
+var noteDependencyGraphChanged = (selector, data) => {
+  if (!data.dependencyOrder.has(selector)) {
+    data.dependencyOrder.set(selector, data.nextDependencyOrder++);
+  }
+  data.dependencyGraphVersion++;
+};
+
 // src/lib/asyncDependencyTracking.ts
 var pendingAsyncDeps = new WeakMap;
 
@@ -375,6 +383,7 @@ var lateGet = (state, selector, data) => {
   }
   const isNewDep = !deps.has(state);
   if (isNewDep) {
+    noteDependencyGraphChanged(selector, data);
     deps.add(state);
     const dependents = getOrInitDependentsSet(state, data);
     dependents.add(selector);
@@ -812,6 +821,7 @@ var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencyS
       depsChanged = true;
     }
     if (depsChanged || !currentDependencies) {
+      noteDependencyGraphChanged(selector, data);
       if (data.livenessPassActive && currentDependencies) {
         (data.livenessSeeds ??= new Set).add(selector);
         if (!depsChangeOut)
@@ -901,8 +911,13 @@ var handleSelectorResult = (value, selector, data) => {
         const currentDeps = data.stateDependencies.get(selector);
         if (currentDeps) {
           const selectorIsLive = isLive(selector, data);
+          let graphChangeNoted = false;
           for (const dep of currentDeps) {
             if (!evalDeps.has(dep)) {
+              if (!graphChangeNoted) {
+                noteDependencyGraphChanged(selector, data);
+                graphChangeNoted = true;
+              }
               currentDeps.delete(dep);
               const dependents2 = data.stateDependents.get(dep);
               if (dependents2)
@@ -1773,8 +1788,12 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
   }
   let syncValue = validateSchema(atom, newValue, data);
   const areEqual = isPromiseLike(currentValue) ? currentValue === syncValue : atom.equal(currentValue, syncValue);
-  if (areEqual)
+  if (areEqual) {
+    if (data.parent && !data.values.has(atom)) {
+      return setValueInData(atom, syncValue, data);
+    }
     return syncValue;
+  }
   syncValue = setValueInData(atom, syncValue, data);
   if (atom.onSet && !skipOnSet)
     atom.onSet(syncValue, data);
@@ -2040,6 +2059,10 @@ Object.defineProperties(lazyProto, {
   subscriptionsRequireEqualCheck: makeLazyGetter("subscriptionsRequireEqualCheck"),
   stateDependents: makeLazyGetter("stateDependents"),
   stateDependencies: makeLazyGetter("stateDependencies"),
+  dependencyOrder: makeLazyGetter("dependencyOrder"),
+  cycleRiskInClosure: makeLazyGetter("cycleRiskInClosure"),
+  acyclicDependencyVersion: makeLazyGetter("acyclicDependencyVersion"),
+  orphanCleanupVersion: makeLazyGetter("orphanCleanupVersion"),
   mounts: makeLazyGetter("mounts"),
   liveDependentCount: makeLazyGetter("liveDependentCount"),
   mountInClosure: makeLazyGetter("mountInClosure"),
@@ -2055,6 +2078,10 @@ function createStoreData(id, parent, options) {
   if (enumerable)
     data.enumerable = true;
   data.values = enumerable ? new Map : new WeakMap;
+  data.nextDependencyOrder = 0;
+  data.dependencyGraphVersion = 0;
+  data.pendingOrphanCleanup = undefined;
+  data.orphanCleanupScheduled = false;
   data.scopes = new Map;
   data.scopeValueIndex = new WeakMap;
   data.pendingDefaults = new WeakMap;
@@ -2085,6 +2112,56 @@ var deleteFamilyAtom = (atom, data) => {
   propagateDeletedAtoms([atom], data, undefined, undefined, undefined, undefined, "delete");
 };
 
+// src/lib/cleanupOrphanedDeps.ts
+var cleanupOrphanedDeps = (state, data) => {
+  if (isLive(state, data))
+    return;
+  const graphVersion = data.dependencyGraphVersion;
+  const cleanedAtVersion = data.orphanCleanupVersion;
+  if (cleanedAtVersion.get(state) === graphVersion)
+    return;
+  const stack = [state];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (cleanedAtVersion.get(current) === graphVersion)
+      continue;
+    if (isLive(current, data))
+      continue;
+    cleanedAtVersion.set(current, graphVersion);
+    const dependents = data.stateDependents.get(current);
+    const deps = data.stateDependencies.get(current);
+    if (deps) {
+      for (const dep of deps) {
+        data.stateDependents.get(dep)?.delete(current);
+      }
+      data.stateDependencies.delete(current);
+      data.values.delete(current);
+      data.abortControllers.delete(current);
+      if (dependents) {
+        for (const dependent of dependents)
+          stack.push(dependent);
+      }
+      for (const dep of deps)
+        stack.push(dep);
+      continue;
+    }
+    if (dependents) {
+      for (const dependent of dependents)
+        stack.push(dependent);
+    }
+  }
+};
+
+// src/lib/flushPendingOrphanCleanup.ts
+var flushPendingOrphanCleanup = (data) => {
+  const pending = data.pendingOrphanCleanup;
+  if (!pending)
+    return;
+  data.pendingOrphanCleanup = undefined;
+  for (const state of pending)
+    cleanupOrphanedDeps(state, data);
+};
+
 // src/lib/onStoreChange.ts
 var onStoreChange = (callback, data, options) => {
   const atoms = options?.atoms ?? true;
@@ -2186,6 +2263,26 @@ var deleteMaxAgeCleanup = (data, state) => {
   maxAgeCleanups.get(data)?.delete(state);
 };
 
+// src/lib/queueOrphanCleanup.ts
+var queueOrphanCleanup = (state, data) => {
+  if (!data.stateDependencies.has(state) && !data.stateDependents.get(state)?.size) {
+    return;
+  }
+  let pending = data.pendingOrphanCleanup;
+  if (!pending) {
+    pending = new Set;
+    data.pendingOrphanCleanup = pending;
+  }
+  pending.add(state);
+  if (data.orphanCleanupScheduled)
+    return;
+  data.orphanCleanupScheduled = true;
+  queueMicrotask(() => {
+    data.orphanCleanupScheduled = false;
+    flushPendingOrphanCleanup(data);
+  });
+};
+
 // src/lib/unsubscribe.ts
 var unsubscribe = (state, subscription, data) => {
   const subscribers = data.subscriptions.get(state);
@@ -2211,49 +2308,12 @@ var unsubscribe = (state, subscription, data) => {
       }
       data.subscriptions.delete(state);
       onLastDirectSubscriber(state, data);
-      if (isSelector(state) && regionHasCycle(new Set([state]), data)) {
+      if (isSelector(state) && data.cycleRiskInClosure.has(state) && regionHasCycle(state, data)) {
         reconcileLivenessAfterChurn(new Set([state]), data);
       }
-      unmountOrphanedDeps(state, data);
-      cleanupOrphanedDeps(state, data);
-    }
-  }
-};
-var cleanupOrphanedDeps = (state, data) => {
-  const visited = new Set;
-  const stack = [state];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (visited.has(current))
-      continue;
-    visited.add(current);
-    if (isLive(current, data))
-      continue;
-    const dependents = data.stateDependents.get(current);
-    const deps = data.stateDependencies.get(current);
-    if (deps) {
-      for (const dep of deps) {
-        const depDependents = data.stateDependents.get(dep);
-        if (depDependents) {
-          depDependents.delete(current);
-        }
-      }
-      data.stateDependencies.delete(current);
-      data.values.delete(current);
-      data.abortControllers.delete(current);
-      if (dependents) {
-        for (const dep of dependents) {
-          stack.push(dep);
-        }
-      }
-      for (const dep of deps) {
-        stack.push(dep);
-      }
-      continue;
-    }
-    if (dependents) {
-      for (const dep of dependents) {
-        stack.push(dep);
+      if (!isLive(state, data)) {
+        unmountOrphanedDeps(state, data);
+        queueOrphanCleanup(state, data);
       }
     }
   }
@@ -3032,6 +3092,8 @@ function storeFromStoreData(data, detach) {
     return _pendingTxn;
   };
   const getDefault = (state) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (data.values.has(state)) {
       if (!isCachedValueStale(state, data)) {
         return data.values.get(state);
@@ -3064,12 +3126,16 @@ function storeFromStoreData(data, detach) {
   };
   const getBatched = (state) => {
     if (_pendingTxn) {
+      if (data.pendingOrphanCleanup)
+        flushPendingOrphanCleanup(data);
       return _pendingTxn.get(state);
     }
     return getDefault(state);
   };
   const get = data.batchUpdates ? getBatched : getDefault;
   const setDefault = (state, value) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (isAtom(state))
       return setAtom(state, value, data);
     if (isSelector(state))
@@ -3077,6 +3143,8 @@ function storeFromStoreData(data, detach) {
     throw new Error(InvalidStateSetError);
   };
   const setBatched = (state, value) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (isAtom(state)) {
       return ensurePendingTxn().set(state, value);
     }
@@ -3086,29 +3154,45 @@ function storeFromStoreData(data, detach) {
   };
   const set = data.batchUpdates ? setBatched : setDefault;
   const reset = (atom) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (data.batchUpdates)
       flushPendingTxn();
     return resetAtom(atom, data);
   };
   const del = (atom) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (data.batchUpdates)
       flushPendingTxn();
     return deleteFamilyAtom(atom, data);
   };
   const unset = (atom) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (data.batchUpdates)
       flushPendingTxn();
     return unsetValue(atom, data);
   };
-  const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
+  const sub = (state, callback, deepEqualCheckBeforeCallback = true) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
+    return subscribe(state, callback, deepEqualCheckBeforeCallback, data);
+  };
   const txn = (callback, name) => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
     if (data.batchUpdates)
       flushPendingTxn();
     return transaction(callback, data, name);
   };
   const onChange = (callback, options) => onStoreChange(callback, data, options);
   const storeOnCommitEnd = (callback) => onCommitEnd(callback, data);
-  const storeSnapshot = () => snapshot(data);
+  const storeSnapshot = () => {
+    if (data.pendingOrphanCleanup)
+      flushPendingOrphanCleanup(data);
+    return snapshot(data);
+  };
   const scope = (scopeId, callback) => {
     if (callback) {
       if (!data.scopes.has(scopeId)) {
@@ -3212,7 +3296,30 @@ var propagateMountMarkerUp = (state, data) => {
     }
   }
 };
+var propagateCycleRiskUp = (state, data) => {
+  if (data.cycleRiskInClosure.has(state))
+    return;
+  data.cycleRiskInClosure.set(state, true);
+  const stack = [state];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const parents = data.stateDependents.get(current);
+    if (!parents)
+      continue;
+    for (const parent of parents) {
+      if (data.cycleRiskInClosure.has(parent))
+        continue;
+      data.cycleRiskInClosure.set(parent, true);
+      stack.push(parent);
+    }
+  }
+};
 var noteDependencyAdded = (selector, dep, data) => {
+  const selectorOrder = data.dependencyOrder.get(selector);
+  const depOrder = data.dependencyOrder.get(dep);
+  if (data.cycleRiskInClosure.has(dep) || selectorOrder === undefined || isSelector(dep) && (depOrder === undefined || depOrder >= selectorOrder)) {
+    propagateCycleRiskUp(selector, data);
+  }
   if (!hasMountInClosure(dep, data))
     return;
   if (data.mountInClosure.has(selector))
@@ -3295,36 +3402,53 @@ var onLiveDependencyRemoved = (dep, data) => {
     propagateNotLive(dep, data);
   }
 };
-var regionHasCycle = (seeds, data) => {
-  const done = new Set;
+var seedClosureHasCycle = (seed, data, graphVersion, acyclicAtVersion) => {
+  if (acyclicAtVersion.get(seed) === graphVersion)
+    return false;
   const onPath = new Set;
-  for (const seed of seeds) {
-    if (done.has(seed))
+  const stack = [
+    { node: seed, it: (data.stateDependencies.get(seed) ?? EMPTY).values() }
+  ];
+  onPath.add(seed);
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    const next = frame.it.next();
+    if (next.done) {
+      onPath.delete(frame.node);
+      acyclicAtVersion.set(frame.node, graphVersion);
+      stack.pop();
       continue;
-    const stack = [
-      { node: seed, it: (data.stateDependencies.get(seed) ?? EMPTY).values() }
-    ];
-    onPath.add(seed);
-    while (stack.length > 0) {
-      const frame = stack[stack.length - 1];
-      const next = frame.it.next();
-      if (next.done) {
-        onPath.delete(frame.node);
-        done.add(frame.node);
-        stack.pop();
-        continue;
-      }
-      const dep = next.value;
-      if (onPath.has(dep))
+    }
+    const dep = next.value;
+    if (onPath.has(dep))
+      return true;
+    if (acyclicAtVersion.get(dep) === graphVersion)
+      continue;
+    onPath.add(dep);
+    stack.push({
+      node: dep,
+      it: (data.stateDependencies.get(dep) ?? EMPTY).values()
+    });
+  }
+  return false;
+};
+var regionHasCycle = (seeds, data) => {
+  const graphVersion = data.dependencyGraphVersion;
+  const acyclicAtVersion = data.acyclicDependencyVersion;
+  if (seeds instanceof Set) {
+    for (const seed of seeds) {
+      if (seedClosureHasCycle(seed, data, graphVersion, acyclicAtVersion)) {
         return true;
-      if (done.has(dep))
-        continue;
-      onPath.add(dep);
-      stack.push({
-        node: dep,
-        it: (data.stateDependencies.get(dep) ?? EMPTY).values()
-      });
+      }
     }
+    return false;
+  }
+  return seedClosureHasCycle(seeds, data, graphVersion, acyclicAtVersion);
+};
+var seededRegionMayHaveCycle = (seeds, data) => {
+  for (const seed of seeds) {
+    if (data.cycleRiskInClosure.has(seed))
+      return true;
   }
   return false;
 };
@@ -3344,7 +3468,7 @@ var endLivenessPass = (data) => {
   data.livenessSeeds = undefined;
   data.livenessLazyArmed = false;
   data.livenessRemovalArmed = false;
-  if (seeds && seeds.size > 0 && (lazyArmed || removalArmed && regionHasCycle(seeds, data))) {
+  if (seeds && seeds.size > 0 && (lazyArmed || removalArmed && seededRegionMayHaveCycle(seeds, data) && regionHasCycle(seeds, data))) {
     return seeds;
   }
   return null;
@@ -3687,6 +3811,7 @@ function atom(defaultValue, options) {
   return created;
 }
 // src/lib/stableStringify.ts
+var compareStrings = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 var stableStringifyRecurse = (x, key) => {
   if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
     return `"${x}"`;
@@ -3720,14 +3845,18 @@ var stableStringifyRecurse = (x, key) => {
     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);
+    const entries = Array.from(x, ([k, v]) => [
+      stableStringifyRecurse(k),
+      stableStringifyRecurse(v)
+    ]).sort(([ak, av], [bk, bv]) => {
+      const keyOrder = compareStrings(ak, bk);
+      return keyOrder || compareStrings(av, bv);
+    });
+    return `__MAP(${stableStringifyRecurse(entries, key)})__`;
   }
   if (x instanceof Set) {
-    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
+    const values = Array.from(x, (v) => stableStringifyRecurse(v)).sort();
+    return `__SET(${stableStringifyRecurse(values, key)})__`;
   }
   if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
     return stableStringifyRecurse(Array.from(x), key);
@@ -4091,9 +4220,9 @@ var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 // src/index.ts
 var slot = valdresGlobal();
 if (slot.version) {
-  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${slot.version}. Attempted to load: ${"1.0.0-beta.14"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${slot.version}. Attempted to load: ${"1.0.0-beta.15"}`);
 } else {
-  slot.version = "1.0.0-beta.14";
+  slot.version = "1.0.0-beta.15";
 }
 export {
   store,

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

@@ -0,0 +1,9 @@
+import type { State } from "../types/State";
+import type { StoreData } from "../types/StoreData";
+/**
+ * Remove non-live states from the dependency graph, clear selector caches, and
+ * recursively clean orphaned dependencies/dependents. Visit marks persist for
+ * one topology generation so every state is processed once across a queued
+ * sibling-unsubscribe burst.
+ */
+export declare const cleanupOrphanedDeps: (state: State, data: StoreData) => void;

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

@@ -0,0 +1,7 @@
+import type { StoreData } from "../types/StoreData";
+/**
+ * Drain this store's queued orphan roots synchronously. Public store operations
+ * call this first so microtask batching does not change their observable cache
+ * semantics.
+ */
+export declare const flushPendingOrphanCleanup: (data: StoreData) => void;

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

@@ -41,27 +41,7 @@ export declare const onLiveDependencyAdded: (dep: State, data: StoreData) => voi
  * if the contribution was the last one keeping dep alive.
  */
 export declare const onLiveDependencyRemoved: (dep: State, data: StoreData) => void;
-/**
- * Does the DOWNWARD (dependency) closure of `seeds` contain a directed cycle?
- *
- * This is the exact gate for the removal-armed liveness reconcile. Both bugs the
- * reconcile fixes provably require a cycle inside the affected region:
- *  - FREEZE: a still-live selector S is stranded only if `propagateNotLive`,
- *    walking DOWN from a removed dep D, reaches back to S — i.e. D depends
- *    (transitively) on S while S reads D, a cycle through D and S.
- *  - LEAK: a reference count fails to drain only a cycle; a DAG always drains
- *    via the `prev === 1` guard.
- * So on an acyclic region the incremental onLiveDependencyRemoved + propagateNotLive
- * already equals ground truth and the reconcile is a no-op — skip it.
- *
- * Iterative DFS over `data.stateDependencies` (down-edges only) restricted to the
- * seeds' closure; an `onPath` (gray) set detects a back-edge, a `done` (black) set
- * memoizes fully-explored acyclic subgraphs. Only selectors are keyed in
- * `stateDependencies`; atoms and atom-family members are graph sinks (no
- * out-edges), so a region of pure atom deps returns false in O(seeds).
- * (selectorFamily members ARE selectors and do have out-edges.)
- */
-export declare const regionHasCycle: (seeds: Set<State>, data: StoreData) => boolean;
+export declare const regionHasCycle: (seeds: Set<State> | State, data: StoreData) => boolean;
 /**
  * Begin a liveness-reconcile pass. Returns true iff THIS call owns the pass (the
  * outermost one) — a nested pass returns false and must not release or reconcile.

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

@@ -0,0 +1,7 @@
+import type { State } from "../types/State";
+import type { StoreData } from "../types/StoreData";
+/**
+ * Invalidate topology-sensitive teardown caches after graph construction or
+ * churn, and assign the selector's stable per-store materialization order.
+ */
+export declare const noteDependencyGraphChanged: (selector: State, data: StoreData) => void;

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

@@ -0,0 +1,9 @@
+import type { State } from "../types/State";
+import type { StoreData } from "../types/StoreData";
+/**
+ * Batch orphan graph/value cleanup across a synchronous unsubscribe burst.
+ * This one-microtask delay is intentional: lifecycle cleanup already ran
+ * synchronously, and every public store operation drains this queue before it
+ * can observe or mutate selector caches.
+ */
+export declare const queueOrphanCleanup: (state: State, data: StoreData) => void;

package/dist/types/types/StoreData.d.ts

@@ -16,6 +16,34 @@ export type StoreData = {
     subscriptionsRequireEqualCheck: WeakMap<WeakKey, boolean>;
     stateDependents: WeakMap<WeakKey, any>;
     stateDependencies: WeakMap<WeakKey, any>;
+    /** Stable per-store order assigned when a selector first materializes its
+     *  dependency set. An edge to an equal/newer selector violates this order,
+     *  making a directed cycle possible in that closure. */
+    dependencyOrder: WeakMap<WeakKey, number>;
+    nextDependencyOrder: number;
+    /** Monotonic, conservative marker: present when a state's downward closure
+     *  may contain an edge that violates `dependencyOrder`. Every real cycle has
+     *  at least one such edge, so absence proves the closure acyclic in O(1).
+     *  Stale positives after edge removal only cost a fallback DFS. */
+    cycleRiskInClosure: WeakMap<WeakKey, true>;
+    /** Monotonic generation for dependency-graph materialization/churn. Selector
+     *  evaluation increments it when a dependency set is created or changed.
+     *  Orphan teardown only removes edges and deliberately leaves it unchanged:
+     *  deletion cannot create a cycle, so a synchronous unsubscribe burst can
+     *  reuse both negative cycle proofs and completed orphan-walk visits. */
+    dependencyGraphVersion: number;
+    /** `state -> dependencyGraphVersion` for closures proven acyclic. A cached
+     *  negative remains valid while teardown only deletes edges; any normal graph
+     *  construction/churn bumps `dependencyGraphVersion` and invalidates it. */
+    acyclicDependencyVersion: WeakMap<WeakKey, number>;
+    /** `state -> dependencyGraphVersion` for non-live states whose orphan graph
+     *  work has completed. This is the shared visited set for a deletion-only
+     *  unsubscribe burst, without retaining states strongly between calls. */
+    orphanCleanupVersion: WeakMap<WeakKey, number>;
+    /** Strong only until the queued microtask drains it. Batches orphan graph
+     *  cleanup roots across a synchronous unsubscribe burst. */
+    pendingOrphanCleanup?: Set<WeakKey>;
+    orphanCleanupScheduled: boolean;
     mounts: WeakMap<WeakKey, {
         cleanup?: () => void;
     }>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "valdres",
     "description": "Fast atom-based state management for JavaScript. Inspired by Recoil and Jotai.",
-    "version": "1.0.0-beta.14",
+    "version": "1.0.0-beta.15",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"