@depup/jotai 2.18.1-depup.0 → 2.19.1-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/jotai
 
 | Field | Value |
 |-------|-------|
-| Original | [jotai](https://www.npmjs.com/package/jotai) @ 2.18.1 |
-| Processed | 2026-03-09 |
+| Original | [jotai](https://www.npmjs.com/package/jotai) @ 2.19.1 |
+| Processed | 2026-04-07 |
 | Smoke test | failed |
 | Deps updated | 0 |
 

package/benchmarks/diamond.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/benchmarks/read-write.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/benchmarks/run-all.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/benchmarks/select-atom.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/benchmarks/subscription.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/benchmarks/wide-fan-out.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-03-09T16:26:15.981Z",
+  "timestamp": "2026-04-07T16:33:27.833Z",
   "totalUpdated": 0
 }

package/esm/react/useAtomValue.d.mts

@@ -1,6 +1,7 @@
 import type { Atom, ExtractAtomValue } from 'jotai/vanilla';
 import { useStore } from './Provider.mjs';
 type Options = Parameters<typeof useStore>[0] & {
+    /** @deprecated delay option is deprecated and will be removed in v3. https://github.com/pmndrs/jotai/pull/3264 */
     delay?: number;
     unstable_promiseStatus?: boolean;
 };

package/esm/react.mjs

@@ -134,6 +134,28 @@ function useAtomValue(atom, options) {
         }
       }
       if (typeof delay === "number") {
+        console.warn(`[DEPRECATED] delay option is deprecated and will be removed in v3.
+
+Migration guide:
+
+Create a custom hook like the following.
+
+function useAtomValueWithDelay<Value>(
+  atom: Atom<Value>,
+  options: { delay: number },
+): Value {
+  const { delay } = options
+  const store = useStore(options)
+  const [value, setValue] = useState(() => store.get(atom))
+  useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      setTimeout(() => setValue(store.get(atom)), delay)
+    })
+    return unsub
+  }, [store, atom, delay])
+  return value
+}
+`);
         setTimeout(rerender, delay);
         return;
       }

package/esm/vanilla/internals.d.mts

@@ -1,8 +1,11 @@
-import type { Atom, WritableAtom } from './atom.mjs';
+import { type Atom, type WritableAtom } from './atom.mjs';
 type AnyValue = unknown;
 type AnyError = unknown;
 type AnyAtom = Atom<AnyValue>;
 type AnyWritableAtom = WritableAtom<AnyValue, unknown[], unknown>;
+type WritableAtomWithOnMount<Value, Args extends unknown[], Result> = Omit<WritableAtom<Value, Args, Result>, 'onMount'> & {
+    onMount: NonNullable<WritableAtom<Value, Args, Result>['onMount']>;
+};
 type OnUnmount = () => void;
 type EpochNumber = number;
 /**
@@ -27,6 +30,8 @@ type AtomState<Value = AnyValue> = {
     readonly p: Set<AnyAtom>;
     /** The epoch number of the atom. */
     n: EpochNumber;
+    /** The store epoch number that last validated the atom. */
+    m?: EpochNumber;
     /** Atom value */
     v?: Value;
     /** Atom error */
@@ -71,7 +76,7 @@ type Callbacks = SetLike<() => void>;
 type AtomRead = <Value>(store: Store, atom: Atom<Value>, ...params: Parameters<Atom<Value>['read']>) => Value;
 type AtomWrite = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...params: Parameters<WritableAtom<Value, Args, Result>['write']>) => Result;
 type AtomOnInit = <Value>(store: Store, atom: Atom<Value>) => void;
-type AtomOnMount = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;
+type AtomOnMount = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtomWithOnMount<Value, Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;
 type EnsureAtomState = <Value>(store: Store, atom: Atom<Value>) => AtomState<Value>;
 type FlushCallbacks = (store: Store) => void;
 type RecomputeInvalidatedAtoms = (store: Store) => void;
@@ -89,6 +94,7 @@ type EnhanceBuildingBlocks = (buildingBlocks: Readonly<BuildingBlocks>) => Reado
 type AbortHandlersMap = WeakMapLike<PromiseLike<unknown>, Set<() => void>>;
 type RegisterAbortHandler = <T>(store: Store, promise: PromiseLike<T>, abortHandler: () => void) => void;
 type AbortPromise = <T>(store: Store, promise: PromiseLike<T>) => void;
