@powerhousedao/connect 1.0.0-dev.229 → 1.0.0-dev.231

package/dist/modules/@powerhousedao/reactor-browser/{chunk-D2ZLIUVV.js → chunk-FW7N6EJH.js}

@@ -1,65 +1,7 @@
-// ../../node_modules/.pnpm/jotai@2.11.1_@types+react@18.3.18_react@18.3.1/node_modules/jotai/esm/vanilla.mjs
-var keyCount = 0;
-function atom(read, write) {
-  const key = `atom${++keyCount}`;
-  const config = {
-    toString() {
-      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
-    }
-  };
-  if (typeof read === "function") {
-    config.read = read;
-  } else {
-    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
-  );
-}
+// ../../node_modules/.pnpm/jotai@2.12.2_@types+react@18.3.18_react@18.3.1/node_modules/jotai/esm/vanilla/internals.mjs
 var isSelfAtom = (atom2, a) => atom2.unstable_is ? atom2.unstable_is(a) : a === atom2;
 var hasInitialValue = (atom2) => "init" in atom2;
 var isActuallyWritableAtom = (atom2) => !!atom2.write;
-var cancelablePromiseMap = /* @__PURE__ */ new WeakMap();
-var isPendingPromise = (value) => {
-  var _a;
-  return isPromiseLike(value) && !((_a = cancelablePromiseMap.get(value)) == null ? void 0 : _a[1]);
-};
-var cancelPromise = (promise, nextValue) => {
-  const promiseState = cancelablePromiseMap.get(promise);
-  if (promiseState) {
-    promiseState[1] = true;
-    promiseState[0].forEach((fn) => fn(nextValue));
-  } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-    throw new Error("[Bug] cancelable promise not found");
-  }
-};
-var patchPromiseForCancelability = (promise) => {
-  if (cancelablePromiseMap.has(promise)) {
-    return;
-  }
-  const promiseState = [/* @__PURE__ */ new Set(), false];
-  cancelablePromiseMap.set(promise, promiseState);
-  const settle = () => {
-    promiseState[1] = true;
-  };
-  promise.then(settle, settle);
-  promise.onCancel = (fn) => {
-    promiseState[0].add(fn);
-  };
-};
-var isPromiseLike = (p) => typeof (p == null ? void 0 : p.then) === "function";
 var isAtomStateInitialized = (atomState) => "v" in atomState || "e" in atomState;
 var returnAtomValue = (atomState) => {
   if ("e" in atomState) {
@@ -70,6 +12,31 @@ var returnAtomValue = (atomState) => {
   }
   return atomState.v;
 };
+var promiseStateMap = /* @__PURE__ */ new WeakMap();
+var isPendingPromise = (value) => {
+  var _a;
+  return isPromiseLike(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
+};
+var abortPromise = (promise) => {
+  const promiseState = promiseStateMap.get(promise);
+  if (promiseState == null ? void 0 : promiseState[0]) {
+    promiseState[0] = false;
+    promiseState[1].forEach((fn) => fn());
+  }
+};
+var 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);
+  }
+  promiseState[1].add(abortHandler);
+};
+var isPromiseLike = (p) => typeof (p == null ? void 0 : p.then) === "function";
 var addPendingPromiseToDependency = (atom2, promise, dependencyAtomState) => {
   if (!dependencyAtomState.p.has(atom2)) {
     dependencyAtomState.p.add(atom2);
@@ -83,45 +50,99 @@ var addPendingPromiseToDependency = (atom2, promise, dependencyAtomState) => {
     );
   }
 };
