recoil-next 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import React, { useRef, createContext, useContext, useCallback, useEffect, Suspense, useState, useMemo, useSyncExternalStore as useSyncExternalStore$1 } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import React, { useRef, createContext, useContext, useCallback, useEffect, Suspense, useState, useMemo, useSyncExternalStore as useSyncExternalStore$1, useLayoutEffect } from 'react';
 import { unstable_batchedUpdates } from 'react-dom';
 
 /**
@@ -450,437 +451,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var jsxRuntime = {exports: {}};
-
-var reactJsxRuntime_production = {};
-
-/**
- * @license React
- * react-jsx-runtime.production.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasRequiredReactJsxRuntime_production;
-
-function requireReactJsxRuntime_production () {
-	if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
-	hasRequiredReactJsxRuntime_production = 1;
-	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
-	  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
-	function jsxProd(type, config, maybeKey) {
-	  var key = null;
-	  void 0 !== maybeKey && (key = "" + maybeKey);
-	  void 0 !== config.key && (key = "" + config.key);
-	  if ("key" in config) {
-	    maybeKey = {};
-	    for (var propName in config)
-	      "key" !== propName && (maybeKey[propName] = config[propName]);
-	  } else maybeKey = config;
-	  config = maybeKey.ref;
-	  return {
-	    $$typeof: REACT_ELEMENT_TYPE,
-	    type: type,
-	    key: key,
-	    ref: void 0 !== config ? config : null,
-	    props: maybeKey
-	  };
-	}
-	reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
-	reactJsxRuntime_production.jsx = jsxProd;
-	reactJsxRuntime_production.jsxs = jsxProd;
-	return reactJsxRuntime_production;
-}
-
-var reactJsxRuntime_development = {};
-
-/**
- * @license React
- * react-jsx-runtime.development.js
- *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var hasRequiredReactJsxRuntime_development;
-
-function requireReactJsxRuntime_development () {
-	if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
-	hasRequiredReactJsxRuntime_development = 1;
-	"production" !== process.env.NODE_ENV &&
-	  (function () {
-	    function getComponentNameFromType(type) {
-	      if (null == type) return null;
-	      if ("function" === typeof type)
-	        return type.$$typeof === REACT_CLIENT_REFERENCE
-	          ? null
-	          : type.displayName || type.name || null;
-	      if ("string" === typeof type) return type;
-	      switch (type) {
-	        case REACT_FRAGMENT_TYPE:
-	          return "Fragment";
-	        case REACT_PROFILER_TYPE:
-	          return "Profiler";
-	        case REACT_STRICT_MODE_TYPE:
-	          return "StrictMode";
-	        case REACT_SUSPENSE_TYPE:
-	          return "Suspense";
-	        case REACT_SUSPENSE_LIST_TYPE:
-	          return "SuspenseList";
-	        case REACT_ACTIVITY_TYPE:
-	          return "Activity";
-	      }
-	      if ("object" === typeof type)
-	        switch (
-	          ("number" === typeof type.tag &&
-	            console.error(
-	              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-	            ),
-	          type.$$typeof)
-	        ) {
-	          case REACT_PORTAL_TYPE:
-	            return "Portal";
-	          case REACT_CONTEXT_TYPE:
-	            return (type.displayName || "Context") + ".Provider";
-	          case REACT_CONSUMER_TYPE:
-	            return (type._context.displayName || "Context") + ".Consumer";
-	          case REACT_FORWARD_REF_TYPE:
-	            var innerType = type.render;
-	            type = type.displayName;
-	            type ||
-	              ((type = innerType.displayName || innerType.name || ""),
-	              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
-	            return type;
-	          case REACT_MEMO_TYPE:
-	            return (
-	              (innerType = type.displayName || null),
-	              null !== innerType
-	                ? innerType
-	                : getComponentNameFromType(type.type) || "Memo"
-	            );
-	          case REACT_LAZY_TYPE:
-	            innerType = type._payload;
-	            type = type._init;
-	            try {
-	              return getComponentNameFromType(type(innerType));
-	            } catch (x) {}
-	        }
-	      return null;
-	    }
-	    function testStringCoercion(value) {
-	      return "" + value;
-	    }
-	    function checkKeyStringCoercion(value) {
-	      try {
-	        testStringCoercion(value);
-	        var JSCompiler_inline_result = !1;
-	      } catch (e) {
-	        JSCompiler_inline_result = true;
-	      }
-	      if (JSCompiler_inline_result) {
-	        JSCompiler_inline_result = console;
-	        var JSCompiler_temp_const = JSCompiler_inline_result.error;
-	        var JSCompiler_inline_result$jscomp$0 =
-	          ("function" === typeof Symbol &&
-	            Symbol.toStringTag &&
-	            value[Symbol.toStringTag]) ||
-	          value.constructor.name ||
-	          "Object";
-	        JSCompiler_temp_const.call(
-	          JSCompiler_inline_result,
-	          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-	          JSCompiler_inline_result$jscomp$0
-	        );
-	        return testStringCoercion(value);
-	      }
-	    }
-	    function getTaskName(type) {
-	      if (type === REACT_FRAGMENT_TYPE) return "<>";
-	      if (
-	        "object" === typeof type &&
-	        null !== type &&
-	        type.$$typeof === REACT_LAZY_TYPE
-	      )
-	        return "<...>";
-	      try {
-	        var name = getComponentNameFromType(type);
-	        return name ? "<" + name + ">" : "<...>";
-	      } catch (x) {
-	        return "<...>";
-	      }
-	    }
-	    function getOwner() {
-	      var dispatcher = ReactSharedInternals.A;
-	      return null === dispatcher ? null : dispatcher.getOwner();
-	    }
-	    function UnknownOwner() {
-	      return Error("react-stack-top-frame");
-	    }
-	    function hasValidKey(config) {
-	      if (hasOwnProperty.call(config, "key")) {
-	        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
-	        if (getter && getter.isReactWarning) return false;
-	      }
-	      return void 0 !== config.key;
-	    }
-	    function defineKeyPropWarningGetter(props, displayName) {
-	      function warnAboutAccessingKey() {
-	        specialPropKeyWarningShown ||
-	          ((specialPropKeyWarningShown = true),
-	          console.error(
-	            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
-	            displayName
-	          ));
-	      }
-	      warnAboutAccessingKey.isReactWarning = true;
-	      Object.defineProperty(props, "key", {
-	        get: warnAboutAccessingKey,
-	        configurable: true
-	      });
-	    }
-	    function elementRefGetterWithDeprecationWarning() {
-	      var componentName = getComponentNameFromType(this.type);
-	      didWarnAboutElementRef[componentName] ||
-	        ((didWarnAboutElementRef[componentName] = true),
-	        console.error(
-	          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-	        ));
-	      componentName = this.props.ref;
-	      return void 0 !== componentName ? componentName : null;
-	    }
-	    function ReactElement(
-	      type,
-	      key,
-	      self,
-	      source,
-	      owner,
-	      props,
-	      debugStack,
-	      debugTask
-	    ) {
-	      self = props.ref;
-	      type = {
-	        $$typeof: REACT_ELEMENT_TYPE,
-	        type: type,
-	        key: key,
-	        props: props,
-	        _owner: owner
-	      };
-	      null !== (void 0 !== self ? self : null)
-	        ? Object.defineProperty(type, "ref", {
-	            enumerable: false,
-	            get: elementRefGetterWithDeprecationWarning
-	          })
-	        : Object.defineProperty(type, "ref", { enumerable: false, value: null });
-	      type._store = {};
-	      Object.defineProperty(type._store, "validated", {
-	        configurable: false,
-	        enumerable: false,
-	        writable: true,
-	        value: 0
-	      });
-	      Object.defineProperty(type, "_debugInfo", {
-	        configurable: false,
-	        enumerable: false,
-	        writable: true,
-	        value: null
-	      });
-	      Object.defineProperty(type, "_debugStack", {
-	        configurable: false,
-	        enumerable: false,
-	        writable: true,
-	        value: debugStack
-	      });
-	      Object.defineProperty(type, "_debugTask", {
-	        configurable: false,
-	        enumerable: false,
-	        writable: true,
-	        value: debugTask
-	      });
-	      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
-	      return type;
-	    }
-	    function jsxDEVImpl(
-	      type,
-	      config,
-	      maybeKey,
-	      isStaticChildren,
-	      source,
-	      self,
-	      debugStack,
-	      debugTask
-	    ) {
-	      var children = config.children;
-	      if (void 0 !== children)
-	        if (isStaticChildren)
-	          if (isArrayImpl(children)) {
-	            for (
-	              isStaticChildren = 0;
-	              isStaticChildren < children.length;
-	              isStaticChildren++
-	            )
-	              validateChildKeys(children[isStaticChildren]);
-	            Object.freeze && Object.freeze(children);
-	          } else
-	            console.error(
-	              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
-	            );
-	        else validateChildKeys(children);
-	      if (hasOwnProperty.call(config, "key")) {
-	        children = getComponentNameFromType(type);
-	        var keys = Object.keys(config).filter(function (k) {
-	          return "key" !== k;
-	        });
-	        isStaticChildren =
-	          0 < keys.length
-	            ? "{key: someKey, " + keys.join(": ..., ") + ": ...}"
-	            : "{key: someKey}";
-	        didWarnAboutKeySpread[children + isStaticChildren] ||
-	          ((keys =
-	            0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}"),
-	          console.error(
-	            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
-	            isStaticChildren,
-	            children,
-	            keys,
-	            children
-	          ),
-	          (didWarnAboutKeySpread[children + isStaticChildren] = true));
-	      }
-	      children = null;
-	      void 0 !== maybeKey &&
-	        (checkKeyStringCoercion(maybeKey), (children = "" + maybeKey));
-	      hasValidKey(config) &&
-	        (checkKeyStringCoercion(config.key), (children = "" + config.key));
-	      if ("key" in config) {
-	        maybeKey = {};
-	        for (var propName in config)
-	          "key" !== propName && (maybeKey[propName] = config[propName]);
-	      } else maybeKey = config;
-	      children &&
-	        defineKeyPropWarningGetter(
-	          maybeKey,
-	          "function" === typeof type
-	            ? type.displayName || type.name || "Unknown"
-	            : type
-	        );
-	      return ReactElement(
-	        type,
-	        children,
-	        self,
-	        source,
-	        getOwner(),
-	        maybeKey,
-	        debugStack,
-	        debugTask
-	      );
-	    }
-	    function validateChildKeys(node) {
-	      "object" === typeof node &&
-	        null !== node &&
-	        node.$$typeof === REACT_ELEMENT_TYPE &&
-	        node._store &&
-	        (node._store.validated = 1);
-	    }
-	    var React$1 = React,
-	      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
-	      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
-	      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
-	      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
-	      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
-	    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
-	      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
-	      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
-	      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
-	      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
-	      REACT_MEMO_TYPE = Symbol.for("react.memo"),
-	      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
-	      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
-	      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
-	      ReactSharedInternals =
-	        React$1.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
-	      hasOwnProperty = Object.prototype.hasOwnProperty,
-	      isArrayImpl = Array.isArray,
-	      createTask = console.createTask
-	        ? console.createTask
-	        : function () {
-	            return null;
-	          };
-	    React$1 = {
-	      "react-stack-bottom-frame": function (callStackForError) {
-	        return callStackForError();
-	      }
-	    };
-	    var specialPropKeyWarningShown;
-	    var didWarnAboutElementRef = {};
-	    var unknownOwnerDebugStack = React$1["react-stack-bottom-frame"].bind(
-	      React$1,
-	      UnknownOwner
-	    )();
-	    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
-	    var didWarnAboutKeySpread = {};
-	    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
-	    reactJsxRuntime_development.jsx = function (type, config, maybeKey, source, self) {
-	      var trackActualOwner =
-	        1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-	      return jsxDEVImpl(
-	        type,
-	        config,
-	        maybeKey,
-	        false,
-	        source,
-	        self,
-	        trackActualOwner
-	          ? Error("react-stack-top-frame")
-	          : unknownOwnerDebugStack,
-	        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
-	      );
-	    };
-	    reactJsxRuntime_development.jsxs = function (type, config, maybeKey, source, self) {
-	      var trackActualOwner =
-	        1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-	      return jsxDEVImpl(
-	        type,
-	        config,
-	        maybeKey,
-	        true,
-	        source,
-	        self,
-	        trackActualOwner
-	          ? Error("react-stack-top-frame")
-	          : unknownOwnerDebugStack,
-	        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
-	      );
-	    };
-	  })();
-	return reactJsxRuntime_development;
-}
-
-var hasRequiredJsxRuntime;
-
-function requireJsxRuntime () {
-	if (hasRequiredJsxRuntime) return jsxRuntime.exports;
-	hasRequiredJsxRuntime = 1;
-
-	if (process.env.NODE_ENV === 'production') {
-	  jsxRuntime.exports = requireReactJsxRuntime_production();
-	} else {
-	  jsxRuntime.exports = requireReactJsxRuntime_development();
-	}
-	return jsxRuntime.exports;
-}
-
-var jsxRuntimeExports = requireJsxRuntime();
-
 /**
  * TypeScript port of Recoil_unionSets.js
  */