+type StoreEpochHolder = [n: EpochNumber];
 type Store = {
     get: <Value>(atom: Atom<Value>) => Value;
     set: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
@@ -122,7 +128,8 @@ type BuildingBlocks = [
     enhanceBuildingBlocks: EnhanceBuildingBlocks | undefined,
     abortHandlersMap: AbortHandlersMap,
     registerAbortHandler: RegisterAbortHandler,
-    abortPromise: AbortPromise
+    abortPromise: AbortPromise,
+    storeEpochHolder: StoreEpochHolder
 ];
 export type { AtomState as INTERNAL_AtomState, Mounted as INTERNAL_Mounted, AtomStateMap as INTERNAL_AtomStateMap, MountedMap as INTERNAL_MountedMap, InvalidatedAtoms as INTERNAL_InvalidatedAtoms, ChangedAtoms as INTERNAL_ChangedAtoms, Callbacks as INTERNAL_Callbacks, AtomRead as INTERNAL_AtomRead, AtomWrite as INTERNAL_AtomWrite, AtomOnInit as INTERNAL_AtomOnInit, AtomOnMount as INTERNAL_AtomOnMount, EnsureAtomState as INTERNAL_EnsureAtomState, FlushCallbacks as INTERNAL_FlushCallbacks, RecomputeInvalidatedAtoms as INTERNAL_RecomputeInvalidatedAtoms, ReadAtomState as INTERNAL_ReadAtomState, InvalidateDependents as INTERNAL_InvalidateDependents, WriteAtomState as INTERNAL_WriteAtomState, MountDependencies as INTERNAL_MountDependencies, MountAtom as INTERNAL_MountAtom, UnmountAtom as INTERNAL_UnmountAtom, Store as INTERNAL_Store, BuildingBlocks as INTERNAL_BuildingBlocks, StoreHooks as INTERNAL_StoreHooks, };
 declare function hasInitialValue<T extends Atom<AnyValue>>(atom: T): atom is T & (T extends Atom<infer Value> ? {

package/esm/vanilla/internals.mjs

@@ -4,6 +4,9 @@ function hasInitialValue(atom) {
 function isActuallyWritableAtom(atom) {
   return !!atom.write;
 }
+function hasOnMount(atom) {
+  return !!atom.onMount;
+}
 function isAtomStateInitialized(atomState) {
   return "v" in atomState || "e" in atomState;
 }
@@ -27,13 +30,18 @@ function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
   }
 }
 function getMountedOrPendingDependents(atom, atomState, mountedMap) {
-  var _a;
-  const dependents = /* @__PURE__ */ new Set();
-  for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) {
-    dependents.add(a);
+  const mounted = mountedMap.get(atom);
+  const mountedDependents = mounted == null ? void 0 : mounted.t;
+  const pendingDependents = atomState.p;
+  if (!(mountedDependents == null ? void 0 : mountedDependents.size)) {
+    return pendingDependents;
+  }
+  if (!pendingDependents.size) {
+    return mountedDependents;
   }
-  for (const atomWithPendingPromise of atomState.p) {
-    dependents.add(atomWithPendingPromise);
+  const dependents = new Set(mountedDependents);
+  for (const a of pendingDependents) {
+    dependents.add(a);
   }
   return dependents;
 }
@@ -109,6 +117,7 @@ const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
   return atomState;
 };
 const BUILDING_BLOCK_flushCallbacks = (store) => {
+  var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
@@ -116,6 +125,9 @@ const BUILDING_BLOCK_flushCallbacks = (store) => {
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
   const recomputeInvalidatedAtoms = buildingBlocks[13];
+  if (!storeHooks.f && !changedAtoms.size && !mountCallbacks.size && !unmountCallbacks.size) {
+    return;
+  }
   const errors = [];
   const call = (fn) => {
     try {
@@ -129,17 +141,26 @@ const BUILDING_BLOCK_flushCallbacks = (store) => {
       call(storeHooks.f);
     }
     const callbacks = /* @__PURE__ */ new Set();
-    const add = callbacks.add.bind(callbacks);
-    changedAtoms.forEach((atom) => {
-      var _a;
-      return (_a = mountedMap.get(atom)) == null ? void 0 : _a.l.forEach(add);
-    });
+    for (const atom of changedAtoms) {
+      const listeners = (_a = mountedMap.get(atom)) == null ? void 0 : _a.l;
+      if (listeners) {
+        for (const listener of listeners) {
+          callbacks.add(listener);
+        }
+      }
+    }
     changedAtoms.clear();
-    unmountCallbacks.forEach(add);
+    for (const fn of unmountCallbacks) {
+      callbacks.add(fn);
+    }
     unmountCallbacks.clear();
-    mountCallbacks.forEach(add);
+    for (const fn of mountCallbacks) {
+      callbacks.add(fn);
+    }
     mountCallbacks.clear();
-    callbacks.forEach(call);
+    for (const fn of callbacks) {
+      call(fn);
+    }
     if (changedAtoms.size) {
       recomputeInvalidatedAtoms(store);
     }
@@ -156,36 +177,51 @@ const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
   const ensureAtomState = buildingBlocks[11];
   const readAtomState = buildingBlocks[14];
   const mountDependencies = buildingBlocks[17];
-  const topSortedReversed = [];
+  if (!changedAtoms.size) {
+    return;
+  }
+  const sortedReversedAtoms = [];
+  const sortedReversedStates = [];
   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);
+  const stackAtoms = [];
+  const stackStates = [];
+  for (const atom of changedAtoms) {
+    stackAtoms.push(atom);
+    stackStates.push(ensureAtomState(store, atom));
+  }
+  while (stackAtoms.length) {
+    const top = stackAtoms.length - 1;
+    const a = stackAtoms[top];
+    const aState = stackStates[top];
     if (visited.has(a)) {
-      stack.pop();
+      stackAtoms.pop();
+      stackStates.pop();
       continue;
     }
     if (visiting.has(a)) {
       if (invalidatedAtoms.get(a) === aState.n) {
-        topSortedReversed.push([a, aState]);
+        sortedReversedAtoms.push(a);
+        sortedReversedStates.push(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();
+      stackAtoms.pop();
+      stackStates.pop();
       continue;
     }
     visiting.add(a);
     for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
       if (!visiting.has(d)) {
-        stack.push(d);
+        stackAtoms.push(d);
+        stackStates.push(ensureAtomState(store, d));
       }
     }
   }
-  for (let i = topSortedReversed.length - 1; i >= 0; --i) {
-    const [a, aState] = topSortedReversed[i];
+  for (let i = sortedReversedAtoms.length - 1; i >= 0; --i) {
+    const a = sortedReversedAtoms[i];
+    const aState = sortedReversedStates[i];
     let hasChangedDeps = false;
     for (const dep of aState.d.keys()) {
       if (dep !== a && changedAtoms.has(dep)) {
@@ -218,9 +254,19 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
   const mountDependencies = buildingBlocks[17];
   const setAtomStateValueOrPromise = buildingBlocks[20];
   const registerAbortHandler = buildingBlocks[26];
+  const storeEpochHolder = buildingBlocks[28];
   const atomState = ensureAtomState(store, atom);
+  const storeEpochNumber = storeEpochHolder[0];
   if (isAtomStateInitialized(atomState)) {
-    if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
+    if (
+      // If the atom is mounted, we can use cached atom state,
+      // because it should have been updated by dependencies.
+      // We can't use the cache if the atom is invalidated.
+      mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n || // If atom is not mounted, we can use cached atom state,
+      // only if store hasn't been mutated.
+      atomState.m === storeEpochNumber
+    ) {
+      atomState.m = storeEpochNumber;
       return atomState;
     }
     let hasChangedDeps = false;
@@ -231,17 +277,15 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
       }
     }
     if (!hasChangedDeps) {
+      atomState.m = storeEpochNumber;
       return atomState;
     }
   }
   let isSync = true;
   const prevDeps = new Set(atomState.d.keys());
-  const nextDeps = /* @__PURE__ */ new Map();
   const pruneDependencies = () => {
     for (const a of prevDeps) {
-      if (!nextDeps.has(a)) {
-        atomState.d.delete(a);
-      }
+      atomState.d.delete(a);
     }
   };
   const mountDependenciesIfAsync = () => {
@@ -271,7 +315,7 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
     try {
       return returnAtomValue(aState);
     } finally {
-      nextDeps.set(a, aState.n);
+      prevDeps.delete(a);
       atomState.d.set(a, aState.n);
       if (isPromiseLike(atomState.v)) {
         addPendingPromiseToDependency(atom, atomState.v, aState);
@@ -344,11 +388,13 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
       pruneDependencies();
     }
     (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
+    atomState.m = storeEpochNumber;
     return atomState;
   } catch (error) {
     delete atomState.v;
     atomState.e = error;
     ++atomState.n;
+    atomState.m = storeEpochNumber;
     return atomState;
   } finally {
     isSync = false;
@@ -390,6 +436,7 @@ const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
   const writeAtomState = buildingBlocks[16];
   const mountDependencies = buildingBlocks[17];
   const setAtomStateValueOrPromise = buildingBlocks[20];
+  const storeEpochHolder = buildingBlocks[28];
   let isSync = true;
   const getter = (a) => returnAtomValue(readAtomState(store, a));
   const setter = (a, ...args2) => {
@@ -408,6 +455,7 @@ const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
         setAtomStateValueOrPromise(store, a, v);
         mountDependencies(store, a);
         if (prevEpochNumber !== aState.n) {
+          ++storeEpochHolder[0];
           changedAtoms.add(a);
           invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
@@ -441,7 +489,7 @@ const BUILDING_BLOCK_mountDependencies = (store, atom) => {
   const unmountAtom = buildingBlocks[19];
   const atomState = ensureAtomState(store, atom);
   const mounted = mountedMap.get(atom);
-  if (mounted) {
+  if (mounted && atomState.d.size > 0) {
     for (const [a, n] of atomState.d) {
       if (!mounted.d.has(a)) {
         const aState = ensureAtomState(store, a);
@@ -491,7 +539,7 @@ const BUILDING_BLOCK_mountAtom = (store, atom) => {
       t: /* @__PURE__ */ new Set()
     };
     mountedMap.set(atom, mounted);
-    if (isActuallyWritableAtom(atom)) {
+    if (isActuallyWritableAtom(atom) && hasOnMount(atom)) {
       const processOnMount = () => {
         let isSync = true;
         const setAtom = (...args) => {
@@ -712,7 +760,9 @@ function buildStore(...buildArgs) {
     /* @__PURE__ */ new WeakMap(),
     // abortHandlersMap
     BUILDING_BLOCK_registerAbortHandler,
-    BUILDING_BLOCK_abortPromise
+    BUILDING_BLOCK_abortPromise,
+    // store epoch
+    [0]
   ].map((fn, i) => buildArgs[i] || fn);
   buildingBlockMap.set(store, Object.freeze(buildingBlocks));
   return store;

package/esm/vanilla/utils/atomWithObservable.d.mts

@@ -17,7 +17,7 @@ type SubscribableObservable<T> = {
     subscribe(next: (value: T) => void): Subscription;
 };
 type SymbolObservable<T> = {
-    [Symbol.observable]: () => SubscribableObservable<T>;
+    [key: symbol]: () => SubscribableObservable<T>;
 };
 type ObservableLike<T> = SubscribableObservable<T> | SymbolObservable<T>;
 type SubjectLike<T> = ObservableLike<T> & Observer<T>;

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@depup/jotai",
-  "description": "[DepUp] 👻 Primitive and flexible state management for React",
-  "private": false,
+  "description": "👻 Primitive and flexible state management for React (with updated dependencies)",
   "type": "commonjs",
-  "version": "2.18.1-depup.0",
+  "version": "2.19.1-depup.0",
   "main": "./index.js",
   "types": "./index.d.ts",
   "typesVersions": {
@@ -64,7 +63,9 @@
     }
   },
   "files": [
-    "**"
+    "**",
+    "changes.json",
+    "README.md"
   ],
   "sideEffects": false,
   "engines": {
@@ -75,10 +76,12 @@
     "url": "git+https://github.com/pmndrs/jotai.git"
   },
   "keywords": [
-    "depup",
-    "dependency-bumped",
-    "updated-deps",
     "jotai",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
     "react",
     "state",
     "manager",
@@ -118,8 +121,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "jotai",
-    "originalVersion": "2.18.1",
-    "processedAt": "2026-03-09T16:26:16.914Z",
+    "originalVersion": "2.19.1",
+    "processedAt": "2026-04-07T16:33:28.631Z",
     "smokeTest": "failed"
   }
 }

package/react/useAtomValue.d.ts

@@ -1,6 +1,7 @@
 import type { Atom, ExtractAtomValue } from 'jotai/vanilla';
 import { useStore } from './Provider';
 type Options = Parameters<typeof useStore>[0] & {
+    /** @deprecated delay option is deprecated and will be removed in v3. https://github.com/pmndrs/jotai/pull/3264 */
     delay?: number;
     unstable_promiseStatus?: boolean;
 };

package/react.js

@@ -136,6 +136,7 @@ function useAtomValue(atom, options) {
         } catch (_unused) {}
       }
       if (typeof delay === 'number') {
+        console.warn("[DEPRECATED] delay option is deprecated and will be removed in v3.\n\nMigration guide:\n\nCreate a custom hook like the following.\n\nfunction useAtomValueWithDelay<Value>(\n  atom: Atom<Value>,\n  options: { delay: number },\n): Value {\n  const { delay } = options\n  const store = useStore(options)\n  const [value, setValue] = useState(() => store.get(atom))\n  useEffect(() => {\n    const unsub = store.sub(atom, () => {\n      setTimeout(() => setValue(store.get(atom)), delay)\n    })\n    return unsub\n  }, [store, atom, delay])\n  return value\n}\n");
         setTimeout(rerender, delay);
         return;
       }

package/system/react.development.js

@@ -160,6 +160,28 @@ System.register(['react', 'jotai/vanilla', 'jotai/vanilla/internals'], (function
               }
             }
             if (typeof delay === "number") {
+              console.warn(`[DEPRECATED] delay option is deprecated and will be removed in v3.
+
+Migration guide:
+
+Create a custom hook like the following.
+
+function useAtomValueWithDelay<Value>(
+  atom: Atom<Value>,
+  options: { delay: number },
+): Value {
+  const { delay } = options
+  const store = useStore(options)
+  const [value, setValue] = useState(() => store.get(atom))
+  useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      setTimeout(() => setValue(store.get(atom)), delay)
+    })
+    return unsub
+  }, [store, atom, delay])
+  return value
+}
+`);
               setTimeout(rerender, delay);
               return;
             }

package/system/react.production.js

@@ -1,2 +1,23 @@
 'use client';
-System.register(["react","jotai/vanilla","jotai/vanilla/internals"],(function(V){"use strict";var y,k,p,v,d,C,E,j,m,x,P,w;return{setters:[function(s){y=s.createContext,k=s.useContext,p=s.useRef,v=s.createElement,d=s.default,C=s.useReducer,E=s.useEffect,j=s.useDebugValue,m=s.useCallback},function(s){x=s.getDefaultStore,P=s.createStore},function(s){w=s.INTERNAL_getBuildingBlocksRev2}],execute:(function(){V({Provider:L,useAtom:_,useAtomValue:D,useSetAtom:N,useStore:S});const s=y(void 0);function S(t){const e=k(s);return(t==null?void 0:t.store)||e||x()}function L({children:t,store:e}){const n=p(null);return e?v(s.Provider,{value:e},t):(n.current===null&&(n.current=P()),v(s.Provider,{value:n.current},t))}const h=t=>typeof(t==null?void 0:t.then)=="function",A=t=>{t.status||(t.status="pending",t.then(e=>{t.status="fulfilled",t.value=e},e=>{t.status="rejected",t.reason=e}))},T=d.use||(t=>{if(t.status==="pending")throw t;if(t.status==="fulfilled")return t.value;throw t.status==="rejected"?t.reason:(A(t),t)}),b=new WeakMap,B=(t,e,n)=>{const c=w(t)[26];let r=b.get(e);return r||(r=new Promise((f,g)=>{let l=e;const i=u=>R=>{l===u&&f(R)},a=u=>R=>{l===u&&g(R)},o=()=>{try{const u=n();h(u)?(b.set(u,r),l=u,u.then(i(u),a(u)),c(t,u,o)):f(u)}catch(u){g(u)}};e.then(i(e),a(e)),c(t,e,o)}),b.set(e,r)),r};function D(t,e){const{delay:n,unstable_promiseStatus:c=!d.use}=e||{},r=S(e),[[f,g,l],i]=C(o=>{const u=r.get(t);return Object.is(o[0],u)&&o[1]===r&&o[2]===t?o:[u,r,t]},void 0,()=>[r.get(t),r,t]);let a=f;if((g!==r||l!==t)&&(i(),a=r.get(t)),E(()=>{const o=r.sub(t,()=>{if(c)try{const u=r.get(t);h(u)&&A(B(r,u,()=>r.get(t)))}catch(u){}if(typeof n=="number"){setTimeout(i,n);return}i()});return i(),o},[r,t,n,c]),j(a),h(a)){const o=B(r,a,()=>r.get(t));return c&&A(o),T(o)}return a}function N(t,e){const n=S(e);return m((...c)=>n.set(t,...c),[n,t])}function _(t,e){return[D(t,e),N(t,e)]}})}}));
+System.register(["react","jotai/vanilla","jotai/vanilla/internals"],(function(B){"use strict";var S,p,E,d,v,V,R,k,C,w,D,P;return{setters:[function(n){S=n.createContext,p=n.useContext,E=n.useRef,d=n.createElement,v=n.default,V=n.useReducer,R=n.useEffect,k=n.useDebugValue,C=n.useCallback},function(n){w=n.getDefaultStore,D=n.createStore},function(n){P=n.INTERNAL_getBuildingBlocksRev2}],execute:(function(){B({Provider:N,useAtom:I,useAtomValue:j,useSetAtom:x,useStore:m});const n=S(void 0);function m(t){const e=p(n);return(t==null?void 0:t.store)||e||w()}function N({children:t,store:e}){const o=E(null);return e?d(n.Provider,{value:e},t):(o.current===null&&(o.current=D()),d(n.Provider,{value:o.current},t))}const b=t=>typeof(t==null?void 0:t.then)=="function",h=t=>{t.status||(t.status="pending",t.then(e=>{t.status="fulfilled",t.value=e},e=>{t.status="rejected",t.reason=e}))},_=v.use||(t=>{if(t.status==="pending")throw t;if(t.status==="fulfilled")return t.value;throw t.status==="rejected"?t.reason:(h(t),t)}),y=new WeakMap,T=(t,e,o)=>{const a=P(t)[26];let u=y.get(e);return u||(u=new Promise((f,g)=>{let l=e;const i=s=>A=>{l===s&&f(A)},c=s=>A=>{l===s&&g(A)},r=()=>{try{const s=o();b(s)?(y.set(s,u),l=s,s.then(i(s),c(s)),a(t,s,r)):f(s)}catch(s){g(s)}};e.then(i(e),c(e)),a(t,e,r)}),y.set(e,u)),u};function j(t,e){const{delay:o,unstable_promiseStatus:a=!v.use}=e||{},u=m(e),[[f,g,l],i]=V(r=>{const s=u.get(t);return Object.is(r[0],s)&&r[1]===u&&r[2]===t?r:[s,u,t]},void 0,()=>[u.get(t),u,t]);let c=f;if((g!==u||l!==t)&&(i(),c=u.get(t)),R(()=>{const r=u.sub(t,()=>{if(a)try{const s=u.get(t);b(s)&&h(T(u,s,()=>u.get(t)))}catch(s){}if(typeof o=="number"){console.warn(`[DEPRECATED] delay option is deprecated and will be removed in v3.
+
+Migration guide:
+
+Create a custom hook like the following.
+
+function useAtomValueWithDelay<Value>(
+  atom: Atom<Value>,
+  options: { delay: number },
+): Value {
+  const { delay } = options
+  const store = useStore(options)
+  const [value, setValue] = useState(() => store.get(atom))
+  useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      setTimeout(() => setValue(store.get(atom)), delay)
+    })
+    return unsub
+  }, [store, atom, delay])
+  return value
+}
+`),setTimeout(i,o);return}i()});return i(),r},[u,t,o,a]),k(c),b(c)){const r=T(u,c,()=>u.get(t));return a&&h(r),_(r)}return c}function x(t,e){const o=m(e);return C((...a)=>o.set(t,...a),[o,t])}function I(t,e){return[j(t,e),x(t,e)]}})}}));