@storybook/react-native 10.2.2-alpha.5 → 10.2.2-next.6

package/dist/index.js

@@ -51,6 +51,9 @@ var Platform = {
       return true;
     }
     return false;
+  },
+  get Version() {
+    return "0.0.0";
   }
 };
 var Platform_default = Platform;
@@ -91,609 +94,716 @@ var import_react_native_theming = require("@storybook/react-native-theming");
 var import_react3 = __toESM(require("react"));
 var import_react_native2 = require("react-native");
 
-// ../../node_modules/jotai/esm/vanilla.mjs
+// ../../node_modules/jotai/esm/vanilla/internals.mjs
 var import_meta = {};
-var keyCount = 0;
-function atom(read, write) {
-  const key = `atom${++keyCount}`;
-  const config = {
-    toString: () => key
-  };
-  if (typeof read === "function") {
-    config.read = read;
-  } else {
-    config.init = read;
-    config.read = function(get) {
-      return get(this);
-    };
-    config.write = function(get, set, arg) {
-      return set(
-        this,
-        typeof arg === "function" ? arg(get(this)) : arg
-      );
+function hasInitialValue(atom2) {
+  return "init" in atom2;
+}
+function isActuallyWritableAtom(atom2) {
+  return !!atom2.write;
+}
+function isAtomStateInitialized(atomState) {
+  return "v" in atomState || "e" in atomState;
+}
+function returnAtomValue(atomState) {
+  if ("e" in atomState) {
+    throw atomState.e;
+  }
+  if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !("v" in atomState)) {
+    throw new Error("[Bug] atom state is not initialized");
+  }
+  return atomState.v;
+}
+var promiseStateMap = /* @__PURE__ */ new WeakMap();
+function isPendingPromise(value) {
+  var _a;
+  return isPromiseLike(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
+}
+function abortPromise(promise) {
+  const promiseState = promiseStateMap.get(promise);
+  if (promiseState == null ? void 0 : promiseState[0]) {
+    promiseState[0] = false;
+    promiseState[1].forEach((fn) => fn());
+  }
+}
+function registerAbortHandler(promise, abortHandler) {
+  let promiseState = promiseStateMap.get(promise);
+  if (!promiseState) {
+    promiseState = [true, /* @__PURE__ */ new Set()];
+    promiseStateMap.set(promise, promiseState);
+    const settle = () => {
+      promiseState[0] = false;
     };
+    promise.then(settle, settle);
   }
-  if (write) {
-    config.write = write;
+  promiseState[1].add(abortHandler);
+}
+function isPromiseLike(p) {
+  return typeof (p == null ? void 0 : p.then) === "function";
+}
+function addPendingPromiseToDependency(atom2, promise, dependencyAtomState) {
+  if (!dependencyAtomState.p.has(atom2)) {
+    dependencyAtomState.p.add(atom2);
+    const cleanup = () => dependencyAtomState.p.delete(atom2);
+    promise.then(cleanup, cleanup);
   }
-  return config;
 }
-var hasInitialValue = (atom2) => "init" in atom2;
-var isActuallyWritableAtom = (atom2) => !!atom2.write;
-var cancelPromiseMap = /* @__PURE__ */ new WeakMap();
-var registerCancelPromise = (promise, cancel) => {
-  cancelPromiseMap.set(promise, cancel);
-  promise.catch(() => {
-  }).finally(() => cancelPromiseMap.delete(promise));
-};
-var cancelPromise = (promise, next) => {
-  const cancel = cancelPromiseMap.get(promise);
-  if (cancel) {
-    cancelPromiseMap.delete(promise);
-    cancel(next);
+function getMountedOrPendingDependents(atom2, atomState, mountedMap) {
+  var _a;
+  const dependents = /* @__PURE__ */ new Set();
+  for (const a of ((_a = mountedMap.get(atom2)) == null ? void 0 : _a.t) || []) {
+    dependents.add(a);
   }
+  for (const atomWithPendingPromise of atomState.p) {
+    dependents.add(atomWithPendingPromise);
+  }
+  return dependents;
+}
+var BUILDING_BLOCK_atomRead = (_store, atom2, ...params) => atom2.read(...params);
+var BUILDING_BLOCK_atomWrite = (_store, atom2, ...params) => atom2.write(...params);
+var BUILDING_BLOCK_atomOnInit = (store, atom2) => {
+  var _a;
+  return (_a = atom2.INTERNAL_onInit) == null ? void 0 : _a.call(atom2, store);
 };
-var resolvePromise = (promise, value) => {
-  promise.status = "fulfilled";
-  promise.value = value;
-};
-var rejectPromise = (promise, e) => {
-  promise.status = "rejected";
-  promise.reason = e;
+var BUILDING_BLOCK_atomOnMount = (_store, atom2, setAtom) => {
+  var _a;
+  return (_a = atom2.onMount) == null ? void 0 : _a.call(atom2, setAtom);
 };
-var isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
-var isEqualAtomValue = (a, b) => !!a && "v" in a && "v" in b && Object.is(a.v, b.v);
-var isEqualAtomError = (a, b) => !!a && "e" in a && "e" in b && Object.is(a.e, b.e);
-var hasPromiseAtomValue = (a) => !!a && "v" in a && a.v instanceof Promise;
-var isEqualPromiseAtomValue = (a, b) => "v" in a && "v" in b && a.v.orig && a.v.orig === b.v.orig;
-var returnAtomValue = (atomState) => {
-  if ("e" in atomState) {
-    throw atomState.e;
+var BUILDING_BLOCK_ensureAtomState = (store, atom2) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const atomStateMap = buildingBlocks[0];
+  const storeHooks = buildingBlocks[6];
+  const atomOnInit = buildingBlocks[9];
+  if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !atom2) {
+    throw new Error("Atom is undefined or null");
   }
-  return atomState.v;
-};
-var createStore = () => {
-  const atomStateMap = /* @__PURE__ */ new WeakMap();
-  const mountedMap = /* @__PURE__ */ new WeakMap();
-  const pendingMap = /* @__PURE__ */ new Map();
-  let storeListenersRev2;
-  let mountedAtoms;
-  if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-    storeListenersRev2 = /* @__PURE__ */ new Set();
-    mountedAtoms = /* @__PURE__ */ new Set();
+  let atomState = atomStateMap.get(atom2);
+  if (!atomState) {
+    atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
+    atomStateMap.set(atom2, atomState);
+    (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom2);
+    atomOnInit == null ? void 0 : atomOnInit(store, atom2);
   }
-  const getAtomState = (atom2) => atomStateMap.get(atom2);
-  const setAtomState = (atom2, atomState) => {
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      Object.freeze(atomState);
+  return atomState;
+};
+var BUILDING_BLOCK_flushCallbacks = (store) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const changedAtoms = buildingBlocks[3];
+  const mountCallbacks = buildingBlocks[4];
+  const unmountCallbacks = buildingBlocks[5];
+  const storeHooks = buildingBlocks[6];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const errors = [];
+  const call = (fn) => {
+    try {
+      fn();
+    } catch (e) {
+      errors.push(e);
     }
-    const prevAtomState = atomStateMap.get(atom2);
-    atomStateMap.set(atom2, atomState);
-    if (!pendingMap.has(atom2)) {
-      pendingMap.set(atom2, prevAtomState);
+  };
+  do {
+    if (storeHooks.f) {
+      call(storeHooks.f);
+    }
+    const callbacks = /* @__PURE__ */ new Set();
+    const add = callbacks.add.bind(callbacks);
+    changedAtoms.forEach((atom2) => {
+      var _a;
+      return (_a = mountedMap.get(atom2)) == null ? void 0 : _a.l.forEach(add);
+    });
+    changedAtoms.clear();
+    unmountCallbacks.forEach(add);
+    unmountCallbacks.clear();
+    mountCallbacks.forEach(add);
+    mountCallbacks.clear();
+    callbacks.forEach(call);
+    if (changedAtoms.size) {
+      recomputeInvalidatedAtoms(store);
+    }
+  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
+  if (errors.length) {
+    throw new AggregateError(errors);
+  }
+};
+var BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const changedAtoms = buildingBlocks[3];
+  const ensureAtomState = buildingBlocks[11];
+  const readAtomState = buildingBlocks[14];
+  const mountDependencies = buildingBlocks[17];
+  const topSortedReversed = [];
+  const visiting = /* @__PURE__ */ new WeakSet();
+  const visited = /* @__PURE__ */ new WeakSet();
+  const stack = Array.from(changedAtoms);
+  while (stack.length) {
+    const a = stack[stack.length - 1];
+    const aState = ensureAtomState(store, a);
+    if (visited.has(a)) {
+      stack.pop();
+      continue;
     }
-    if (hasPromiseAtomValue(prevAtomState)) {
-      const next = "v" in atomState ? atomState.v instanceof Promise ? atomState.v : Promise.resolve(atomState.v) : Promise.reject(atomState.e);
-      if (prevAtomState.v !== next) {
-        cancelPromise(prevAtomState.v, next);
+    if (visiting.has(a)) {
+      if (invalidatedAtoms.get(a) === aState.n) {
+        topSortedReversed.push([a, aState]);
+      } else if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && invalidatedAtoms.has(a)) {
+        throw new Error("[Bug] invalidated atom exists");
       }
+      visited.add(a);
+      stack.pop();
+      continue;
     }
-  };
-  const updateDependencies = (atom2, nextAtomState, nextDependencies) => {
-    const dependencies = /* @__PURE__ */ new Map();
-    let changed = false;
-    nextDependencies.forEach((aState, a) => {
-      if (!aState && a === atom2) {
-        aState = nextAtomState;
+    visiting.add(a);
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      if (!visiting.has(d)) {
+        stack.push(d);
       }
-      if (aState) {
-        dependencies.set(a, aState);
-        if (nextAtomState.d.get(a) !== aState) {
-          changed = true;
-        }
-      } else if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-        console.warn("[Bug] atom state not found");
+    }
+  }
+  for (let i = topSortedReversed.length - 1; i >= 0; --i) {
+    const [a, aState] = topSortedReversed[i];
+    let hasChangedDeps = false;
+    for (const dep of aState.d.keys()) {
+      if (dep !== a && changedAtoms.has(dep)) {
+        hasChangedDeps = true;
+        break;
       }
-    });
-    if (changed || nextAtomState.d.size !== dependencies.size) {
-      nextAtomState.d = dependencies;
     }
-  };
-  const setAtomValue = (atom2, value, nextDependencies) => {
-    const prevAtomState = getAtomState(atom2);
-    const nextAtomState = {
-      d: (prevAtomState == null ? void 0 : prevAtomState.d) || /* @__PURE__ */ new Map(),
-      v: value
-    };
-    if (nextDependencies) {
-      updateDependencies(atom2, nextAtomState, nextDependencies);
+    if (hasChangedDeps) {
+      readAtomState(store, a);
+      mountDependencies(store, a);
     }
-    if (isEqualAtomValue(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {
-      return prevAtomState;
+    invalidatedAtoms.delete(a);
+  }
+};
+var storeMutationSet = /* @__PURE__ */ new WeakSet();
+var BUILDING_BLOCK_readAtomState = (store, atom2) => {
+  var _a, _b;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const atomRead = buildingBlocks[7];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
+  const atomState = ensureAtomState(store, atom2);
+  if (isAtomStateInitialized(atomState)) {
+    if (mountedMap.has(atom2) && invalidatedAtoms.get(atom2) !== atomState.n) {
+      return atomState;
     }
-    if (hasPromiseAtomValue(prevAtomState) && hasPromiseAtomValue(nextAtomState) && isEqualPromiseAtomValue(prevAtomState, nextAtomState)) {
-      if (prevAtomState.d === nextAtomState.d) {
-        return prevAtomState;
-      } else {
-        nextAtomState.v = prevAtomState.v;
+    let hasChangedDeps = false;
+    for (const [a, n] of atomState.d) {
+      if (readAtomState(store, a).n !== n) {
+        hasChangedDeps = true;
+        break;
       }
     }
-    setAtomState(atom2, nextAtomState);
-    return nextAtomState;
-  };
-  const setAtomValueOrPromise = (atom2, valueOrPromise, nextDependencies, abortPromise) => {
-    if (isPromiseLike(valueOrPromise)) {
-      let continuePromise;
-      const updatePromiseDependencies = () => {
-        const prevAtomState = getAtomState(atom2);
-        if (!hasPromiseAtomValue(prevAtomState) || prevAtomState.v !== promise) {
-          return;
-        }
-        const nextAtomState = setAtomValue(
-          atom2,
-          promise,
-          nextDependencies
-        );
-        if (mountedMap.has(atom2) && prevAtomState.d !== nextAtomState.d) {
-          mountDependencies(atom2, nextAtomState, prevAtomState.d);
-        }
-      };
-      const promise = new Promise((resolve, reject) => {
-        let settled = false;
-        valueOrPromise.then(
-          (v) => {
-            if (!settled) {
-              settled = true;
-              resolvePromise(promise, v);
-              resolve(v);
-              updatePromiseDependencies();
-            }
-          },
-          (e) => {
-            if (!settled) {
-              settled = true;
-              rejectPromise(promise, e);
-              reject(e);
-              updatePromiseDependencies();
-            }
-          }
-        );
-        continuePromise = (next) => {
-          if (!settled) {
-            settled = true;
-            next.then(
-              (v) => resolvePromise(promise, v),
-              (e) => rejectPromise(promise, e)
-            );
-            resolve(next);
-          }
-        };
-      });
-      promise.orig = valueOrPromise;
-      promise.status = "pending";
-      registerCancelPromise(promise, (next) => {
-        if (next) {
-          continuePromise(next);
-        }
-        abortPromise == null ? void 0 : abortPromise();
-      });
-      return setAtomValue(atom2, promise, nextDependencies);
+    if (!hasChangedDeps) {
+      return atomState;
     }
-    return setAtomValue(atom2, valueOrPromise, nextDependencies);
-  };
-  const setAtomError = (atom2, error, nextDependencies) => {
-    const prevAtomState = getAtomState(atom2);
-    const nextAtomState = {
-      d: (prevAtomState == null ? void 0 : prevAtomState.d) || /* @__PURE__ */ new Map(),
-      e: error
-    };
-    if (nextDependencies) {
-      updateDependencies(atom2, nextAtomState, nextDependencies);
+  }
+  atomState.d.clear();
+  let isSync = true;
+  function mountDependenciesIfAsync() {
+    if (mountedMap.has(atom2)) {
+      mountDependencies(store, atom2);
+      recomputeInvalidatedAtoms(store);
+      flushCallbacks(store);
     }
-    if (isEqualAtomError(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {
-      return prevAtomState;
+  }
+  function getter(a) {
+    var _a2;
+    if (a === atom2) {
+      const aState2 = ensureAtomState(store, a);
+      if (!isAtomStateInitialized(aState2)) {
+        if (hasInitialValue(a)) {
+          setAtomStateValueOrPromise(store, a, a.init);
+        } else {
+          throw new Error("no atom init");
+        }
+      }
+      return returnAtomValue(aState2);
     }
-    setAtomState(atom2, nextAtomState);
-    return nextAtomState;
-  };
-  const readAtomState = (atom2, force) => {
-    const atomState = getAtomState(atom2);
-    if (!force && atomState) {
+    const aState = readAtomState(store, a);
+    try {
+      return returnAtomValue(aState);
+    } finally {
+      atomState.d.set(a, aState.n);
+      if (isPendingPromise(atomState.v)) {
+        addPendingPromiseToDependency(atom2, atomState.v, aState);
+      }
       if (mountedMap.has(atom2)) {
-        return atomState;
+        (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom2);
       }
-      if (Array.from(atomState.d).every(([a, s]) => {
-        if (a === atom2) {
-          return true;
-        }
-        const aState = readAtomState(a);
-        return aState === s || isEqualAtomValue(aState, s);
-      })) {
-        return atomState;
+      if (!isSync) {
+        mountDependenciesIfAsync();
       }
     }
-    const nextDependencies = /* @__PURE__ */ new Map();
-    let isSync = true;
-    const getter = (a) => {
-      if (a === atom2) {
-        const aState2 = getAtomState(a);
-        if (aState2) {
-          nextDependencies.set(a, aState2);
-          return returnAtomValue(aState2);
-        }
-        if (hasInitialValue(a)) {
-          nextDependencies.set(a, void 0);
-          return a.init;
-        }
-        throw new Error("no atom init");
+  }
+  let controller;
+  let setSelf;
+  const options = {
+    get signal() {
+      if (!controller) {
+        controller = new AbortController();
       }
-      const aState = readAtomState(a);
-      nextDependencies.set(a, aState);
-      return returnAtomValue(aState);
-    };
-    let controller;
-    let setSelf;
-    const options = {
-      get signal() {
-        if (!controller) {
-          controller = new AbortController();
-        }
-        return controller.signal;
-      },
-      get setSelf() {
-        if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom2)) {
-          console.warn("setSelf function cannot be used with read-only atom");
-        }
-        if (!setSelf && isActuallyWritableAtom(atom2)) {
-          setSelf = (...args) => {
-            if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && isSync) {
-              console.warn("setSelf function cannot be called in sync");
-            }
-            if (!isSync) {
-              return writeAtom(atom2, ...args);
+      return controller.signal;
+    },
+    get setSelf() {
+      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
+        console.warn(
+          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
+        );
+      }
+      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom2)) {
+        console.warn("setSelf function cannot be used with read-only atom");
+      }
+      if (!setSelf && isActuallyWritableAtom(atom2)) {
+        setSelf = (...args) => {
+          if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && isSync) {
+            console.warn("setSelf function cannot be called in sync");
+          }
+          if (!isSync) {
+            try {
+              return writeAtomState(store, atom2, ...args);
+            } finally {
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
-          };
-        }
-        return setSelf;
+          }
+        };
       }
-    };
-    try {
-      const valueOrPromise = atom2.read(getter, options);
-      return setAtomValueOrPromise(
-        atom2,
-        valueOrPromise,
-        nextDependencies,
-        () => controller == null ? void 0 : controller.abort()
-      );
-    } catch (error) {
-      return setAtomError(atom2, error, nextDependencies);
-    } finally {
-      isSync = false;
+      return setSelf;
     }
   };
-  const readAtom = (atom2) => returnAtomValue(readAtomState(atom2));
-  const addAtom = (atom2) => {
-    let mounted = mountedMap.get(atom2);
-    if (!mounted) {
-      mounted = mountAtom(atom2);
+  const prevEpochNumber = atomState.n;
+  try {
+    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
+      storeMutationSet.delete(store);
     }
-    return mounted;
-  };
-  const canUnmountAtom = (atom2, mounted) => !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom2));
-  const delAtom = (atom2) => {
-    const mounted = mountedMap.get(atom2);
-    if (mounted && canUnmountAtom(atom2, mounted)) {
-      unmountAtom(atom2);
+    const valueOrPromise = atomRead(store, atom2, getter, options);
+    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
+      console.warn(
+        "Detected store mutation during atom read. This is not supported."
+      );
     }
-  };
-  const recomputeDependents = (atom2) => {
-    const dependencyMap = /* @__PURE__ */ new Map();
-    const dirtyMap = /* @__PURE__ */ new WeakMap();
-    const getDependents = (a) => {
-      var _a;
-      const dependents = new Set((_a = mountedMap.get(a)) == null ? void 0 : _a.t);
-      pendingMap.forEach((_, pendingAtom) => {
-        var _a2;
-        if ((_a2 = getAtomState(pendingAtom)) == null ? void 0 : _a2.d.has(a)) {
-          dependents.add(pendingAtom);
-        }
-      });
-      return dependents;
-    };
-    const loop1 = (a) => {
-      getDependents(a).forEach((dependent) => {
-        if (dependent !== a) {
-          dependencyMap.set(
-            dependent,
-            (dependencyMap.get(dependent) || /* @__PURE__ */ new Set()).add(a)
-          );
-          dirtyMap.set(dependent, (dirtyMap.get(dependent) || 0) + 1);
-          loop1(dependent);
-        }
-      });
-    };
-    loop1(atom2);
-    const loop2 = (a) => {
-      getDependents(a).forEach((dependent) => {
-        var _a;
-        if (dependent !== a) {
-          let dirtyCount = dirtyMap.get(dependent);
-          if (dirtyCount) {
-            dirtyMap.set(dependent, --dirtyCount);
-          }
-          if (!dirtyCount) {
-            let isChanged = !!((_a = dependencyMap.get(dependent)) == null ? void 0 : _a.size);
-            if (isChanged) {
-              const prevAtomState = getAtomState(dependent);
-              const nextAtomState = readAtomState(dependent, true);
-              isChanged = !isEqualAtomValue(prevAtomState, nextAtomState);
-            }
-            if (!isChanged) {
-              dependencyMap.forEach((s) => s.delete(dependent));
-            }
-          }
-          loop2(dependent);
-        }
-      });
-    };
-    loop2(atom2);
-  };
-  const writeAtomState = (atom2, ...args) => {
-    let isSync = true;
-    const getter = (a) => returnAtomValue(readAtomState(a));
-    const setter = (a, ...args2) => {
-      let r;
+    setAtomStateValueOrPromise(store, atom2, valueOrPromise);
+    if (isPromiseLike(valueOrPromise)) {
+      registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
+      valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
+    }
+    (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom2);
+    return atomState;
+  } catch (error) {
+    delete atomState.v;
+    atomState.e = error;
+    ++atomState.n;
+    return atomState;
+  } finally {
+    isSync = false;
+    if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom2) === prevEpochNumber) {
+      invalidatedAtoms.set(atom2, atomState.n);
+      changedAtoms.add(atom2);
+      (_b = storeHooks.c) == null ? void 0 : _b.call(storeHooks, atom2);
+    }
+  }
+};
+var BUILDING_BLOCK_invalidateDependents = (store, atom2) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const ensureAtomState = buildingBlocks[11];
+  const stack = [atom2];
+  while (stack.length) {
+    const a = stack.pop();
+    const aState = ensureAtomState(store, a);
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      const dState = ensureAtomState(store, d);
+      invalidatedAtoms.set(d, dState.n);
+      stack.push(d);
+    }
+  }
+};
+var BUILDING_BLOCK_writeAtomState = (store, atom2, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const atomWrite = buildingBlocks[8];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const invalidateDependents = buildingBlocks[15];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
+  let isSync = true;
+  const getter = (a) => returnAtomValue(readAtomState(store, a));
+  const setter = (a, ...args2) => {
+    var _a;
+    const aState = ensureAtomState(store, a);
+    try {
       if (a === atom2) {
         if (!hasInitialValue(a)) {
           throw new Error("atom not writable");
         }
-        const prevAtomState = getAtomState(a);
-        const nextAtomState = setAtomValueOrPromise(a, args2[0]);
-        if (!isEqualAtomValue(prevAtomState, nextAtomState)) {
-          recomputeDependents(a);
+        if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
+          storeMutationSet.add(store);
+        }
+        const prevEpochNumber = aState.n;
+        const v = args2[0];
+        setAtomStateValueOrPromise(store, a, v);
+        mountDependencies(store, a);
+        if (prevEpochNumber !== aState.n) {
+          changedAtoms.add(a);
+          invalidateDependents(store, a);
+          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
         }
+        return void 0;
       } else {
-        r = writeAtomState(a, ...args2);
+        return writeAtomState(store, a, ...args2);
       }
+    } finally {
       if (!isSync) {
-        const flushed = flushPending();
-        if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-          storeListenersRev2.forEach(
-            (l) => l({ type: "async-write", flushed })
-          );
-        }
+        recomputeInvalidatedAtoms(store);
+        flushCallbacks(store);
       }
-      return r;
-    };
-    const result = atom2.write(getter, setter, ...args);
-    isSync = false;
-    return result;
-  };
-  const writeAtom = (atom2, ...args) => {
-    const result = writeAtomState(atom2, ...args);
-    const flushed = flushPending();
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      storeListenersRev2.forEach(
-        (l) => l({ type: "write", flushed })
-      );
     }
-    return result;
   };
-  const mountAtom = (atom2, initialDependent, onMountQueue) => {
-    var _a;
-    const queue = onMountQueue || [];
-    (_a = getAtomState(atom2)) == null ? void 0 : _a.d.forEach((_, a) => {
-      const aMounted = mountedMap.get(a);
-      if (aMounted) {
+  try {
+    return atomWrite(store, atom2, getter, setter, ...args);
+  } finally {
+    isSync = false;
+  }
+};
+var BUILDING_BLOCK_mountDependencies = (store, atom2) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const ensureAtomState = buildingBlocks[11];
+  const invalidateDependents = buildingBlocks[15];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom2);
+  const mounted = mountedMap.get(atom2);
+  if (mounted && !isPendingPromise(atomState.v)) {
+    for (const [a, n] of atomState.d) {
+      if (!mounted.d.has(a)) {
+        const aState = ensureAtomState(store, a);
+        const aMounted = mountAtom(store, a);
         aMounted.t.add(atom2);
-      } else {
-        if (a !== atom2) {
-          mountAtom(a, atom2, queue);
+        mounted.d.add(a);
+        if (n !== aState.n) {
+          changedAtoms.add(a);
+          invalidateDependents(store, a);
+          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
         }
       }
-    });
-    readAtomState(atom2);
-    const mounted = {
-      t: new Set(initialDependent && [initialDependent]),
-      l: /* @__PURE__ */ new Set()
-    };
-    mountedMap.set(atom2, mounted);
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      mountedAtoms.add(atom2);
-    }
-    if (isActuallyWritableAtom(atom2) && atom2.onMount) {
-      const { onMount } = atom2;
-      queue.push(() => {
-        const onUnmount = onMount((...args) => writeAtom(atom2, ...args));
-        if (onUnmount) {
-          mounted.u = onUnmount;
-        }
-      });
     }
-    if (!onMountQueue) {
-      queue.forEach((f) => f());
-    }
-    return mounted;
-  };
-  const unmountAtom = (atom2) => {
-    var _a;
-    const onUnmount = (_a = mountedMap.get(atom2)) == null ? void 0 : _a.u;
-    if (onUnmount) {
-      onUnmount();
+    for (const a of mounted.d) {
+      if (!atomState.d.has(a)) {
+        mounted.d.delete(a);
+        const aMounted = unmountAtom(store, a);
+        aMounted == null ? void 0 : aMounted.t.delete(atom2);
+      }
     }
-    mountedMap.delete(atom2);
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      mountedAtoms.delete(atom2);
+  }
+};
+var BUILDING_BLOCK_mountAtom = (store, atom2) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const mountCallbacks = buildingBlocks[4];
+  const storeHooks = buildingBlocks[6];
+  const atomOnMount = buildingBlocks[10];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountAtom = buildingBlocks[18];
+  const atomState = ensureAtomState(store, atom2);
+  let mounted = mountedMap.get(atom2);
+  if (!mounted) {
+    readAtomState(store, atom2);
+    for (const a of atomState.d.keys()) {
+      const aMounted = mountAtom(store, a);
+      aMounted.t.add(atom2);
     }
-    const atomState = getAtomState(atom2);
-    if (atomState) {
-      if (hasPromiseAtomValue(atomState)) {
-        cancelPromise(atomState.v);
-      }
-      atomState.d.forEach((_, a) => {
-        if (a !== atom2) {
-          const mounted = mountedMap.get(a);
-          if (mounted) {
-            mounted.t.delete(atom2);
-            if (canUnmountAtom(a, mounted)) {
-              unmountAtom(a);
+    mounted = {
+      l: /* @__PURE__ */ new Set(),
+      d: new Set(atomState.d.keys()),
+      t: /* @__PURE__ */ new Set()
+    };
+    mountedMap.set(atom2, mounted);
+    if (isActuallyWritableAtom(atom2)) {
+      const processOnMount = () => {
+        let isSync = true;
+        const setAtom = (...args) => {
+          try {
+            return writeAtomState(store, atom2, ...args);
+          } finally {
+            if (!isSync) {
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
+        };
+        try {
+          const onUnmount = atomOnMount(store, atom2, setAtom);
+          if (onUnmount) {
+            mounted.u = () => {
+              isSync = true;
+              try {
+                onUnmount();
+              } finally {
+                isSync = false;
+              }
+            };
+          }
+        } finally {
+          isSync = false;
         }
-      });
-    } else if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      console.warn("[Bug] could not find atom state to unmount", atom2);
+      };
+      mountCallbacks.add(processOnMount);
     }
-  };
-  const mountDependencies = (atom2, atomState, prevDependencies) => {
-    const depSet = new Set(atomState.d.keys());
-    const maybeUnmountAtomSet = /* @__PURE__ */ new Set();
-    prevDependencies == null ? void 0 : prevDependencies.forEach((_, a) => {
-      if (depSet.has(a)) {
-        depSet.delete(a);
-        return;
-      }
-      maybeUnmountAtomSet.add(a);
-      const mounted = mountedMap.get(a);
-      if (mounted) {
-        mounted.t.delete(atom2);
-      }
-    });
-    depSet.forEach((a) => {
-      const mounted = mountedMap.get(a);
-      if (mounted) {
-        mounted.t.add(atom2);
-      } else if (mountedMap.has(atom2)) {
-        mountAtom(a, atom2);
-      }
-    });
-    maybeUnmountAtomSet.forEach((a) => {
-      const mounted = mountedMap.get(a);
-      if (mounted && canUnmountAtom(a, mounted)) {
-        unmountAtom(a);
-      }
-    });
-  };
-  const flushPending = () => {
-    let flushed;
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      flushed = /* @__PURE__ */ new Set();
+    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom2);
+  }
+  return mounted;
+};
+var BUILDING_BLOCK_unmountAtom = (store, atom2) => {
+  var _a, _b;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const unmountCallbacks = buildingBlocks[5];
+  const storeHooks = buildingBlocks[6];
+  const ensureAtomState = buildingBlocks[11];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom2);
+  let mounted = mountedMap.get(atom2);
+  if (!mounted || mounted.l.size) {
+    return mounted;
+  }
+  let isDependent = false;
+  for (const a of mounted.t) {
+    if ((_a = mountedMap.get(a)) == null ? void 0 : _a.d.has(atom2)) {
+      isDependent = true;
+      break;
     }
-    while (pendingMap.size) {
-      const pending = Array.from(pendingMap);
-      pendingMap.clear();
-      pending.forEach(([atom2, prevAtomState]) => {
-        const atomState = getAtomState(atom2);
-        if (atomState) {
-          const mounted = mountedMap.get(atom2);
-          if (mounted && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
-            mountDependencies(atom2, atomState, prevAtomState == null ? void 0 : prevAtomState.d);
-          }
-          if (mounted && !// TODO This seems pretty hacky. Hope to fix it.
-          // Maybe we could `mountDependencies` in `setAtomState`?
-          (!hasPromiseAtomValue(prevAtomState) && (isEqualAtomValue(prevAtomState, atomState) || isEqualAtomError(prevAtomState, atomState)))) {
-            mounted.l.forEach((listener) => listener());
-            if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-              flushed.add(atom2);
-            }
-          }
-        } else if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-          console.warn("[Bug] no atom state to flush");
-        }
-      });
+  }
+  if (!isDependent) {
+    if (mounted.u) {
+      unmountCallbacks.add(mounted.u);
     }
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      return flushed;
+    mounted = void 0;
+    mountedMap.delete(atom2);
+    for (const a of atomState.d.keys()) {
+      const aMounted = unmountAtom(store, a);
+      aMounted == null ? void 0 : aMounted.t.delete(atom2);
     }
-  };
-  const subscribeAtom = (atom2, listener) => {
-    const mounted = addAtom(atom2);
-    const flushed = flushPending();
-    const listeners = mounted.l;
-    listeners.add(listener);
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-      storeListenersRev2.forEach(
-        (l) => l({ type: "sub", flushed })
+    (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom2);
+    return void 0;
+  }
+  return mounted;
+};
+var BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom2, valueOrPromise) => {
+  const ensureAtomState = getInternalBuildingBlocks(store)[11];
+  const atomState = ensureAtomState(store, atom2);
+  const hasPrevValue = "v" in atomState;
+  const prevValue = atomState.v;
+  if (isPromiseLike(valueOrPromise)) {
+    for (const a of atomState.d.keys()) {
+      addPendingPromiseToDependency(
+        atom2,
+        valueOrPromise,
+        ensureAtomState(store, a)
       );
     }
-    return () => {
-      listeners.delete(listener);
-      delAtom(atom2);
-      if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-        storeListenersRev2.forEach((l) => l({ type: "unsub" }));
-      }
-    };
-  };
-  if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-    return {
-      get: readAtom,
-      set: writeAtom,
-      sub: subscribeAtom,
-      // store dev methods (these are tentative and subject to change without notice)
-      dev_subscribe_store: (l, rev) => {
-        if (rev !== 2) {
-          throw new Error("The current StoreListener revision is 2.");
-        }
-        storeListenersRev2.add(l);
-        return () => {
-          storeListenersRev2.delete(l);
-        };
-      },
-      dev_get_mounted_atoms: () => mountedAtoms.values(),
-      dev_get_atom_state: (a) => atomStateMap.get(a),
-      dev_get_mounted: (a) => mountedMap.get(a),
-      dev_restore_atoms: (values) => {
-        for (const [atom2, valueOrPromise] of values) {
-          if (hasInitialValue(atom2)) {
-            setAtomValueOrPromise(atom2, valueOrPromise);
-            recomputeDependents(atom2);
-          }
-        }
-        const flushed = flushPending();
-        storeListenersRev2.forEach(
-          (l) => l({ type: "restore", flushed })
-        );
-      }
-    };
   }
-  return {
-    get: readAtom,
-    set: writeAtom,
-    sub: subscribeAtom
+  atomState.v = valueOrPromise;
+  delete atomState.e;
+  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+    ++atomState.n;
+    if (isPromiseLike(prevValue)) {
+      abortPromise(prevValue);
+    }
+  }
+};
+var BUILDING_BLOCK_storeGet = (store, atom2) => {
+  const readAtomState = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState(store, atom2));
+};
+var BUILDING_BLOCK_storeSet = (store, atom2, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const writeAtomState = buildingBlocks[16];
+  try {
+    return writeAtomState(store, atom2, ...args);
+  } finally {
+    recomputeInvalidatedAtoms(store);
+    flushCallbacks(store);
+  }
+};
+var BUILDING_BLOCK_storeSub = (store, atom2, listener) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const flushCallbacks = buildingBlocks[12];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const mounted = mountAtom(store, atom2);
+  const listeners = mounted.l;
+  listeners.add(listener);
+  flushCallbacks(store);
+  return () => {
+    listeners.delete(listener);
+    unmountAtom(store, atom2);
+    flushCallbacks(store);
   };
 };
-var defaultStore;
-if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
-  if (typeof globalThis.__NUMBER_OF_JOTAI_INSTANCES__ === "number") {
-    ++globalThis.__NUMBER_OF_JOTAI_INSTANCES__;
+var buildingBlockMap = /* @__PURE__ */ new WeakMap();
+var getInternalBuildingBlocks = (store) => {
+  const buildingBlocks = buildingBlockMap.get(store);
+  if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !buildingBlocks) {
+    throw new Error(
+      "Store must be created by buildStore to read its building blocks"
+    );
+  }
+  return buildingBlocks;
+};
+function buildStore(...buildArgs) {
+  const store = {
+    get(atom2) {
+      const storeGet = getInternalBuildingBlocks(store)[21];
+      return storeGet(store, atom2);
+    },
+    set(atom2, ...args) {
+      const storeSet = getInternalBuildingBlocks(store)[22];
+      return storeSet(store, atom2, ...args);
+    },
+    sub(atom2, listener) {
+      const storeSub = getInternalBuildingBlocks(store)[23];
+      return storeSub(store, atom2, listener);
+    }
+  };
+  const buildingBlocks = [
+    // store state
+    /* @__PURE__ */ new WeakMap(),
+    // atomStateMap
+    /* @__PURE__ */ new WeakMap(),
+    // mountedMap
+    /* @__PURE__ */ new WeakMap(),
+    // invalidatedAtoms
+    /* @__PURE__ */ new Set(),
+    // changedAtoms
+    /* @__PURE__ */ new Set(),
+    // mountCallbacks
+    /* @__PURE__ */ new Set(),
+    // unmountCallbacks
+    {},
+    // storeHooks
+    // atom interceptors
+    BUILDING_BLOCK_atomRead,
+    BUILDING_BLOCK_atomWrite,
+    BUILDING_BLOCK_atomOnInit,
+    BUILDING_BLOCK_atomOnMount,
+    // building-block functions
+    BUILDING_BLOCK_ensureAtomState,
+    BUILDING_BLOCK_flushCallbacks,
+    BUILDING_BLOCK_recomputeInvalidatedAtoms,
+    BUILDING_BLOCK_readAtomState,
+    BUILDING_BLOCK_invalidateDependents,
+    BUILDING_BLOCK_writeAtomState,
+    BUILDING_BLOCK_mountDependencies,
+    BUILDING_BLOCK_mountAtom,
+    BUILDING_BLOCK_unmountAtom,
+    BUILDING_BLOCK_setAtomStateValueOrPromise,
+    BUILDING_BLOCK_storeGet,
+    BUILDING_BLOCK_storeSet,
+    BUILDING_BLOCK_storeSub,
+    void 0
+  ].map((fn, i) => buildArgs[i] || fn);
+  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
+  return store;
+}
+
+// ../../node_modules/jotai/esm/vanilla.mjs
+var import_meta2 = {};
+var keyCount = 0;
+function atom(read, write) {
+  const key = `atom${++keyCount}`;
+  const config = {
+    toString() {
+      return (import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
+    }
+  };
+  if (typeof read === "function") {
+    config.read = read;
   } else {
-    globalThis.__NUMBER_OF_JOTAI_INSTANCES__ = 1;
+    config.init = read;
+    config.read = defaultRead;
+    config.write = defaultWrite;
+  }
+  if (write) {
+    config.write = write;
   }
+  return config;
+}
+function defaultRead(get) {
+  return get(this);
+}
+function defaultWrite(get, set, arg) {
+  return set(
+    this,
+    typeof arg === "function" ? arg(get(this)) : arg
+  );
+}
+var overriddenCreateStore;
+function createStore() {
+  if (overriddenCreateStore) {
+    return overriddenCreateStore();
+  }
+  return buildStore();
 }
-var getDefaultStore = () => {
+var defaultStore;
+function getDefaultStore() {
   if (!defaultStore) {
     defaultStore = createStore();
+    if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production") {
+      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
+      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
+        console.warn(
+          "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
+        );
+      }
+    }
   }
   return defaultStore;
-};
+}
 
 // ../../node_modules/jotai/esm/react.mjs
 var import_react = __toESM(require("react"), 1);
-var import_meta2 = {};
-var StoreContext = (0, import_react.createContext)(void 0);
-var useStore = (options) => {
+var import_meta3 = {};
+var StoreContext = (0, import_react.createContext)(
+  void 0
+);
+function useStore(options) {
   const store = (0, import_react.useContext)(StoreContext);
   return (options == null ? void 0 : options.store) || store || getDefaultStore();
-};
+}
 var isPromiseLike2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
-var use = import_react.default.use || ((promise) => {
-  if (promise.status === "pending") {
-    throw promise;
-  } else if (promise.status === "fulfilled") {
-    return promise.value;
-  } else if (promise.status === "rejected") {
-    throw promise.reason;
-  } else {
+var attachPromiseStatus = (promise) => {
+  if (!promise.status) {
     promise.status = "pending";
     promise.then(
       (v) => {
@@ -705,10 +815,61 @@ var use = import_react.default.use || ((promise) => {
         promise.reason = e;
       }
     );
+  }
+};
+var use = import_react.default.use || // A shim for older React versions
+((promise) => {
+  if (promise.status === "pending") {
+    throw promise;
+  } else if (promise.status === "fulfilled") {
+    return promise.value;
+  } else if (promise.status === "rejected") {
+    throw promise.reason;
+  } else {
+    attachPromiseStatus(promise);
     throw promise;
   }
 });
+var continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+var createContinuablePromise = (promise, getValue) => {
+  let continuablePromise = continuablePromiseMap.get(promise);
+  if (!continuablePromise) {
+    continuablePromise = new Promise((resolve, reject) => {
+      let curr = promise;
+      const onFulfilled = (me) => (v) => {
+        if (curr === me) {
+          resolve(v);
+        }
+      };
+      const onRejected = (me) => (e) => {
+        if (curr === me) {
+          reject(e);
+        }
+      };
+      const onAbort = () => {
+        try {
+          const nextValue = getValue();
+          if (isPromiseLike2(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            registerAbortHandler(nextValue, onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      };
+      promise.then(onFulfilled(promise), onRejected(promise));
+      registerAbortHandler(promise, onAbort);
+    });
+    continuablePromiseMap.set(promise, continuablePromise);
+  }
+  return continuablePromise;
+};
 function useAtomValue(atom2, options) {
+  const { delay, unstable_promiseStatus: promiseStatus = !import_react.default.use } = options || {};
   const store = useStore(options);
   const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = (0, import_react.useReducer)(
     (prev) => {
@@ -726,9 +887,19 @@ function useAtomValue(atom2, options) {
     rerender();
     value = store.get(atom2);
   }
-  const delay = options == null ? void 0 : options.delay;
   (0, import_react.useEffect)(() => {
     const unsub = store.sub(atom2, () => {
+      if (promiseStatus) {
+        try {
+          const value2 = store.get(atom2);
+          if (isPromiseLike2(value2)) {
+            attachPromiseStatus(
+              createContinuablePromise(value2, () => store.get(atom2))
+            );
+          }
+        } catch (e) {
+        }
+      }
       if (typeof delay === "number") {
         setTimeout(rerender, delay);
         return;
@@ -737,15 +908,22 @@ function useAtomValue(atom2, options) {
     });
     rerender();
     return unsub;
-  }, [store, atom2, delay]);
+  }, [store, atom2, delay, promiseStatus]);
   (0, import_react.useDebugValue)(value);
-  return isPromiseLike2(value) ? use(value) : value;
+  if (isPromiseLike2(value)) {
+    const promise = createContinuablePromise(value, () => store.get(atom2));
+    if (promiseStatus) {
+      attachPromiseStatus(promise);
+    }
+    return use(promise);
+  }
+  return value;
 }
 function useSetAtom(atom2, options) {
   const store = useStore(options);
   const setAtom = (0, import_react.useCallback)(
     (...args) => {
-      if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && !("write" in atom2)) {
+      if ((import_meta3.env ? import_meta3.env.MODE : void 0) !== "production" && !("write" in atom2)) {
         throw new Error("not writable atom");
       }
       return store.set(atom2, ...args);