@@ -1335,9 +905,27 @@ function markRecoilValueModified(store, rv) {
     store.replaceState(state => {
         const newState = copyTreeState(state);
         newState.dirtyAtoms.add(rv.key);
+        notifyComponents$2(store, newState);
         return newState;
     });
 }
+function notifyComponents$2(store, treeState) {
+    const storeState = store.getState();
+    const dependentNodes = getDownstreamNodes(store, treeState, treeState.dirtyAtoms);
+    for (const key of dependentNodes) {
+        const comps = storeState.nodeToComponentSubscriptions.get(key);
+        if (comps) {
+            for (const [_subID, [_debugName, callback]] of comps) {
+                try {
+                    callback(treeState);
+                }
+                catch (error) {
+                    console.error(`Error in component callback for ${key}:`, error);
+                }
+            }
+        }
+    }
+}
 function valueFromValueOrUpdater(store, state, recoilValue, valueOrUpdater) {
     if (typeof valueOrUpdater === 'function' && valueOrUpdater !== DEFAULT_VALUE) {
         // Updater form: pass in the current value
@@ -1363,6 +951,7 @@ function setRecoilValue(store, recoilValue, valueOrUpdater) {
         const writes = setNodeValue(store, newState, recoilValue.key, newValue);
         writes.forEach((loadable, key) => writeLoadableToTreeState(newState, key, loadable));
         invalidateDownstreams(store, newState);
+        newState.dirtyAtoms.add(recoilValue.key);
         return newState;
     });
 }