-var addDependency = (atom2, atomState, a, aState) => {
+var setAtomStateValueOrPromise = (atom2, valueOrPromise, ensureAtomState) => {
+  const atomState = ensureAtomState(atom2);
+  const hasPrevValue = "v" in atomState;
+  const prevValue = atomState.v;
+  if (isPromiseLike(valueOrPromise)) {
+    for (const a of atomState.d.keys()) {
+      addPendingPromiseToDependency(atom2, valueOrPromise, ensureAtomState(a));
+    }
+  }
+  atomState.v = valueOrPromise;
+  delete atomState.e;
+  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+    ++atomState.n;
+    if (isPromiseLike(prevValue)) {
+      abortPromise(prevValue);
+    }
+  }
+};
+var getMountedOrPendingDependents = (atom2, atomState, mountedMap) => {
   var _a;
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && a === atom2) {
-    throw new Error("[Bug] atom cannot depend on itself");
+  const dependents = /* @__PURE__ */ new Set();
+  for (const a of ((_a = mountedMap.get(atom2)) == null ? void 0 : _a.t) || []) {
+    if (mountedMap.has(a)) {
+      dependents.add(a);
+    }
   }
-  atomState.d.set(a, aState.n);
-  if (isPendingPromise(atomState.v)) {
-    addPendingPromiseToDependency(atom2, atomState.v, aState);
+  for (const atomWithPendingPromise of atomState.p) {
+    dependents.add(atomWithPendingPromise);
   }
-  (_a = aState.m) == null ? void 0 : _a.t.add(atom2);
+  return dependents;
 };
-var INTERNAL_flushStoreHook = Symbol.for("JOTAI.EXPERIMENTAL.FLUSHSTOREHOOK");
-var buildStore = (...storeArgs) => {
-  const [
-    getAtomState,
-    setAtomState,
-    atomRead,
-    atomWrite,
-    atomOnInit,
-    atomOnMount
-  ] = storeArgs;
-  const ensureAtomState = (atom2) => {
+var createStoreHook = () => {
+  const callbacks = /* @__PURE__ */ new Set();
+  const notify = () => {
+    callbacks.forEach((fn) => fn());
+  };
+  notify.add = (fn) => {
+    callbacks.add(fn);
+    return () => {
+      callbacks.delete(fn);
+    };
+  };
+  return notify;
+};
+var createStoreHookForAtoms = () => {
+  const all = {};
+  const callbacks = /* @__PURE__ */ new WeakMap();
+  const notify = (atom2) => {
+    var _a, _b;
+    (_a = callbacks.get(all)) == null ? void 0 : _a.forEach((fn) => fn(atom2));
+    (_b = callbacks.get(atom2)) == null ? void 0 : _b.forEach((fn) => fn());
+  };
+  notify.add = (atom2, fn) => {
+    const key = atom2 || all;
+    const fns = (callbacks.has(key) ? callbacks : callbacks.set(key, /* @__PURE__ */ new Set())).get(key);
+    fns.add(fn);
+    return () => {
+      fns == null ? void 0 : fns.delete(fn);
+      if (!fns.size) {
+        callbacks.delete(key);
+      }
+    };
+  };
+  return notify;
+};
+var initializeStoreHooks = (storeHooks) => {
+  storeHooks.c || (storeHooks.c = createStoreHookForAtoms());
+  storeHooks.m || (storeHooks.m = createStoreHookForAtoms());
+  storeHooks.u || (storeHooks.u = createStoreHookForAtoms());
+  storeHooks.f || (storeHooks.f = createStoreHook());
+  return storeHooks;
+};
+var BUILDING_BLOCKS = Symbol();
+var buildStore = (atomStateMap = /* @__PURE__ */ new WeakMap(), mountedMap = /* @__PURE__ */ new WeakMap(), invalidatedAtoms = /* @__PURE__ */ new WeakMap(), changedAtoms = /* @__PURE__ */ new Set(), mountCallbacks = /* @__PURE__ */ new Set(), unmountCallbacks = /* @__PURE__ */ new Set(), storeHooks = {}, atomRead = (atom2, ...params) => atom2.read(...params), atomWrite = (atom2, ...params) => atom2.write(...params), atomOnInit = (atom2, store) => {
+  var _a;
+  return (_a = atom2.unstable_onInit) == null ? void 0 : _a.call(atom2, store);
+}, atomOnMount = (atom2, setAtom) => {
+  var _a;
+  return (_a = atom2.onMount) == null ? void 0 : _a.call(atom2, setAtom);
+}, ...buildingBlockFunctions) => {
+  const ensureAtomState = buildingBlockFunctions[0] || ((atom2) => {
     if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !atom2) {
       throw new Error("Atom is undefined or null");
     }
-    let atomState = getAtomState(atom2);
+    let atomState = atomStateMap.get(atom2);
     if (!atomState) {
       atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
-      setAtomState(atom2, atomState);
+      atomStateMap.set(atom2, atomState);
       atomOnInit == null ? void 0 : atomOnInit(atom2, store);
     }
     return atomState;
-  };
-  const invalidatedAtoms = /* @__PURE__ */ new WeakMap();
-  const changedAtoms = /* @__PURE__ */ new Map();
-  const unmountCallbacks = /* @__PURE__ */ new Set();
-  const mountCallbacks = /* @__PURE__ */ new Set();
-  const flushCallbacks = () => {
-    var _a;
+  });
+  const flushCallbacks = buildingBlockFunctions[1] || (() => {
     const errors = [];
     const call = (fn) => {
       try {
@@ -131,12 +152,14 @@ var buildStore = (...storeArgs) => {
       }
     };
     do {
-      (_a = store[INTERNAL_flushStoreHook]) == null ? void 0 : _a.call(store);
+      if (storeHooks.f) {
+        call(storeHooks.f);
+      }
       const callbacks = /* @__PURE__ */ new Set();
       const add = callbacks.add.bind(callbacks);
-      changedAtoms.forEach((atomState) => {
-        var _a2;
-        return (_a2 = atomState.m) == null ? void 0 : _a2.l.forEach(add);
+      changedAtoms.forEach((atom2) => {
+        var _a;
+        return (_a = mountedMap.get(atom2)) == null ? void 0 : _a.l.forEach(add);
       });
       changedAtoms.clear();
       unmountCallbacks.forEach(add);
@@ -149,35 +172,59 @@ var buildStore = (...storeArgs) => {
       }
     } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
     if (errors.length) {
-      throw errors[0];
+      throw new AggregateError(errors);
     }
-  };
-  const setAtomStateValueOrPromise = (atom2, atomState, valueOrPromise) => {
-    const hasPrevValue = "v" in atomState;
-    const prevValue = atomState.v;
-    const pendingPromise = isPendingPromise(atomState.v) ? atomState.v : null;
-    if (isPromiseLike(valueOrPromise)) {
-      patchPromiseForCancelability(valueOrPromise);
-      for (const a of atomState.d.keys()) {
-        addPendingPromiseToDependency(atom2, valueOrPromise, ensureAtomState(a));
+  });
+  const recomputeInvalidatedAtoms = buildingBlockFunctions[2] || (() => {
+    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(a);
+      if (visited.has(a)) {
+        stack.pop();
+        continue;
+      }
+      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;
+      }
+      visiting.add(a);
+      for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+        if (!visiting.has(d)) {
+          stack.push(d);
+        }
       }
-      atomState.v = valueOrPromise;
-    } else {
-      atomState.v = valueOrPromise;
     }
-    delete atomState.e;
-    if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
-      ++atomState.n;
-      if (pendingPromise) {
-        cancelPromise(pendingPromise, valueOrPromise);
+    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 (hasChangedDeps) {
+        readAtomState(a);
+        mountDependencies(a);
+      }
+      invalidatedAtoms.delete(a);
     }
-  };
-  const readAtomState = (atom2) => {
+  });
+  const readAtomState = buildingBlockFunctions[3] || ((atom2) => {
     var _a;
     const atomState = ensureAtomState(atom2);
     if (isAtomStateInitialized(atomState)) {
-      if (atomState.m && invalidatedAtoms.get(atom2) !== atomState.n) {
+      if (mountedMap.has(atom2) && invalidatedAtoms.get(atom2) !== atomState.n) {
         return atomState;
       }
       if (Array.from(atomState.d).every(
@@ -193,18 +240,19 @@ var buildStore = (...storeArgs) => {
     atomState.d.clear();
     let isSync = true;
     const mountDependenciesIfAsync = () => {
-      if (atomState.m) {
-        mountDependencies(atom2, atomState);
+      if (mountedMap.has(atom2)) {
+        mountDependencies(atom2);
         recomputeInvalidatedAtoms();
         flushCallbacks();
       }
     };
     const getter = (a) => {
+      var _a2;
       if (isSelfAtom(atom2, a)) {
         const aState2 = ensureAtomState(a);
         if (!isAtomStateInitialized(aState2)) {
           if (hasInitialValue(a)) {
-            setAtomStateValueOrPromise(a, aState2, a.init);
+            setAtomStateValueOrPromise(a, a.init, ensureAtomState);
           } else {
             throw new Error("no atom init");
           }
@@ -215,7 +263,11 @@ var buildStore = (...storeArgs) => {
       try {
         return returnAtomValue(aState);
       } finally {
-        addDependency(atom2, atomState, a, aState);
+        atomState.d.set(a, aState.n);
+        if (isPendingPromise(atomState.v)) {
+          addPendingPromiseToDependency(atom2, atomState.v, aState);
+        }
+        (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom2);
         if (!isSync) {
           mountDependenciesIfAsync();
         }
@@ -240,19 +292,28 @@ var buildStore = (...storeArgs) => {
               console.warn("setSelf function cannot be called in sync");
             }
             if (!isSync) {
-              return writeAtom(atom2, ...args);
+              try {
+                return writeAtomState(atom2, ...args);
+              } finally {
+                recomputeInvalidatedAtoms();
+                flushCallbacks();
+              }
             }
           };
         }
         return setSelf;
       }
     };
+    const prevEpochNumber = atomState.n;
     try {
       const valueOrPromise = atomRead(atom2, getter, options);
-      setAtomStateValueOrPromise(atom2, atomState, valueOrPromise);
+      setAtomStateValueOrPromise(atom2, valueOrPromise, ensureAtomState);
       if (isPromiseLike(valueOrPromise)) {
-        (_a = valueOrPromise.onCancel) == null ? void 0 : _a.call(valueOrPromise, () => controller == null ? void 0 : controller.abort());
-        valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
+        registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
+        valueOrPromise.then(
+          mountDependenciesIfAsync,
+          mountDependenciesIfAsync
+        );
       }
       return atomState;
     } catch (error) {
@@ -262,89 +323,26 @@ var buildStore = (...storeArgs) => {
       return atomState;
     } finally {
       isSync = false;
-    }
-  };
-  const readAtom = (atom2) => returnAtomValue(readAtomState(atom2));
-  const getMountedOrPendingDependents = (atomState) => {
-    var _a;
-    const dependents = /* @__PURE__ */ new Map();
-    for (const a of ((_a = atomState.m) == null ? void 0 : _a.t) || []) {
-      const aState = ensureAtomState(a);
-      if (aState.m) {
-        dependents.set(a, aState);
-      }
-    }
-    for (const atomWithPendingPromise of atomState.p) {
-      dependents.set(
-        atomWithPendingPromise,
-        ensureAtomState(atomWithPendingPromise)
-      );
-    }
-    return dependents;
-  };
-  const invalidateDependents = (atomState) => {
-    const stack = [atomState];
-    while (stack.length) {
-      const aState = stack.pop();
-      for (const [d, s] of getMountedOrPendingDependents(aState)) {
-        if (!invalidatedAtoms.has(d)) {
-          invalidatedAtoms.set(d, s.n);
-          stack.push(s);
-        }
+      if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom2) === prevEpochNumber) {
+        invalidatedAtoms.set(atom2, atomState.n);
+        changedAtoms.add(atom2);
+        (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, atom2);
       }
     }
-  };
-  const recomputeInvalidatedAtoms = () => {
-    var _a;
-    const topSortedReversed = [];
-    const visiting = /* @__PURE__ */ new WeakSet();
-    const visited = /* @__PURE__ */ new WeakSet();
-    const stack = Array.from(changedAtoms);
+  });
+  const invalidateDependents = buildingBlockFunctions[4] || ((atom2) => {
+    const stack = [atom2];
     while (stack.length) {
-      const [a, aState] = stack[stack.length - 1];
-      if (visited.has(a)) {
-        stack.pop();
-        continue;
-      }
-      if (visiting.has(a)) {
-        if (invalidatedAtoms.get(a) === aState.n) {
-          topSortedReversed.push([a, aState, aState.n]);
-        } else {
-          invalidatedAtoms.delete(a);
-          changedAtoms.set(a, aState);
-        }
-        visited.add(a);
-        stack.pop();
-        continue;
-      }
-      visiting.add(a);
-      for (const [d, s] of getMountedOrPendingDependents(aState)) {
-        if (!visiting.has(d)) {
-          stack.push([d, s]);
-        }
-      }
-    }
-    for (let i = topSortedReversed.length - 1; i >= 0; --i) {
-      const [a, aState, prevEpochNumber] = topSortedReversed[i];
-      let hasChangedDeps = false;
-      for (const dep of aState.d.keys()) {
-        if (dep !== a && changedAtoms.has(dep)) {
-          hasChangedDeps = true;
-          break;
-        }
-      }
-      if (hasChangedDeps) {
-        readAtomState(a);
-        mountDependencies(a, aState);
-        if (prevEpochNumber !== aState.n) {
-          changedAtoms.set(a, aState);
-          (_a = aState.u) == null ? void 0 : _a.call(aState);
-        }
+      const a = stack.pop();
+      const aState = ensureAtomState(a);
+      for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+        const dState = ensureAtomState(d);
+        invalidatedAtoms.set(d, dState.n);
+        stack.push(d);
       }
-      invalidatedAtoms.delete(a);
     }
-  };
-  const writeAtomState = (atom2, ...args) => {
+  });
+  const writeAtomState = buildingBlockFunctions[5] || ((atom2, ...args) => {
     let isSync = true;
     const getter = (a) => returnAtomValue(readAtomState(a));
     const setter = (a, ...args2) => {
@@ -357,12 +355,12 @@ var buildStore = (...storeArgs) => {
           }
           const prevEpochNumber = aState.n;
           const v = args2[0];
-          setAtomStateValueOrPromise(a, aState, v);
-          mountDependencies(a, aState);
+          setAtomStateValueOrPromise(a, v, ensureAtomState);
+          mountDependencies(a);
           if (prevEpochNumber !== aState.n) {
-            changedAtoms.set(a, aState);
-            (_a = aState.u) == null ? void 0 : _a.call(aState);
-            invalidateDependents(aState);
+            changedAtoms.add(a);
+            (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
+            invalidateDependents(a);
           }
           return void 0;
         } else {
@@ -380,56 +378,52 @@ var buildStore = (...storeArgs) => {
     } finally {
       isSync = false;
     }
-  };
-  const writeAtom = (atom2, ...args) => {
-    try {
-      return writeAtomState(atom2, ...args);
-    } finally {
-      recomputeInvalidatedAtoms();
-      flushCallbacks();
-    }
-  };
-  const mountDependencies = (atom2, atomState) => {
+  });
+  const mountDependencies = buildingBlockFunctions[6] || ((atom2) => {
     var _a;
-    if (atomState.m && !isPendingPromise(atomState.v)) {
+    const atomState = ensureAtomState(atom2);
+    const mounted = mountedMap.get(atom2);
+    if (mounted && !isPendingPromise(atomState.v)) {
       for (const [a, n] of atomState.d) {
-        if (!atomState.m.d.has(a)) {
+        if (!mounted.d.has(a)) {
           const aState = ensureAtomState(a);
-          const aMounted = mountAtom(a, aState);
+          const aMounted = mountAtom(a);
           aMounted.t.add(atom2);
-          atomState.m.d.add(a);
+          mounted.d.add(a);
           if (n !== aState.n) {
-            changedAtoms.set(a, aState);
-            (_a = aState.u) == null ? void 0 : _a.call(aState);
-            invalidateDependents(aState);
+            changedAtoms.add(a);
+            (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
+            invalidateDependents(a);
           }
         }
       }
-      for (const a of atomState.m.d || []) {
+      for (const a of mounted.d || []) {
         if (!atomState.d.has(a)) {
-          atomState.m.d.delete(a);
-          const aMounted = unmountAtom(a, ensureAtomState(a));
+          mounted.d.delete(a);
+          const aMounted = unmountAtom(a);
           aMounted == null ? void 0 : aMounted.t.delete(atom2);
         }
       }
     }
-  };
-  const mountAtom = (atom2, atomState) => {
+  });
+  const mountAtom = buildingBlockFunctions[7] || ((atom2) => {
     var _a;
-    if (!atomState.m) {
+    const atomState = ensureAtomState(atom2);
+    let mounted = mountedMap.get(atom2);
+    if (!mounted) {
       readAtomState(atom2);
       for (const a of atomState.d.keys()) {
-        const aMounted = mountAtom(a, ensureAtomState(a));
+        const aMounted = mountAtom(a);
         aMounted.t.add(atom2);
       }
-      atomState.m = {
+      mounted = {
         l: /* @__PURE__ */ new Set(),
         d: new Set(atomState.d.keys()),
         t: /* @__PURE__ */ new Set()
       };
-      (_a = atomState.h) == null ? void 0 : _a.call(atomState);
+      mountedMap.set(atom2, mounted);
+      (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom2);
       if (isActuallyWritableAtom(atom2)) {
-        const mounted = atomState.m;
         const processOnMount = () => {
           let isSync = true;
           const setAtom = (...args) => {
@@ -461,88 +455,149 @@ var buildStore = (...storeArgs) => {
         mountCallbacks.add(processOnMount);
       }
     }
-    return atomState.m;
-  };
-  const unmountAtom = (atom2, atomState) => {
+    return mounted;
+  });
+  const unmountAtom = buildingBlockFunctions[8] || ((atom2) => {
     var _a;
-    if (atomState.m && !atomState.m.l.size && !Array.from(atomState.m.t).some((a) => {
+    const atomState = ensureAtomState(atom2);
+    let mounted = mountedMap.get(atom2);
+    if (mounted && !mounted.l.size && !Array.from(mounted.t).some((a) => {
       var _a2;
-      return (_a2 = ensureAtomState(a).m) == null ? void 0 : _a2.d.has(atom2);
+      return (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.d.has(atom2);
     })) {
-      const onUnmount = atomState.m.u;
-      if (onUnmount) {
-        unmountCallbacks.add(onUnmount);
+      if (mounted.u) {
+        unmountCallbacks.add(mounted.u);
       }
-      delete atomState.m;
-      (_a = atomState.h) == null ? void 0 : _a.call(atomState);
+      mounted = void 0;
+      mountedMap.delete(atom2);
+      (_a = storeHooks.u) == null ? void 0 : _a.call(storeHooks, atom2);
       for (const a of atomState.d.keys()) {
-        const aMounted = unmountAtom(a, ensureAtomState(a));
+        const aMounted = unmountAtom(a);
         aMounted == null ? void 0 : aMounted.t.delete(atom2);
       }
       return void 0;
     }
-    return atomState.m;
-  };
-  const subscribeAtom = (atom2, listener) => {
-    const atomState = ensureAtomState(atom2);
-    const mounted = mountAtom(atom2, atomState);
-    const listeners = mounted.l;
-    listeners.add(listener);
-    flushCallbacks();
-    return () => {
-      listeners.delete(listener);
-      unmountAtom(atom2, atomState);
-      flushCallbacks();
-    };
-  };
-  const unstable_derive = (fn) => buildStore(...fn(...storeArgs));
+    return mounted;
+  });
+  const buildingBlocks = [
+    // store state
+    atomStateMap,
+    mountedMap,
+    invalidatedAtoms,
+    changedAtoms,
+    mountCallbacks,
+    unmountCallbacks,
+    storeHooks,
+    // atom intercepters
+    atomRead,
+    atomWrite,
+    atomOnInit,
+    atomOnMount,
+    // building-block functions
+    ensureAtomState,
+    flushCallbacks,
+    recomputeInvalidatedAtoms,
+    readAtomState,
+    invalidateDependents,
+    writeAtomState,
+    mountDependencies,
+    mountAtom,
+    unmountAtom
+  ];
   const store = {
-    get: readAtom,
-    set: writeAtom,
-    sub: subscribeAtom,
-    unstable_derive
+    get: (atom2) => returnAtomValue(readAtomState(atom2)),
+    set: (atom2, ...args) => {
+      try {
+        return writeAtomState(atom2, ...args);
+      } finally {
+        recomputeInvalidatedAtoms();
+        flushCallbacks();
+      }
+    },
+    sub: (atom2, listener) => {
+      const mounted = mountAtom(atom2);
+      const listeners = mounted.l;
+      listeners.add(listener);
+      flushCallbacks();
+      return () => {
+        listeners.delete(listener);
+        unmountAtom(atom2);
+        flushCallbacks();
+      };
+    }
   };
+  Object.defineProperty(store, BUILDING_BLOCKS, { value: buildingBlocks });
   return store;
 };
-var deriveDevStoreRev4 = (store) => {
-  const debugMountedAtoms = /* @__PURE__ */ new Set();
-  let savedGetAtomState;
+var INTERNAL_buildStoreRev1 = buildStore;
+var INTERNAL_initializeStoreHooks = initializeStoreHooks;
+var INTERNAL_registerAbortHandler = registerAbortHandler;
+
+// ../../node_modules/.pnpm/jotai@2.12.2_@types+react@18.3.18_react@18.3.1/node_modules/jotai/esm/vanilla.mjs
+var keyCount = 0;
+function atom(read, write) {
+  const key = `atom${++keyCount}`;
+  const config = {
+    toString() {
+      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
+    }
+  };
+  if (typeof read === "function") {
+    config.read = read;
+  } else {
+    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 createDevStoreRev4 = () => {
   let inRestoreAtom = 0;
-  const derivedStore = store.unstable_derive((...storeArgs) => {
-    const [getAtomState, setAtomState, , atomWrite] = storeArgs;
-    savedGetAtomState = getAtomState;
-    storeArgs[1] = function devSetAtomState(atom2, atomState) {
-      setAtomState(atom2, atomState);
-      const originalMounted = atomState.h;
-      atomState.h = () => {
-        originalMounted == null ? void 0 : originalMounted();
-        if (atomState.m) {
-          debugMountedAtoms.add(atom2);
-        } else {
-          debugMountedAtoms.delete(atom2);
-        }
-      };
-    };
-    storeArgs[3] = function devAtomWrite(atom2, getter, setter, ...args) {
+  const storeHooks = INTERNAL_initializeStoreHooks({});
+  const atomStateMap = /* @__PURE__ */ new WeakMap();
+  const mountedAtoms = /* @__PURE__ */ new WeakMap();
+  const store = INTERNAL_buildStoreRev1(
+    atomStateMap,
+    mountedAtoms,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    storeHooks,
+    void 0,
+    (atom2, get, set, ...args) => {
       if (inRestoreAtom) {
-        return setter(atom2, ...args);
+        return set(atom2, ...args);
       }
-      return atomWrite(atom2, getter, setter, ...args);
-    };
-    return storeArgs;
+      return atom2.write(get, set, ...args);
+    }
+  );
+  const debugMountedAtoms = /* @__PURE__ */ new Set();
+  storeHooks.m.add(void 0, (atom2) => {
+    debugMountedAtoms.add(atom2);
+    const atomState = atomStateMap.get(atom2);
+    atomState.m = mountedAtoms.get(atom2);
+  });
+  storeHooks.u.add(void 0, (atom2) => {
+    debugMountedAtoms.delete(atom2);
+    const atomState = atomStateMap.get(atom2);
+    delete atomState.m;
   });
-  const savedStoreSet = derivedStore.set;
   const devStore = {
     // store dev methods (these are tentative and subject to change without notice)
-    dev4_get_internal_weak_map: () => ({
-      get: (atom2) => {
-        const atomState = savedGetAtomState(atom2);
-        if (!atomState || atomState.n === 0) {
-          return void 0;
-        }
-        return atomState;
-      }
-    }),
+    dev4_get_internal_weak_map: () => atomStateMap,
     dev4_get_mounted_atoms: () => debugMountedAtoms,
     dev4_restore_atoms: (values) => {
       const restoreAtom = {
@@ -551,7 +606,7 @@ var deriveDevStoreRev4 = (store) => {
           ++inRestoreAtom;
           try {
             for (const [atom2, value] of values) {
-              if (hasInitialValue(atom2)) {
+              if ("init" in atom2) {
                 set(atom2, value);
               }
             }
@@ -560,34 +615,20 @@ var deriveDevStoreRev4 = (store) => {
           }
         }
       };
-      savedStoreSet(restoreAtom);
+      store.set(restoreAtom);
     }
   };
-  return Object.assign(derivedStore, devStore);
+  return Object.assign(store, devStore);
 };
-var createStore = () => {
-  const atomStateMap = /* @__PURE__ */ new WeakMap();
-  const store = buildStore(
-    (atom2) => atomStateMap.get(atom2),
-    (atom2, atomState) => atomStateMap.set(atom2, atomState).get(atom2),
-    (atom2, ...params) => atom2.read(...params),
-    (atom2, ...params) => atom2.write(...params),
-    (atom2, ...params) => {
-      var _a;
-      return (_a = atom2.unstable_onInit) == null ? void 0 : _a.call(atom2, ...params);
-    },
-    (atom2, ...params) => {
-      var _a;
-      return (_a = atom2.onMount) == null ? void 0 : _a.call(atom2, ...params);
-    }
-  );
+function createStore() {
   if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-    return deriveDevStoreRev4(store);
+    return createDevStoreRev4();
   }
+  const store = INTERNAL_buildStoreRev1();
   return store;
-};
+}
 var defaultStore;
-var getDefaultStore = () => {
+function getDefaultStore() {
   if (!defaultStore) {
     defaultStore = createStore();
     if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
@@ -600,17 +641,17 @@ var getDefaultStore = () => {
     }
   }
   return defaultStore;
-};
+}
 
-// ../../node_modules/.pnpm/jotai@2.11.1_@types+react@18.3.18_react@18.3.1/node_modules/jotai/esm/react.mjs
+// ../../node_modules/.pnpm/jotai@2.12.2_@types+react@18.3.18_react@18.3.1/node_modules/jotai/esm/react.mjs
 import ReactExports, { createContext, useContext, useRef, createElement, useReducer, useEffect, useDebugValue, useCallback } from "react";
 var StoreContext = createContext(
   void 0
 );
-var useStore = (options) => {
+function useStore(options) {
   const store = useContext(StoreContext);
   return (options == null ? void 0 : options.store) || store || getDefaultStore();
-};
+}
 var isPromiseLike2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
 var attachPromiseMeta = (promise) => {
   promise.status = "pending";
@@ -638,7 +679,7 @@ var use = ReactExports.use || ((promise) => {
   }
 });
 var continuablePromiseMap = /* @__PURE__ */ new WeakMap();
-var createContinuablePromise = (promise) => {
+var createContinuablePromise = (promise, getValue) => {
   let continuablePromise = continuablePromiseMap.get(promise);
   if (!continuablePromise) {
     continuablePromise = new Promise((resolve, reject) => {
@@ -653,25 +694,23 @@ var createContinuablePromise = (promise) => {
           reject(e);
         }
       };
-      const registerCancelHandler = (p) => {
-        if ("onCancel" in p && typeof p.onCancel === "function") {
-          p.onCancel((nextValue) => {
-            if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && nextValue === p) {
-              throw new Error("[Bug] p is not updated even after cancelation");
-            }
-            if (isPromiseLike2(nextValue)) {
-              continuablePromiseMap.set(nextValue, continuablePromise);
-              curr = nextValue;
-              nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-              registerCancelHandler(nextValue);
-            } else {
-              resolve(nextValue);
-            }
-          });
+      const onAbort = () => {
+        try {
+          const nextValue = getValue();
+          if (isPromiseLike2(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            INTERNAL_registerAbortHandler(nextValue, onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
         }
       };
       promise.then(onFulfilled(promise), onRejected(promise));
-      registerCancelHandler(promise);
+      INTERNAL_registerAbortHandler(promise, onAbort);
     });
     continuablePromiseMap.set(promise, continuablePromise);
   }
@@ -701,7 +740,9 @@ function useAtomValue(atom2, options) {
       if (typeof delay === "number") {
         const value2 = store.get(atom2);
         if (isPromiseLike2(value2)) {
-          attachPromiseMeta(createContinuablePromise(value2));
+          attachPromiseMeta(
+            createContinuablePromise(value2, () => store.get(atom2))
+          );
         }
         setTimeout(rerender, delay);
         return;
@@ -713,7 +754,7 @@ function useAtomValue(atom2, options) {
   }, [store, atom2, delay]);
   useDebugValue(value);
   if (isPromiseLike2(value)) {
-    const promise = createContinuablePromise(value);
+    const promise = createContinuablePromise(value, () => store.get(atom2));
     return use(promise);
   }
   return value;