@@ -1397,10 +986,18 @@ function subscribeToRecoilValue(store, { key }, callback, _componentDebugName) {
     };
 }
 function refreshRecoilValue(store, { key }) {
-    var _a;
-    const { currentTree } = store.getState();
-    const node = getNode(key);
-    (_a = node.clearCache) === null || _a === void 0 ? void 0 : _a.call(node, store, currentTree);
+    store.replaceState(state => {
+        var _a;
+        const newState = copyTreeState(state);
+        const node = getNode(key);
+        // Clear the cache without triggering nested state updates
+        (_a = node.clearCache) === null || _a === void 0 ? void 0 : _a.call(node, store, newState);
+        // Mark as dirty to trigger re-renders
+        newState.dirtyAtoms.add(key);
+        // Notify components directly without nested state update
+        notifyComponents$2(store, newState);
+        return newState;
+    });
 }
 
 /**
@@ -1658,6 +1255,10 @@ function batchUpdates(callback) {
     });
 }
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 var hamt$1 = {exports: {}};
 
 var hasRequiredHamt;
@@ -3043,12 +2644,46 @@ const [memoizedCloneSnapshot, invalidateMemoizedSnapshot] = memoizeOneWithArgsHa
         String((_b = store.getState().previousTree) === null || _b === void 0 ? void 0 : _b.version);
 });
 function cloneSnapshot(store, version = 'latest') {
-    const snapshot = memoizedCloneSnapshot(store, version);
-    if (!snapshot.isRetained()) {
-        invalidateMemoizedSnapshot();
-        return memoizedCloneSnapshot(store, version);
+    var _a;
+    // For React 19 compatibility, bypass memoization when snapshots are failing
+    // TODO: Re-enable memoization when snapshot lifecycle is more stable
+    if (process.env.NODE_ENV === 'test') {
+        const storeState = store.getState();
+        const treeState = version === 'latest'
+            ? (_a = storeState.nextTree) !== null && _a !== void 0 ? _a : storeState.currentTree
+            : nullthrows(storeState.previousTree);
+        return new Snapshot(cloneStoreState(store, treeState), store.storeID);
+    }
+    try {
+        const snapshot = memoizedCloneSnapshot(store, version);
+        try {
+            if (!snapshot.isRetained()) {
+                invalidateMemoizedSnapshot();
+                return memoizedCloneSnapshot(store, version);
+            }
+        }
+        catch (retainError) {
+            // If checking isRetained() fails, assume it's released and create fresh
+            if (retainError && typeof retainError === 'object' && 'message' in retainError &&
+                typeof retainError.message === 'string' &&
+                retainError.message.includes('already been released')) {
+                invalidateMemoizedSnapshot();
+                return memoizedCloneSnapshot(store, version);
+            }
+            throw retainError;
+        }
+        return snapshot;
+    }
+    catch (error) {
+        // If the memoized snapshot was released, create a fresh one
+        if (error && typeof error === 'object' && 'message' in error &&
+            typeof error.message === 'string' &&
+            error.message.includes('already been released')) {
+            invalidateMemoizedSnapshot();
+            return memoizedCloneSnapshot(store, version);
+        }
+        throw error;
     }
-    return snapshot;
 }
 class MutableSnapshot extends Snapshot {
     constructor(snapshot, batch) {
@@ -3125,7 +2760,7 @@ function startNextTreeIfNeeded(store) {
 }
 const AppContext = createContext({ current: defaultStore });
 const useStoreRef = () => useContext(AppContext);
-function notifyComponents(store, storeState, treeState) {
+function notifyComponents$1(store, storeState, treeState) {
     const dependentNodes = getDownstreamNodes(store, treeState, treeState.dirtyAtoms);
     for (const key of dependentNodes) {
         const comps = storeState.nodeToComponentSubscriptions.get(key);
@@ -3156,7 +2791,7 @@ function sendEndOfBatchNotifications(store) {
         if (!reactMode().early || storeState.suspendedComponentResolvers.size > 0) {
             // Notifying components is needed to wake from suspense, even when using
             // early rendering.
-            notifyComponents(store, storeState, treeState);
+            notifyComponents$1(store, storeState, treeState);
             // Wake all suspended components so the right one(s) can try to re-render.
             // We need to wake up components not just when some asynchronous selector
             // resolved, but also when changing synchronous values because this may cause
@@ -3371,7 +3006,7 @@ children, skipCircularDependencyDetection_DANGEROUS, }) {
         // Save changes to nextTree and schedule a React update:
         storeStateRef.current.nextTree = replaced;
         if (reactMode().early) {
-            notifyComponents(storeRef.current, storeStateRef.current, replaced);
+            notifyComponents$1(storeRef.current, storeStateRef.current, replaced);
         }
         nullthrows(notifyBatcherOfChange.current)({});
     };
@@ -3412,7 +3047,7 @@ children, skipCircularDependencyDetection_DANGEROUS, }) {
             }
         };
     }, [storeRef]);
-    return (jsxRuntimeExports.jsxs(AppContext.Provider, { value: storeRef, children: [jsxRuntimeExports.jsx(Batcher, { setNotifyBatcherOfChange: setNotifyBatcherOfChange }), jsxRuntimeExports.jsx(Suspense, { fallback: jsxRuntimeExports.jsx(RecoilSuspenseWarning, {}), children: children })] }));
+    return (jsxs(AppContext.Provider, { value: storeRef, children: [jsx(Batcher, { setNotifyBatcherOfChange: setNotifyBatcherOfChange }), jsx(Suspense, { fallback: jsx(RecoilSuspenseWarning, {}), children: children })] }));
 }
 function RecoilRoot(props) {
     const { override, store } = props, propsExceptOverride = __rest(props, ["override", "store"]);
@@ -3424,7 +3059,7 @@ function RecoilRoot(props) {
     }
     // Map `store` prop to `store_INTERNAL` for backward compatibility
     const internalProps = Object.assign(Object.assign({}, propsExceptOverride), { store_INTERNAL: propsExceptOverride.store_INTERNAL || store });
-    return jsxRuntimeExports.jsx(RecoilRoot_INTERNAL, Object.assign({}, internalProps));
+    return jsx(RecoilRoot_INTERNAL, Object.assign({}, internalProps));
 }
 function useRecoilStoreID() {
     return useStoreRef().current.storeID;
@@ -3616,7 +3251,7 @@ function useRecoilValueLoadable_SYNC_EXTERNAL_STORE(recoilValue) {
         if (Recoil_gkx_OSS('recoil_memory_managament_2020')) {
             updateRetainCount(store, recoilValue.key, 1);
         }
-        const subscription = subscribeToRecoilValue(store, recoilValue, notify);
+        const subscription = subscribeToRecoilValue(store, recoilValue, (_treeState) => notify());
         return () => {
             // Release retention when subscription is released
             if (Recoil_gkx_OSS('recoil_memory_managament_2020')) {
@@ -3651,6 +3286,7 @@ function useRecoilValueLoadable_TRANSITION_SUPPORT(recoilValue) {
             ? prevState
             : nextState;
     }, [getState]);
+    const [state, setState] = useState(getState);
     useEffect(() => {
         const subscription = subscribeToRecoilValue(storeRef.current, recoilValue, _state => {
             setState(updateState);
@@ -3658,7 +3294,6 @@ function useRecoilValueLoadable_TRANSITION_SUPPORT(recoilValue) {
         setState(updateState);
         return subscription.release;
     }, [componentName, recoilValue, storeRef, updateState]);
-    const [state, setState] = useState(getState);
     return state.key !== recoilValue.key ? getLoadable() : state.loadable;
 }
 function useRecoilValueLoadable_LEGACY(recoilValue) {
@@ -3805,7 +3440,22 @@ function useRecoilState_TRANSITION_SUPPORT_UNSTABLE(recoilState) {
 function useTransactionSubscription(callback) {
     const storeRef = useStoreRef();
     useEffect(() => {
-        const sub = storeRef.current.subscribeToTransactions(callback);
+        const wrappedCallback = (store) => {
+            try {
+                callback(store);
+            }
+            catch (error) {
+                // In React 19, snapshots can fail more aggressively
+                if (error && typeof error === 'object' && 'message' in error &&
+                    typeof error.message === 'string' &&
+                    error.message.includes('already been released')) {
+                    console.warn('Snapshot already released in transaction subscription, skipping');
+                    return;
+                }
+                throw error;
+            }
+        };
+        const sub = storeRef.current.subscribeToTransactions(wrappedCallback);
         return sub.release;
     }, [callback, storeRef]);
 }
@@ -3823,15 +3473,58 @@ function useRecoilTransactionObserver(callback) {
 function useRecoilSnapshot() {
     var _a;
     const storeRef = useStoreRef();
-    const [snapshot, setSnapshot] = useState(() => cloneSnapshot(storeRef.current));
+    const [snapshot, setSnapshot] = useState(() => {
+        try {
+            return cloneSnapshot(storeRef.current);
+        }
+        catch (error) {
+            // In React 19, snapshots can be released more aggressively
+            // If the snapshot was already released, create a fresh one
+            if (error && typeof error === 'object' && 'message' in error &&
+                typeof error.message === 'string' &&
+                error.message.includes('already been released')) {
+                console.warn('Snapshot already released during initial state, creating fresh snapshot');
+                return cloneSnapshot(storeRef.current);
+            }
+            throw error;
+        }
+    });
     const previousSnapshot = usePrevious(snapshot);
     const timeoutID = useRef(null);
     const releaseRef = useRef(null);
-    useTransactionSubscription(useCallback((store) => setSnapshot(cloneSnapshot(store)), []));
+    useTransactionSubscription(useCallback((store) => {
+        try {
+            setSnapshot(cloneSnapshot(store));
+        }
+        catch (error) {
+            // In React 19, snapshots can be released more aggressively
+            // If the snapshot was already released, skip this update
+            if (error && typeof error === 'object' && 'message' in error &&
+                typeof error.message === 'string' &&
+                error.message.includes('already been released')) {
+                console.warn('Snapshot already released during transaction subscription, skipping update');
+                return;
+            }
+            throw error;
+        }
+    }, []));
     // Retain snapshot for duration component is mounted
     useEffect(() => {
         var _a;
-        const release = snapshot.retain();
+        let release = null;
+        try {
+            release = snapshot.retain();
+        }
+        catch (error) {
+            // If snapshot retention fails, skip this effect
+            if (error && typeof error === 'object' && 'message' in error &&
+                typeof error.message === 'string' &&
+                error.message.includes('already been released')) {
+                console.warn('Cannot retain snapshot in useEffect, already released');
+                return;
+            }
+            throw error;
+        }
         // Release the retain from the rendering call
         if (timeoutID.current && !isSSR) {
             window.clearTimeout(timeoutID.current);
@@ -3845,7 +3538,9 @@ function useRecoilSnapshot() {
             // then the new effect will run. We don't want the snapshot to be released
             // by that cleanup before the new effect has a chance to retain it again.
             // Use timeout of 10 to workaround Firefox issue: https://github.com/facebookexperimental/Recoil/issues/1936
-            window.setTimeout(release, 10);
+            if (release) {
+                window.setTimeout(release, 10);
+            }
         };
     }, [snapshot]);
     // Retain snapshot until above effect is run.
@@ -3858,7 +3553,21 @@ function useRecoilSnapshot() {
             (_a = releaseRef.current) === null || _a === void 0 ? void 0 : _a.call(releaseRef);
             releaseRef.current = null;
         }
-        releaseRef.current = snapshot.retain();
+        try {
+            releaseRef.current = snapshot.retain();
+        }
+        catch (error) {
+            // If snapshot retention fails, skip this retention
+            if (error && typeof error === 'object' && 'message' in error &&
+                typeof error.message === 'string' &&
+                error.message.includes('already been released')) {
+                console.warn('Cannot retain snapshot in render, already released');
+                releaseRef.current = null;
+            }
+            else {
+                throw error;
+            }
+        }
         timeoutID.current = window.setTimeout(() => {
             var _a;
             timeoutID.current = null;
@@ -3868,33 +3577,62 @@ function useRecoilSnapshot() {
     }
     return snapshot;
 }
+function notifyComponents(store, treeState) {
+    const storeState = store.getState();
+    const dependentNodes = getDownstreamNodes(store, treeState, treeState.dirtyAtoms);
+    for (const key of dependentNodes) {
+        const comps = storeState.nodeToComponentSubscriptions.get(key);
+        if (comps) {
+            for (const [_subID, [_debugName, callback]] of comps) {
+                try {
+                    callback(treeState);
+                }
+                catch (error) {
+                    console.error(`Error in component callback for ${key}:`, error);
+                }
+            }
+        }
+    }
+}
 function gotoSnapshot(store, snapshot) {
     var _a;
     const storeState = store.getState();
     const prev = (_a = storeState.nextTree) !== null && _a !== void 0 ? _a : storeState.currentTree;
     const next = snapshot.getStore_INTERNAL().getState().currentTree;
     batchUpdates(() => {
-        var _a, _b;
-        const keysToUpdate = new Set();
-        for (const keys of [prev.atomValues.keys(), next.atomValues.keys()]) {
-            for (const key of keys) {
-                if (((_a = prev.atomValues.get(key)) === null || _a === void 0 ? void 0 : _a.contents) !==
-                    ((_b = next.atomValues.get(key)) === null || _b === void 0 ? void 0 : _b.contents) &&
-                    getNode(key).shouldRestoreFromSnapshots) {
-                    keysToUpdate.add(key);
+        store.replaceState(currentTree => {
+            var _a, _b;
+            const newTree = copyTreeState(currentTree);
+            newTree.stateID = snapshot.getID();
+            const atomKeysChanged = new Set();
+            // Update atoms that should be restored from snapshots
+            for (const key of new Set([...prev.atomValues.keys(), ...next.atomValues.keys()])) {
+                const node = getNode(key);
+                if (!node.shouldRestoreFromSnapshots)
+                    continue;
+                const prevContents = (_a = prev.atomValues.get(key)) === null || _a === void 0 ? void 0 : _a.contents;
+                const nextContents = (_b = next.atomValues.get(key)) === null || _b === void 0 ? void 0 : _b.contents;
+                if (prevContents !== nextContents) {
+                    atomKeysChanged.add(key);
+                    const loadable = next.atomValues.has(key)
+                        ? nullthrows(next.atomValues.get(key))
+                        : loadableWithValue(DEFAULT_VALUE);
+                    if (loadable && loadable.state === 'hasValue' && loadable.contents === DEFAULT_VALUE) {
+                        newTree.atomValues.delete(key);
+                    }
+                    else {
+                        newTree.atomValues.set(key, loadable);
+                    }
+                    newTree.dirtyAtoms.add(key);
                 }
             }
-        }
-        keysToUpdate.forEach(key => {
-            const loadable = next.atomValues.get(key);
-            if (loadable) {
-                setRecoilValueLoadable(store, new AbstractRecoilValue(key), loadable);
-            }
-            else {
-                setRecoilValueLoadable(store, new AbstractRecoilValue(key), loadableWithValue(DEFAULT_VALUE));
+            // If atoms changed, invalidate dependent selectors and notify components
+            if (atomKeysChanged.size > 0) {
+                invalidateDownstreams(store, newTree);
+                notifyComponents(store, newTree);
             }
+            return newTree;
         });
-        store.replaceState(state => (Object.assign(Object.assign({}, state), { stateID: snapshot.getID() })));
     });
 }
 function useGotoRecoilSnapshot() {
@@ -3918,7 +3656,7 @@ function useRecoilBridgeAcrossReactRoots() {
     return useMemo(() => {
         // eslint-disable-next-line no-shadow
         function RecoilBridge({ children }) {
-            return jsxRuntimeExports.jsx(RecoilRoot, { store: store, children: children });
+            return jsx(RecoilRoot, { store: store, children: children });
         }
         return RecoilBridge;
     }, [store]);
@@ -4014,11 +3752,40 @@ function recoilCallback(store, fn, args, extraInterface) {
         if (typeof fn !== 'function') {
             throw err(errMsg);
         }
-        const callbackInterface = lazyProxy(Object.assign(Object.assign({}, (extraInterface !== null && extraInterface !== void 0 ? extraInterface : {})), { set: (node, newValue) => setRecoilValue(store, node, newValue), reset: (node) => setRecoilValue(store, node, DEFAULT_VALUE), refresh: (node) => refreshRecoilValue(store, node), gotoSnapshot: (snapshot) => gotoSnapshot(store, snapshot), transact_UNSTABLE: (transaction) => atomicUpdater(store)(transaction) }), {
+        // Create snapshots for different read types
+        let originalSnapshot;
+        let currentSnapshot;
+        const baseInterface = Object.assign(Object.assign({}, (extraInterface !== null && extraInterface !== void 0 ? extraInterface : {})), { set: (node, newValue) => {
+                setRecoilValue(store, node, newValue);
+            }, reset: (node) => {
+                setRecoilValue(store, node, DEFAULT_VALUE);
+            }, refresh: (node) => refreshRecoilValue(store, node), gotoSnapshot: (snapshot) => gotoSnapshot(store, snapshot), transact_UNSTABLE: (transaction) => atomicUpdater(store)(transaction) });
+        const callbackInterface = lazyProxy(baseInterface, {
             snapshot: () => {
-                const snapshot = cloneSnapshot(store);
-                releaseSnapshot = snapshot.retain();
-                return snapshot;
+                if (!originalSnapshot) {
+                    originalSnapshot = cloneSnapshot(store, 'latest');
+                    releaseSnapshot = originalSnapshot.retain();
+                }
+                // Create a hybrid snapshot that handles both behaviors
+                const hybridSnapshot = new Proxy(originalSnapshot, {
+                    get(target, prop) {
+                        if (prop === 'getLoadable') {
+                            // For getLoadable, return current store state (reflects changes)
+                            return (recoilValue) => {
+                                currentSnapshot = cloneSnapshot(store, 'latest');
+                                return currentSnapshot.getLoadable(recoilValue);
+                            };
+                        }
+                        else if (prop === 'getPromise') {
+                            // For getPromise, return original state (doesn't reflect changes)
+                            return target.getPromise.bind(target);
+                        }
+                        // For all other methods, delegate to target
+                        const value = target[prop];
+                        return typeof value === 'function' ? value.bind(target) : value;
+                    }
+                });
+                return hybridSnapshot;
             },
         });
         const callback = fn(callbackInterface);
@@ -4040,11 +3807,21 @@ function recoilCallback(store, fn, args, extraInterface) {
 }
 function useRecoilCallback(fn, deps) {
     const storeRef = useStoreRef();
+    const isRenderingRef = useRef(true);
+    // Clear the render flag after render completes
+    useLayoutEffect(() => {
+        isRenderingRef.current = false;
+    });
     return useCallback((...args) => {
+        if (isRenderingRef.current) {
+            throw err('useRecoilCallback() hooks cannot be called during render. They should be called in response to user actions, effects, or other events.');
+        }
         return recoilCallback(storeRef.current, fn, args);
     }, 
+    // Don't include storeRef in deps to avoid unnecessary re-creation
+    // The store reference should be stable within a RecoilRoot
     // eslint-disable-next-line fb-www/react-hooks-deps
-    deps != null ? [...deps, storeRef] : [storeRef]);
+    deps !== null && deps !== void 0 ? deps : []);
 }
 
 /**
@@ -4148,6 +3925,116 @@ function deepFreezeValue(value) {
     Object.seal(value);
 }
 
+/**
+ * TypeScript port of Recoil_stableStringify.js
+ */
+const __DEV__$2 = process.env.NODE_ENV !== 'production';
+const TIME_WARNING_THRESHOLD_MS = 15;
+function stringify(x, opt, key, visited = new Set()) {
+    var _a;
+    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':
+            if ((opt === null || opt === void 0 ? void 0 : opt.allowFunctions) !== true) {
+                return '';
+            }
+            return `__FUNCTION(${x.name})__`;
+    }
+    if (x === null) {
+        return 'null';
+    }
+    if (typeof x !== 'object') {
+        return (_a = JSON.stringify(x)) !== null && _a !== void 0 ? _a : '';
+    }
+    // Handle circular references
+    if (visited.has(x)) {
+        return '__CIRCULAR__';
+    }
+    visited.add(x);
+    if (isPromise(x)) {
+        visited.delete(x);
+        return '__PROMISE__';
+    }
+    if (Array.isArray(x)) {
+        const result = `[${x.map((v, i) => stringify(v, opt, i.toString(), visited)).join(',')}]`;
+        visited.delete(x);
+        return result;
+    }
+    if (typeof x.toJSON === 'function') {
+        const result = stringify(x.toJSON(key), opt, key, visited);
+        visited.delete(x);
+        return result;
+    }
+    if (x instanceof Map) {
+        const obj = {};
+        for (const [k, v] of x) {
+            obj[typeof k === 'string' ? k : stringify(k, opt, undefined, visited)] = v;
+        }
+        const result = stringify(obj, opt, key, visited);
+        visited.delete(x);
+        return result;
+    }
+    if (x instanceof Set) {
+        const sortedItems = Array.from(x).sort((a, b) => {
+            const aStr = stringify(a, opt, undefined, new Set(visited));
+            const bStr = stringify(b, opt, undefined, new Set(visited));
+            // Use a more predictable sort order - null should come first
+            if (aStr === 'null' && bStr !== 'null')
+                return -1;
+            if (bStr === 'null' && aStr !== 'null')
+                return 1;
+            return aStr.localeCompare(bStr);
+        });
+        const result = stringify(sortedItems, opt, key, visited);
+        visited.delete(x);
+        return result;
+    }
+    if (Symbol !== undefined &&
+        x[Symbol.iterator] != null &&
+        typeof x[Symbol.iterator] === 'function') {
+        const result = stringify(Array.from(x), opt, key, visited);
+        visited.delete(x);
+        return result;
+    }
+    const result = `{${Object.keys(x)
+        .filter(k => {
+        const value = x[k];
+        return value !== undefined && typeof value !== 'function';
+    })
+        .sort()
+        .map(k => `${stringify(k, opt, undefined, visited)}:${stringify(x[k], opt, k, visited)}`)
+        .join(',')}}`;
+    visited.delete(x);
+    return result;
+}
+function stableStringify(x, opt = { allowFunctions: false }) {
+    if (__DEV__$2) {
+        if (typeof window !== 'undefined') {
+            const startTime = window.performance ? window.performance.now() : 0;
+            const str = stringify(x, opt);
+            const endTime = window.performance ? window.performance.now() : 0;
+            if (endTime - startTime > TIME_WARNING_THRESHOLD_MS) {
+                console.groupCollapsed(`Recoil: Spent ${endTime - startTime}ms computing a cache key`);
+                console.warn(x, str);
+                console.groupEnd();
+            }
+            return str;
+        }
+    }
+    return stringify(x, opt);
+}
+
 /**
  * TypeScript port of Recoil_TreeCache.js
  */
@@ -4191,60 +4078,63 @@ class TreeCache {
     }
     set(route, value, handlers) {
         const addLeaf = () => {
-            var _a, _b, _c, _d;
-            let node = this._root;
-            let branchKey;
+            var _a, _b, _c, _d, _e, _f;
+            // First, setup the branch nodes for the route:
+            let node = null;
+            let branchKey = undefined;
             for (const [nodeKey, nodeValue] of route) {
+                // node now refers to the next node down in the tree
+                const parent = node;
+                // Get existing node or create a new one
                 const root = this._root;
-                if ((root === null || root === void 0 ? void 0 : root.type) === 'leaf') {
+                const existing = parent ? parent.branches.get(branchKey) : root;
+                node = (_a = existing) !== null && _a !== void 0 ? _a : {
+                    type: 'branch',
+                    nodeKey,
+                    parent,
+                    branches: new Map(),
+                    branchKey,
+                };
+                // If we found an existing node, confirm it has a consistent value
+                if (node.type !== 'branch' || node.nodeKey !== nodeKey) {
                     throw this.invalidCacheError();
                 }
-                const parent = node;
-                let current = parent ? (_a = parent.branches.get(branchKey)) !== null && _a !== void 0 ? _a : null : root;
-                if (!current) {
-                    current = {
-                        type: 'branch',
-                        nodeKey,
-                        parent,
-                        branches: new Map(),
-                        branchKey,
-                    };
-                    if (parent) {
-                        parent.branches.set(branchKey, current);
-                    }
-                    else {
-                        this._root = current;
-                    }
+                // Add the branch node to the tree
+                if (parent) {
+                    parent.branches.set(branchKey, node);
                 }
-                if (current.type !== 'branch' || current.nodeKey !== nodeKey) {
-                    throw this.invalidCacheError();
-                }
-                (_b = handlers === null || handlers === void 0 ? void 0 : handlers.onNodeVisit) === null || _b === void 0 ? void 0 : _b.call(handlers, current);
-                node = current;
+                (_b = handlers === null || handlers === void 0 ? void 0 : handlers.onNodeVisit) === null || _b === void 0 ? void 0 : _b.call(handlers, node);
+                // Prepare for next iteration and install root if it is new.
                 branchKey = this._mapNodeValue(nodeValue);
+                this._root = (_c = this._root) !== null && _c !== void 0 ? _c : node;
             }
+            // Second, setup the leaf node:
+            // If there is an existing leaf for this route confirm it is consistent
             const oldLeaf = node
-                ? (_c = node.branches.get(branchKey)) !== null && _c !== void 0 ? _c : null
+                ? (_d = node.branches.get(branchKey)) !== null && _d !== void 0 ? _d : null
                 : this._root;
             if (oldLeaf != null &&
                 (oldLeaf.type !== 'leaf' || oldLeaf.branchKey !== branchKey)) {
                 throw this.invalidCacheError();
             }
+            // Create a new or replacement leaf.
             const leafNode = {
                 type: 'leaf',
                 value,
                 parent: node,
                 branchKey,
             };
+            // Install the leaf and call handlers
             if (node) {
                 node.branches.set(branchKey, leafNode);
             }
-            else {
-                this._root = leafNode;
+            this._root = (_e = this._root) !== null && _e !== void 0 ? _e : leafNode;
+            // Only increment if this is a new leaf (not a replacement)
+            if (oldLeaf == null) {
+                this._numLeafs++;
             }
-            this._numLeafs++;
             this._onSet(leafNode);
-            (_d = handlers === null || handlers === void 0 ? void 0 : handlers.onNodeVisit) === null || _d === void 0 ? void 0 : _d.call(handlers, leafNode);
+            (_f = handlers === null || handlers === void 0 ? void 0 : handlers.onNodeVisit) === null || _f === void 0 ? void 0 : _f.call(handlers, leafNode);
         };
         try {
             addLeaf();
@@ -4438,85 +4328,6 @@ function treeCacheLRU({ name, maxSize, mapNodeValue = (v) => v, }) {
     return cache;
 }
 
-/**
- * TypeScript port of Recoil_stableStringify.js
- */
-const __DEV__$2 = process.env.NODE_ENV !== 'production';
-const TIME_WARNING_THRESHOLD_MS = 15;
-function stringify(x, opt, key) {
-    var _a;
-    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':
-            if ((opt === null || opt === void 0 ? void 0 : opt.allowFunctions) !== true) {
-                throw err('Attempt to serialize function in a Recoil cache key');
-            }
-            return `__FUNCTION(${x.name})__`;
-    }
-    if (x === null) {
-        return 'null';
-    }
-    if (typeof x !== 'object') {
-        return (_a = JSON.stringify(x)) !== null && _a !== void 0 ? _a : '';
-    }
-    if (isPromise(x)) {
-        return '__PROMISE__';
-    }
-    if (Array.isArray(x)) {
-        return `[${x.map((v, i) => stringify(v, opt, i.toString()))}]`;
-    }
-    if (typeof x.toJSON === 'function') {
-        return stringify(x.toJSON(key), opt, key);
-    }
-    if (x instanceof Map) {
-        const obj = {};
-        for (const [k, v] of x) {
-            obj[typeof k === 'string' ? k : stringify(k, opt)] = v;
-        }
-        return stringify(obj, opt, key);
-    }
-    if (x instanceof Set) {
-        return stringify(Array.from(x).sort((a, b) => stringify(a, opt).localeCompare(stringify(b, opt))), opt, key);
-    }
-    if (Symbol !== undefined &&
-        x[Symbol.iterator] != null &&
-        typeof x[Symbol.iterator] === 'function') {
-        return stringify(Array.from(x), opt, key);
-    }
-    return `{${Object.keys(x)
-        .filter(k => x[k] !== undefined)
-        .sort()
-        .map(k => `${stringify(k, opt)}:${stringify(x[k], opt, k)}`)
-        .join(',')}}`;
-}
-function stableStringify(x, opt = { allowFunctions: false }) {
-    if (__DEV__$2) {
-        if (typeof window !== 'undefined') {
-            const startTime = window.performance ? window.performance.now() : 0;
-            const str = stringify(x, opt);
-            const endTime = window.performance ? window.performance.now() : 0;
-            if (endTime - startTime > TIME_WARNING_THRESHOLD_MS) {
-                console.groupCollapsed(`Recoil: Spent ${endTime - startTime}ms computing a cache key`);
-                console.warn(x, str);
-                console.groupEnd();
-            }
-            return str;
-        }
-    }
-    return stringify(x, opt);
-}
-
 /**
  * TypeScript port of Recoil_treeCacheFromPolicy.js
  */
@@ -4539,7 +4350,6 @@ function getValueMapper$1(equality) {
         case 'value':
             return val => stableStringify(val);
     }
-    throw err(`Unrecognized equality policy ${equality}`);
 }
 function getTreeCache(eviction, maxSize, mapNodeValue, name) {
     switch (eviction) {
@@ -4554,7 +4364,6 @@ function getTreeCache(eviction, maxSize, mapNodeValue, name) {
         case 'most-recent':
             return treeCacheLRU({ name, maxSize: 1, mapNodeValue });
     }
-    throw err(`Unrecognized eviction policy ${eviction}`);
 }
 
 /**
@@ -4721,10 +4530,9 @@ function selector(options) {
     }
     function updateDeps(store, state, deps, executionID) {
         var _a, _b, _c, _d, _e, _f, _g;
-        if (executionID != null &&
-            (isLatestExecution(store, executionID) ||
-                state.version === ((_b = (_a = store.getState()) === null || _a === void 0 ? void 0 : _a.currentTree) === null || _b === void 0 ? void 0 : _b.version) ||
-                state.version === ((_d = (_c = store.getState()) === null || _c === void 0 ? void 0 : _c.nextTree) === null || _d === void 0 ? void 0 : _d.version))) {
+        if ((executionID != null && isLatestExecution(store, executionID)) ||
+            state.version === ((_b = (_a = store.getState()) === null || _a === void 0 ? void 0 : _a.currentTree) === null || _b === void 0 ? void 0 : _b.version) ||
+            state.version === ((_d = (_c = store.getState()) === null || _c === void 0 ? void 0 : _c.nextTree) === null || _d === void 0 ? void 0 : _d.version)) {
             saveDepsToStore(key, deps, store, (_g = (_f = (_e = store.getState()) === null || _e === void 0 ? void 0 : _e.nextTree) === null || _f === void 0 ? void 0 : _f.version) !== null && _g !== void 0 ? _g : store.getState().currentTree.version);
         }
         for (const nodeKey of deps) {
@@ -4989,7 +4797,8 @@ function selector(options) {
         discoveredDependencyNodeKeys.clear();
         invalidateSelector(treeState);
         cache.clear();
-        markRecoilValueModified(store, recoilValue);
+        // Don't call markRecoilValueModified here as it causes nested state updates
+        // The caller (like refreshRecoilValue) should handle marking as dirty
     }
     if (set != null) {
         const selectorSet = (store, state, newValue) => {
@@ -5480,12 +5289,7 @@ function getCache(eviction, maxSize, mapKey) {
 }
 
 /**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @oncall recoil
+ * TypeScript port of Recoil_atomFamily.js
  */
 function atomFamily(options) {
     var _a, _b;
@@ -5595,12 +5399,7 @@ function constSelector(constant) {
 }
 
 /**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @oncall recoil
+ * TypeScript port of Recoil_errorSelector.js
  */
 const throwingSelector = selectorFamily({
     key: '__error',
@@ -5616,14 +5415,7 @@ function errorSelector(message) {
 }
 
 /**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * Wraps another recoil value and prevents writing to it.
- *
- * @oncall recoil
+ * TypeScript port of Recoil_readOnlySelector.js
  */
 function readOnlySelector(atom) {
     return atom;
@@ -5684,11 +5476,21 @@ const waitForAny = selectorFamily({
         const deps = unwrapDependencies(dependencies);
         const [results, exceptions] = concurrentRequests(get, deps);
         if (exceptions.some(exp => !isPromise(exp))) {
+            // If all are errors (no promises), waitForAny should throw the first error
+            if (exceptions.every(exp => isError(exp))) {
+                const firstError = exceptions.find(isError);
+                if (firstError) {
+                    throw firstError;
+                }
+            }
             return wrapLoadables(dependencies, results, exceptions);
         }
-        return new Promise(resolve => {
+        return new Promise((resolve, reject) => {
+            let pendingCount = 0;
+            let settledCount = 0;
             for (const [i, exp] of exceptions.entries()) {
                 if (isPromise(exp)) {
+                    pendingCount++;
                     exp
                         .then(result => {
                         results[i] = result;
@@ -5697,7 +5499,18 @@ const waitForAny = selectorFamily({
                     })
                         .catch(error => {
                         exceptions[i] = error;
-                        resolve(wrapLoadables(dependencies, results, exceptions));
+                        settledCount++;
+                        // Only resolve with error if ALL promises have settled/failed
+                        if (settledCount === pendingCount) {
+                            // All promises have settled with errors, so reject with the first error
+                            const firstError = exceptions.find(isError);
+                            if (firstError) {
+                                reject(firstError);
+                            }
+                            else {
+                                resolve(wrapLoadables(dependencies, results, exceptions));
+                            }
+                        }
                     });
                 }
             }