jotai-state-tree 1.4.3 → 1.4.4

package/dist/{chunk-5OCZ6YLH.mjs → chunk-XA4ACZVI.mjs}

@@ -128,6 +128,41 @@ var StateTreeNode = class {
     this.$parent = parent ?? null;
     this.$path = parent ? `${parent.$path}/${pathSegment}` : "";
     this.valueAtom = atom(initialValue);
+    this.isAliveAtom = atom(true);
+    this.snapshotAtom = atom((get) => {
+      const value = get(this.valueAtom);
+      if (this.$type._kind === "model") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        if (value && typeof value === "object") {
+          for (const key of Object.keys(value)) {
+            if (!this.children.has(key)) {
+              res[key] = value[key];
+            }
+          }
+        }
+        return this.postProcessor ? this.postProcessor(res) : res;
+      }
+      if (this.$type._kind === "array") {
+        const res = [];
+        const childrenKeys = Array.from(this.children.keys()).sort((a, b) => Number(a) - Number(b));
+        for (const key of childrenKeys) {
+          const childNode = this.children.get(key);
+          res.push(get(childNode.snapshotAtom));
+        }
+        return res;
+      }
+      if (this.$type._kind === "map") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        return res;
+      }
+      return value;
+    });
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
     nodeFinalizationRegistry.register(this, this.$id, this);
   }
@@ -319,6 +354,10 @@ var StateTreeNode = class {
     this.children.clear();
     this.unregisterIdentifier();
     this.$isAlive = false;
+    try {
+      globalStore.set(this.isAliveAtom, false);
+    } catch (e) {
+    }
     notifyLifecycleChange(this, false);
     nodeRegistry.delete(this.$id);
     nodeFinalizationRegistry.unregister(this);
@@ -495,6 +534,10 @@ function clearAllRegistries() {
     const node = entry.node.deref();
     if (node) {
       node.$isAlive = false;
+      try {
+        globalStore.set(node.isAliveAtom, false);
+      } catch (e) {
+      }
     }
   }
   nodeRegistry.clear();

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance } from './undo-quCDYz_6.mjs';
-export { L as CustomTypeOptions, aG as IActionRecorder, aH as IActionRecording, C as IAnyComplexType, D as IAnyMixin, aE as IHistoryEntry, F as IJsonPatch, y as IMSTArray, z as IMSTMap, G as IReversibleJsonPatch, x as IStateTreeNode, aF as ITimeTravelManager, aC as IUndoManager, aD as IUndoManagerOptions, H as IValidationContext, K as IValidationError, J as IValidationResult, A as ModelInstance, E as ModelSelf, B as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, aB as createActionRecorder, aA as createTimeTravelManager, az as createUndoManager, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './undo-quCDYz_6.mjs';
+import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance } from './undo-BSq-Pomp.mjs';
+export { L as CustomTypeOptions, aG as IActionRecorder, aH as IActionRecording, C as IAnyComplexType, D as IAnyMixin, aE as IHistoryEntry, F as IJsonPatch, y as IMSTArray, z as IMSTMap, G as IReversibleJsonPatch, x as IStateTreeNode, aF as ITimeTravelManager, aC as IUndoManager, aD as IUndoManagerOptions, H as IValidationContext, K as IValidationError, J as IValidationResult, A as ModelInstance, E as ModelSelf, B as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, aB as createActionRecorder, aA as createTimeTravelManager, az as createUndoManager, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './undo-BSq-Pomp.mjs';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance } from './undo-quCDYz_6.js';
-export { L as CustomTypeOptions, aG as IActionRecorder, aH as IActionRecording, C as IAnyComplexType, D as IAnyMixin, aE as IHistoryEntry, F as IJsonPatch, y as IMSTArray, z as IMSTMap, G as IReversibleJsonPatch, x as IStateTreeNode, aF as ITimeTravelManager, aC as IUndoManager, aD as IUndoManagerOptions, H as IValidationContext, K as IValidationError, J as IValidationResult, A as ModelInstance, E as ModelSelf, B as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, aB as createActionRecorder, aA as createTimeTravelManager, az as createUndoManager, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './undo-quCDYz_6.js';
+import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance } from './undo-BSq-Pomp.js';
+export { L as CustomTypeOptions, aG as IActionRecorder, aH as IActionRecording, C as IAnyComplexType, D as IAnyMixin, aE as IHistoryEntry, F as IJsonPatch, y as IMSTArray, z as IMSTMap, G as IReversibleJsonPatch, x as IStateTreeNode, aF as ITimeTravelManager, aC as IUndoManager, aD as IUndoManagerOptions, H as IValidationContext, K as IValidationError, J as IValidationResult, A as ModelInstance, E as ModelSelf, B as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, aB as createActionRecorder, aA as createTimeTravelManager, az as createUndoManager, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './undo-BSq-Pomp.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/index.js

@@ -559,6 +559,41 @@ var StateTreeNode = class {
     this.$parent = parent ?? null;
     this.$path = parent ? `${parent.$path}/${pathSegment}` : "";
     this.valueAtom = (0, import_jotai.atom)(initialValue);
+    this.isAliveAtom = (0, import_jotai.atom)(true);
+    this.snapshotAtom = (0, import_jotai.atom)((get) => {
+      const value = get(this.valueAtom);
+      if (this.$type._kind === "model") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        if (value && typeof value === "object") {
+          for (const key of Object.keys(value)) {
+            if (!this.children.has(key)) {
+              res[key] = value[key];
+            }
+          }
+        }
+        return this.postProcessor ? this.postProcessor(res) : res;
+      }
+      if (this.$type._kind === "array") {
+        const res = [];
+        const childrenKeys = Array.from(this.children.keys()).sort((a, b) => Number(a) - Number(b));
+        for (const key of childrenKeys) {
+          const childNode = this.children.get(key);
+          res.push(get(childNode.snapshotAtom));
+        }
+        return res;
+      }
+      if (this.$type._kind === "map") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        return res;
+      }
+      return value;
+    });
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
     nodeFinalizationRegistry.register(this, this.$id, this);
   }
@@ -750,6 +785,10 @@ var StateTreeNode = class {
     this.children.clear();
     this.unregisterIdentifier();
     this.$isAlive = false;
+    try {
+      globalStore.set(this.isAliveAtom, false);
+    } catch (e) {
+    }
     notifyLifecycleChange(this, false);
     nodeRegistry.delete(this.$id);
     nodeFinalizationRegistry.unregister(this);
@@ -926,6 +965,10 @@ function clearAllRegistries() {
     const node = entry.node.deref();
     if (node) {
       node.$isAlive = false;
+      try {
+        globalStore.set(node.isAliveAtom, false);
+      } catch (e) {
+      }
     }
   }
   nodeRegistry.clear();

package/dist/index.mjs

@@ -62,7 +62,7 @@ import {
   tryResolve,
   unfreeze,
   walk
-} from "./chunk-5OCZ6YLH.mjs";
+} from "./chunk-XA4ACZVI.mjs";
 
 // src/primitives.ts
 function createSimpleType(name, validator, defaultValue) {

package/dist/react.d.mts

@@ -1,6 +1,6 @@
 import React, { ComponentType, FC, ReactNode } from 'react';
-import { ag as getGlobalStore, aD as IUndoManagerOptions, aC as IUndoManager, aF as ITimeTravelManager } from './undo-quCDYz_6.mjs';
-export { aI as hasStateTreeNode } from './undo-quCDYz_6.mjs';
+import { ag as getGlobalStore, aD as IUndoManagerOptions, aC as IUndoManager, aF as ITimeTravelManager } from './undo-BSq-Pomp.mjs';
+export { aI as hasStateTreeNode } from './undo-BSq-Pomp.mjs';
 import 'jotai/vanilla/internals';
 import 'jotai';
 
@@ -108,9 +108,6 @@ declare function createStoreContext<T>(): {
     useIsAlive: () => boolean;
     Context: React.Context<T | null>;
 };
-/**
- * Hook that returns the current snapshot and re-renders on changes.
- */
 declare function useSnapshot<T>(target: unknown): T;
 /**
  * Hook to watch specific paths in a state tree

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import React, { ComponentType, FC, ReactNode } from 'react';
-import { ag as getGlobalStore, aD as IUndoManagerOptions, aC as IUndoManager, aF as ITimeTravelManager } from './undo-quCDYz_6.js';
-export { aI as hasStateTreeNode } from './undo-quCDYz_6.js';
+import { ag as getGlobalStore, aD as IUndoManagerOptions, aC as IUndoManager, aF as ITimeTravelManager } from './undo-BSq-Pomp.js';
+export { aI as hasStateTreeNode } from './undo-BSq-Pomp.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 
@@ -108,9 +108,6 @@ declare function createStoreContext<T>(): {
     useIsAlive: () => boolean;
     Context: React.Context<T | null>;
 };
-/**
- * Hook that returns the current snapshot and re-renders on changes.
- */
 declare function useSnapshot<T>(target: unknown): T;
 /**
  * Hook to watch specific paths in a state tree

package/dist/react.js

@@ -109,17 +109,6 @@ function generateNodeId() {
   return `node_${++nodeIdCounter}_${Date.now().toString(36)}`;
 }
 var lifecycleListeners = /* @__PURE__ */ new WeakMap();
-function onLifecycleChange(node, listener) {
-  let listeners = lifecycleListeners.get(node);
-  if (!listeners) {
-    listeners = /* @__PURE__ */ new Set();
-    lifecycleListeners.set(node, listeners);
-  }
-  listeners.add(listener);
-  return () => {
-    listeners?.delete(listener);
-  };
-}
 function notifyLifecycleChange(node, isAlive) {
   const listeners = lifecycleListeners.get(node);
   if (listeners) {
@@ -180,6 +169,41 @@ var StateTreeNode = class {
     this.$parent = parent ?? null;
     this.$path = parent ? `${parent.$path}/${pathSegment}` : "";
     this.valueAtom = (0, import_jotai.atom)(initialValue);
+    this.isAliveAtom = (0, import_jotai.atom)(true);
+    this.snapshotAtom = (0, import_jotai.atom)((get) => {
+      const value = get(this.valueAtom);
+      if (this.$type._kind === "model") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        if (value && typeof value === "object") {
+          for (const key of Object.keys(value)) {
+            if (!this.children.has(key)) {
+              res[key] = value[key];
+            }
+          }
+        }
+        return this.postProcessor ? this.postProcessor(res) : res;
+      }
+      if (this.$type._kind === "array") {
+        const res = [];
+        const childrenKeys = Array.from(this.children.keys()).sort((a, b) => Number(a) - Number(b));
+        for (const key of childrenKeys) {
+          const childNode = this.children.get(key);
+          res.push(get(childNode.snapshotAtom));
+        }
+        return res;
+      }
+      if (this.$type._kind === "map") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        return res;
+      }
+      return value;
+    });
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
     nodeFinalizationRegistry.register(this, this.$id, this);
   }
@@ -371,6 +395,10 @@ var StateTreeNode = class {
     this.children.clear();
     this.unregisterIdentifier();
     this.$isAlive = false;
+    try {
+      globalStore.set(this.isAliveAtom, false);
+    } catch (e) {
+    }
     notifyLifecycleChange(this, false);
     nodeRegistry.delete(this.$id);
     nodeFinalizationRegistry.unregister(this);
@@ -504,10 +532,6 @@ function applySnapshot(target, snapshot) {
     setIsApplyingSnapshotOrPatch(wasApplying);
   }
 }
-function onSnapshot(target, listener) {
-  const node = getStateTreeNode(target);
-  return node.onSnapshot(listener);
-}
 function onPatch(target, listener) {
   const node = getStateTreeNode(target);
   return node.onPatch(listener);
@@ -1007,60 +1031,19 @@ function useObserver(fn) {
   }
 }
 function useLocalObservable(initializer, dependencies = []) {
-  const [, forceUpdate] = (0, import_react.useState)({});
-  const storeRef = (0, import_react.useRef)(null);
-  const disposerRef = (0, import_react.useRef)(null);
-  if (storeRef.current === null) {
-    storeRef.current = initializer();
-    if (hasStateTreeNode(storeRef.current)) {
-      disposerRef.current = onSnapshot(storeRef.current, () => {
-        forceUpdate({});
-      });
-    }
+  const store = (0, import_react.useMemo)(initializer, dependencies);
+  if (hasStateTreeNode(store)) {
+    const node = getStateTreeNode(store);
+    (0, import_jotai3.useAtomValue)(node.snapshotAtom, { store: getGlobalStore() });
   }
-  (0, import_react.useEffect)(() => {
-    return () => {
-      disposerRef.current?.();
-    };
-  }, []);
-  (0, import_react.useEffect)(() => {
-    if (dependencies.length > 0) {
-      disposerRef.current?.();
-      storeRef.current = initializer();
-      if (hasStateTreeNode(storeRef.current)) {
-        disposerRef.current = onSnapshot(storeRef.current, () => {
-          forceUpdate({});
-        });
-      }
-    }
-  }, dependencies);
-  return storeRef.current;
+  return store;
 }
 function useSyncedStore(store) {
-  const snapshotRef = (0, import_react.useRef)(null);
-  const subscribe = (0, import_react.useCallback)(
-    (callback) => {
-      if (!hasStateTreeNode(store)) {
-        return () => {
-        };
-      }
-      return onSnapshot(store, () => {
-        snapshotRef.current = getSnapshot(store);
-        callback();
-      });
-    },
-    [store]
-  );
-  const getSnapshotValue = (0, import_react.useCallback)(() => {
-    if (!hasStateTreeNode(store)) {
-      return null;
-    }
-    if (snapshotRef.current === null) {
-      snapshotRef.current = getSnapshot(store);
-    }
-    return snapshotRef.current;
-  }, [store]);
-  (0, import_react.useSyncExternalStore)(subscribe, getSnapshotValue, getSnapshotValue);
+  if (!hasStateTreeNode(store)) {
+    return store;
+  }
+  const node = getStateTreeNode(store);
+  (0, import_jotai3.useAtomValue)(node.snapshotAtom, { store: getGlobalStore() });
   return store;
 }
 var StoreContext = import_react.default.createContext(
@@ -1084,20 +1067,12 @@ function useStore() {
 }
 function useStoreSnapshot(selector) {
   const store = useStore();
-  const [, forceUpdate] = (0, import_react.useState)({});
-  (0, import_react.useEffect)(() => {
-    if (hasStateTreeNode(store)) {
-      return onSnapshot(store, () => {
-        forceUpdate({});
-      });
-    }
-    return () => {
-    };
-  }, [store]);
-  if (selector) {
-    return selector(store);
+  if (!hasStateTreeNode(store)) {
+    return store;
   }
-  return store;
+  const node = getStateTreeNode(store);
+  (0, import_jotai3.useAtomValue)(node.snapshotAtom, { store: getGlobalStore() });
+  return selector ? selector(store) : store;
 }
 function createStoreContext() {
   const Context = import_react.default.createContext(null);
@@ -1118,20 +1093,12 @@ function createStoreContext() {
   }
   function useTypedStoreSnapshot(selector) {
     const store = useTypedStore();
-    const [, forceUpdate] = (0, import_react.useState)({});
-    (0, import_react.useEffect)(() => {
-      if (hasStateTreeNode(store)) {
-        return onSnapshot(store, () => {
-          forceUpdate({});
-        });
-      }
-      return () => {
-      };
-    }, [store]);
-    if (selector) {
-      return selector(store);
+    if (!hasStateTreeNode(store)) {
+      return store;
     }
-    return store;
+    const node = getStateTreeNode(store);
+    (0, import_jotai3.useAtomValue)(node.snapshotAtom, { store: getGlobalStore() });
+    return selector ? selector(store) : store;
   }
   function useTypedIsAlive() {
     const store = useTypedStore();
@@ -1146,47 +1113,33 @@ function createStoreContext() {
   };
 }
 function useSnapshot(target) {
-  const [snapshot, setSnapshot] = (0, import_react.useState)(() => getSnapshot(target));
-  (0, import_react.useEffect)(() => {
-    const disposer = onSnapshot(target, (newSnapshot) => {
-      setSnapshot(newSnapshot);
-    });
-    return disposer;
-  }, [target]);
-  return snapshot;
+  if (!hasStateTreeNode(target)) {
+    return target;
+  }
+  const node = getStateTreeNode(target);
+  return (0, import_jotai3.useAtomValue)(node.snapshotAtom, { store: getGlobalStore() });
 }
 function useWatchPath(target, path, defaultValue) {
-  const [value, setValue] = (0, import_react.useState)(() => {
-    const snapshot = getSnapshot(target);
-    const parts = path.split(".");
-    let current = snapshot;
-    for (const part of parts) {
-      if (current && typeof current === "object" && part in current) {
-        current = current[part];
-      } else {
-        return defaultValue;
-      }
-    }
-    return current;
-  });
-  (0, import_react.useEffect)(() => {
-    const disposer = onSnapshot(target, (newSnapshot) => {
-      const snapshot = newSnapshot;
+  if (!hasStateTreeNode(target)) {
+    return defaultValue;
+  }
+  const node = getStateTreeNode(target);
+  const pathAtom = (0, import_react.useMemo)(() => {
+    return (0, import_jotai3.atom)((get) => {
+      const snapshot = get(node.snapshotAtom);
       const parts = path.split(".");
       let current = snapshot;
       for (const part of parts) {
         if (current && typeof current === "object" && part in current) {
           current = current[part];
         } else {
-          setValue(defaultValue);
-          return;
+          return defaultValue;
         }
       }
-      setValue(current);
+      return current;
     });
-    return disposer;
-  }, [target, path, defaultValue]);
-  return value;
+  }, [node, path, defaultValue]);
+  return (0, import_jotai3.useAtomValue)(pathAtom, { store: getGlobalStore() });
 }
 function usePatches(target, callback) {
   (0, import_react.useEffect)(() => {
@@ -1223,20 +1176,9 @@ function scheduleUpdate(update) {
   }
 }
 function useIsAlive(target) {
-  const [isAlive, setIsAlive] = (0, import_react.useState)(() => {
-    if (!hasStateTreeNode(target)) return false;
-    return getStateTreeNode(target).$isAlive;
-  });
-  (0, import_react.useEffect)(() => {
-    if (!hasStateTreeNode(target)) return;
-    const node = getStateTreeNode(target);
-    setIsAlive(node.$isAlive);
-    const disposer = onLifecycleChange(node, (alive) => {
-      setIsAlive(alive);
-    });
-    return disposer;
-  }, [target]);
-  return isAlive;
+  if (!hasStateTreeNode(target)) return false;
+  const node = getStateTreeNode(target);
+  return (0, import_jotai3.useAtomValue)(node.isAliveAtom, { store: getGlobalStore() });
 }
 function useCleanup(cleanupFn) {
   const cleanupRef = (0, import_react.useRef)(cleanupFn);

package/dist/react.mjs

@@ -5,15 +5,12 @@ import {
   getGlobalStore,
   getIsApplyingSnapshotOrPatch,
   getOrCreateHistoryTracker,
-  getSnapshot,
   getStateTreeNode,
   hasStateTreeNode,
-  onLifecycleChange,
   onPatch,
-  onSnapshot,
   setActiveTrackingFn,
   setIsApplyingSnapshotOrPatch
-} from "./chunk-5OCZ6YLH.mjs";
+} from "./chunk-XA4ACZVI.mjs";
 
 // src/react.ts
 import React, {
@@ -22,11 +19,10 @@ import React, {
   useMemo,
   useRef,
   forwardRef,
-  memo,
-  useCallback,
-  useSyncExternalStore
+  memo
 } from "react";
 import {
+  atom,
   useAtomValue
 } from "jotai";
 import { useHydrateAtoms } from "jotai/utils";
@@ -116,60 +112,19 @@ function useObserver(fn) {
   }
 }
 function useLocalObservable(initializer, dependencies = []) {
-  const [, forceUpdate] = useState({});
-  const storeRef = useRef(null);
-  const disposerRef = useRef(null);
-  if (storeRef.current === null) {
-    storeRef.current = initializer();
-    if (hasStateTreeNode(storeRef.current)) {
-      disposerRef.current = onSnapshot(storeRef.current, () => {
-        forceUpdate({});
-      });
-    }
+  const store = useMemo(initializer, dependencies);
+  if (hasStateTreeNode(store)) {
+    const node = getStateTreeNode(store);
+    useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
   }
-  useEffect(() => {
-    return () => {
-      disposerRef.current?.();
-    };
-  }, []);
-  useEffect(() => {
-    if (dependencies.length > 0) {
-      disposerRef.current?.();
-      storeRef.current = initializer();
-      if (hasStateTreeNode(storeRef.current)) {
-        disposerRef.current = onSnapshot(storeRef.current, () => {
-          forceUpdate({});
-        });
-      }
-    }
-  }, dependencies);
-  return storeRef.current;
+  return store;
 }
 function useSyncedStore(store) {
-  const snapshotRef = useRef(null);
-  const subscribe = useCallback(
-    (callback) => {
-      if (!hasStateTreeNode(store)) {
-        return () => {
-        };
-      }
-      return onSnapshot(store, () => {
-        snapshotRef.current = getSnapshot(store);
-        callback();
-      });
-    },
-    [store]
-  );
-  const getSnapshotValue = useCallback(() => {
-    if (!hasStateTreeNode(store)) {
-      return null;
-    }
-    if (snapshotRef.current === null) {
-      snapshotRef.current = getSnapshot(store);
-    }
-    return snapshotRef.current;
-  }, [store]);
-  useSyncExternalStore(subscribe, getSnapshotValue, getSnapshotValue);
+  if (!hasStateTreeNode(store)) {
+    return store;
+  }
+  const node = getStateTreeNode(store);
+  useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
   return store;
 }
 var StoreContext = React.createContext(
@@ -193,20 +148,12 @@ function useStore() {
 }
 function useStoreSnapshot(selector) {
   const store = useStore();
-  const [, forceUpdate] = useState({});
-  useEffect(() => {
-    if (hasStateTreeNode(store)) {
-      return onSnapshot(store, () => {
-        forceUpdate({});
-      });
-    }
-    return () => {
-    };
-  }, [store]);
-  if (selector) {
-    return selector(store);
+  if (!hasStateTreeNode(store)) {
+    return store;
   }
-  return store;
+  const node = getStateTreeNode(store);
+  useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
+  return selector ? selector(store) : store;
 }
 function createStoreContext() {
   const Context = React.createContext(null);
@@ -227,20 +174,12 @@ function createStoreContext() {
   }
   function useTypedStoreSnapshot(selector) {
     const store = useTypedStore();
-    const [, forceUpdate] = useState({});
-    useEffect(() => {
-      if (hasStateTreeNode(store)) {
-        return onSnapshot(store, () => {
-          forceUpdate({});
-        });
-      }
-      return () => {
-      };
-    }, [store]);
-    if (selector) {
-      return selector(store);
+    if (!hasStateTreeNode(store)) {
+      return store;
     }
-    return store;
+    const node = getStateTreeNode(store);
+    useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
+    return selector ? selector(store) : store;
   }
   function useTypedIsAlive() {
     const store = useTypedStore();
@@ -255,47 +194,33 @@ function createStoreContext() {
   };
 }
 function useSnapshot(target) {
-  const [snapshot, setSnapshot] = useState(() => getSnapshot(target));
-  useEffect(() => {
-    const disposer = onSnapshot(target, (newSnapshot) => {
-      setSnapshot(newSnapshot);
-    });
-    return disposer;
-  }, [target]);
-  return snapshot;
+  if (!hasStateTreeNode(target)) {
+    return target;
+  }
+  const node = getStateTreeNode(target);
+  return useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
 }
 function useWatchPath(target, path, defaultValue) {
-  const [value, setValue] = useState(() => {
-    const snapshot = getSnapshot(target);
-    const parts = path.split(".");
-    let current = snapshot;
-    for (const part of parts) {
-      if (current && typeof current === "object" && part in current) {
-        current = current[part];
-      } else {
-        return defaultValue;
-      }
-    }
-    return current;
-  });
-  useEffect(() => {
-    const disposer = onSnapshot(target, (newSnapshot) => {
-      const snapshot = newSnapshot;
+  if (!hasStateTreeNode(target)) {
+    return defaultValue;
+  }
+  const node = getStateTreeNode(target);
+  const pathAtom = useMemo(() => {
+    return atom((get) => {
+      const snapshot = get(node.snapshotAtom);
       const parts = path.split(".");
       let current = snapshot;
       for (const part of parts) {
         if (current && typeof current === "object" && part in current) {
           current = current[part];
         } else {
-          setValue(defaultValue);
-          return;
+          return defaultValue;
         }
       }
-      setValue(current);
+      return current;
     });
-    return disposer;
-  }, [target, path, defaultValue]);
-  return value;
+  }, [node, path, defaultValue]);
+  return useAtomValue(pathAtom, { store: getGlobalStore() });
 }
 function usePatches(target, callback) {
   useEffect(() => {
@@ -332,20 +257,9 @@ function scheduleUpdate(update) {
   }
 }
 function useIsAlive(target) {
-  const [isAlive, setIsAlive] = useState(() => {
-    if (!hasStateTreeNode(target)) return false;
-    return getStateTreeNode(target).$isAlive;
-  });
-  useEffect(() => {
-    if (!hasStateTreeNode(target)) return;
-    const node = getStateTreeNode(target);
-    setIsAlive(node.$isAlive);
-    const disposer = onLifecycleChange(node, (alive) => {
-      setIsAlive(alive);
-    });
-    return disposer;
-  }, [target]);
-  return isAlive;
+  if (!hasStateTreeNode(target)) return false;
+  const node = getStateTreeNode(target);
+  return useAtomValue(node.isAliveAtom, { store: getGlobalStore() });
 }
 function useCleanup(cleanupFn) {
   const cleanupRef = useRef(cleanupFn);

package/dist/{undo-quCDYz_6.d.mts → undo-BSq-Pomp.d.mts}

@@ -1,5 +1,5 @@
 import * as jotai_vanilla_internals from 'jotai/vanilla/internals';
-import { WritableAtom, createStore } from 'jotai';
+import { WritableAtom, Atom, createStore } from 'jotai';
 
 /**
  * Core types for jotai-state-tree
@@ -332,6 +332,10 @@ declare class StateTreeNode implements IStateTreeNode {
     private children;
     /** Atom storing the raw value/snapshot */
     valueAtom: WritableAtom<unknown, [unknown], void>;
+    /** Derived atom representing the snapshot of the entire node subtree */
+    snapshotAtom: Atom<unknown>;
+    /** Atom tracking the isAlive status */
+    isAliveAtom: WritableAtom<boolean, [boolean], void>;
     /** Snapshot listeners */
     private snapshotListeners;
     /** Patch listeners */

package/dist/{undo-quCDYz_6.d.ts → undo-BSq-Pomp.d.ts}

@@ -1,5 +1,5 @@
 import * as jotai_vanilla_internals from 'jotai/vanilla/internals';
-import { WritableAtom, createStore } from 'jotai';
+import { WritableAtom, Atom, createStore } from 'jotai';
 
 /**
  * Core types for jotai-state-tree
@@ -332,6 +332,10 @@ declare class StateTreeNode implements IStateTreeNode {
     private children;
     /** Atom storing the raw value/snapshot */
     valueAtom: WritableAtom<unknown, [unknown], void>;
+    /** Derived atom representing the snapshot of the entire node subtree */
+    snapshotAtom: Atom<unknown>;
+    /** Atom tracking the isAlive status */
+    isAliveAtom: WritableAtom<boolean, [boolean], void>;
     /** Snapshot listeners */
     private snapshotListeners;
     /** Patch listeners */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jotai-state-tree",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "MobX-State-Tree API compatible library powered by Jotai",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/react.ts

@@ -18,6 +18,7 @@ import React, {
   type FC,
 } from "react";
 import {
+  atom,
   useAtom,
   useAtomValue,
   useSetAtom,
@@ -218,43 +219,12 @@ export function useLocalObservable<T>(
   initializer: () => T,
   dependencies: unknown[] = [],
 ): T {
-  const [, forceUpdate] = useState({});
-  const storeRef = useRef<T | null>(null);
-  const disposerRef = useRef<IDisposer | null>(null);
-
-  // Initialize store
-  if (storeRef.current === null) {
-    storeRef.current = initializer();
-
-    // Subscribe to changes
-    if (hasStateTreeNode(storeRef.current)) {
-      disposerRef.current = onSnapshot(storeRef.current, () => {
-        forceUpdate({});
-      });
-    }
+  const store = useMemo(initializer, dependencies);
+  if (hasStateTreeNode(store)) {
+    const node = getStateTreeNode(store);
+    useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
   }
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      disposerRef.current?.();
-    };
-  }, []);
-
-  // Reinitialize if dependencies change
-  useEffect(() => {
-    if (dependencies.length > 0) {
-      disposerRef.current?.();
-      storeRef.current = initializer();
-      if (hasStateTreeNode(storeRef.current)) {
-        disposerRef.current = onSnapshot(storeRef.current, () => {
-          forceUpdate({});
-        });
-      }
-    }
-  }, dependencies);
-
-  return storeRef.current;
+  return store;
 }
 
 // ============================================================================
@@ -266,36 +236,11 @@ export function useLocalObservable<T>(
  * This provides better concurrent mode support.
  */
 export function useSyncedStore<T>(store: T): T {
-  // Cache the snapshot to provide stable reference for useSyncExternalStore
-  const snapshotRef = useRef<unknown>(null);
-
-  const subscribe = useCallback(
-    (callback: () => void) => {
-      if (!hasStateTreeNode(store)) {
-        return () => {};
-      }
-      return onSnapshot(store, () => {
-        // Update cached snapshot on change
-        snapshotRef.current = getSnapshot(store);
-        callback();
-      });
-    },
-    [store],
-  );
-
-  const getSnapshotValue = useCallback(() => {
-    if (!hasStateTreeNode(store)) {
-      return null;
-    }
-    // Return cached snapshot for stable reference comparison
-    if (snapshotRef.current === null) {
-      snapshotRef.current = getSnapshot(store);
-    }
-    return snapshotRef.current;
-  }, [store]);
-
-  useSyncExternalStore(subscribe, getSnapshotValue, getSnapshotValue);
-
+  if (!hasStateTreeNode(store)) {
+    return store;
+  }
+  const node = getStateTreeNode(store);
+  useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
   return store;
 }
 
@@ -350,22 +295,12 @@ export function useStoreSnapshot<T>(): T;
 export function useStoreSnapshot<T, S>(selector: (store: T) => S): S;
 export function useStoreSnapshot<T, S>(selector?: (store: T) => S): T | S {
   const store = useStore<T>();
-  const [, forceUpdate] = useState({});
-
-  useEffect(() => {
-    if (hasStateTreeNode(store)) {
-      return onSnapshot(store, () => {
-        forceUpdate({});
-      });
-    }
-    return () => {};
-  }, [store]);
-
-  if (selector) {
-    return selector(store);
+  if (!hasStateTreeNode(store)) {
+    return store;
   }
-
-  return store;
+  const node = getStateTreeNode(store);
+  useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
+  return selector ? selector(store) : store;
 }
 
 // ============================================================================
@@ -424,22 +359,12 @@ export function createStoreContext<T>() {
   function useTypedStoreSnapshot<S>(selector: (store: T) => S): S;
   function useTypedStoreSnapshot<S>(selector?: (store: T) => S): T | S {
     const store = useTypedStore();
-    const [, forceUpdate] = useState({});
-
-    useEffect(() => {
-      if (hasStateTreeNode(store)) {
-        return onSnapshot(store, () => {
-          forceUpdate({});
-        });
-      }
-      return () => {};
-    }, [store]);
-
-    if (selector) {
-      return selector(store);
+    if (!hasStateTreeNode(store)) {
+      return store;
     }
-
-    return store;
+    const node = getStateTreeNode(store);
+    useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
+    return selector ? selector(store) : store;
   }
 
   /**
@@ -463,20 +388,12 @@ export function createStoreContext<T>() {
 // Snapshot Hooks
 // ============================================================================
 
-/**
- * Hook that returns the current snapshot and re-renders on changes.
- */
 export function useSnapshot<T>(target: unknown): T {
-  const [snapshot, setSnapshot] = useState<T>(() => getSnapshot(target));
-
-  useEffect(() => {
-    const disposer = onSnapshot(target, (newSnapshot) => {
-      setSnapshot(newSnapshot as T);
-    });
-    return disposer;
-  }, [target]);
-
-  return snapshot;
+  if (!hasStateTreeNode(target)) {
+    return target as T;
+  }
+  const node = getStateTreeNode(target);
+  return useAtomValue(node.snapshotAtom, { store: getGlobalStore() }) as T;
 }
 
 /**
@@ -487,39 +404,27 @@ export function useWatchPath<T>(
   path: string,
   defaultValue?: T,
 ): T {
-  const [value, setValue] = useState<T>(() => {
-    const snapshot = getSnapshot(target) as Record<string, unknown>;
-    const parts = path.split(".");
-    let current: unknown = snapshot;
-    for (const part of parts) {
-      if (current && typeof current === "object" && part in current) {
-        current = (current as Record<string, unknown>)[part];
-      } else {
-        return defaultValue as T;
-      }
-    }
-    return current as T;
-  });
-
-  useEffect(() => {
-    const disposer = onSnapshot(target, (newSnapshot) => {
-      const snapshot = newSnapshot as Record<string, unknown>;
+  if (!hasStateTreeNode(target)) {
+    return defaultValue as T;
+  }
+  const node = getStateTreeNode(target);
+  const pathAtom = useMemo(() => {
+    return atom((get) => {
+      const snapshot = get(node.snapshotAtom) as Record<string, unknown>;
       const parts = path.split(".");
       let current: unknown = snapshot;
       for (const part of parts) {
         if (current && typeof current === "object" && part in current) {
           current = (current as Record<string, unknown>)[part];
         } else {
-          setValue(defaultValue as T);
-          return;
+          return defaultValue as T;
         }
       }
-      setValue(current as T);
+      return current as T;
     });
-    return disposer;
-  }, [target, path, defaultValue]);
+  }, [node, path, defaultValue]);
 
-  return value;
+  return useAtomValue(pathAtom, { store: getGlobalStore() });
 }
 
 /**
@@ -602,27 +507,9 @@ export function scheduleUpdate(update: () => void): void {
  * Uses proper subscription instead of polling for better performance.
  */
 export function useIsAlive(target: unknown): boolean {
-  const [isAlive, setIsAlive] = useState(() => {
-    if (!hasStateTreeNode(target)) return false;
-    return getStateTreeNode(target).$isAlive;
-  });
-
-  useEffect(() => {
-    if (!hasStateTreeNode(target)) return;
-
-    const node = getStateTreeNode(target);
-    setIsAlive(node.$isAlive);
-
-    // Subscribe to lifecycle changes using proper event system
-    // This is much more efficient than polling
-    const disposer = onLifecycleChange(node, (alive) => {
-      setIsAlive(alive);
-    });
-
-    return disposer;
-  }, [target]);
-
-  return isAlive;
+  if (!hasStateTreeNode(target)) return false;
+  const node = getStateTreeNode(target);
+  return useAtomValue(node.isAliveAtom, { store: getGlobalStore() });
 }
 
 /**

package/src/tree.ts

@@ -9,7 +9,7 @@
  * - Properly cleans up all registries on node destruction
  */
 
-import { atom, createStore, type WritableAtom } from "jotai";
+import { atom, createStore, type WritableAtom, type Atom } from "jotai";
 import type {
   IStateTreeNode,
   IType,
@@ -226,6 +226,12 @@ export class StateTreeNode implements IStateTreeNode {
   /** Atom storing the raw value/snapshot */
   valueAtom: WritableAtom<unknown, [unknown], void>;
 
+  /** Derived atom representing the snapshot of the entire node subtree */
+  snapshotAtom: Atom<unknown>;
+
+  /** Atom tracking the isAlive status */
+  isAliveAtom: WritableAtom<boolean, [boolean], void>;
+
   /** Snapshot listeners */
   private snapshotListeners = new Set<(snapshot: unknown) => void>();
 
@@ -280,6 +286,47 @@ export class StateTreeNode implements IStateTreeNode {
     // Create the value atom
     this.valueAtom = atom(initialValue);
 
+    this.isAliveAtom = atom(true);
+
+    this.snapshotAtom = atom((get) => {
+      const value = get(this.valueAtom);
+
+      if (this.$type._kind === "model") {
+        const res: Record<string, unknown> = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        if (value && typeof value === "object") {
+          for (const key of Object.keys(value)) {
+            if (!this.children.has(key)) {
+              res[key] = (value as Record<string, unknown>)[key];
+            }
+          }
+        }
+        return this.postProcessor ? this.postProcessor(res) : res;
+      }
+
+      if (this.$type._kind === "array") {
+        const res: unknown[] = [];
+        const childrenKeys = Array.from(this.children.keys()).sort((a, b) => Number(a) - Number(b));
+        for (const key of childrenKeys) {
+          const childNode = this.children.get(key)!;
+          res.push(get(childNode.snapshotAtom));
+        }
+        return res;
+      }
+
+      if (this.$type._kind === "map") {
+        const res: Record<string, unknown> = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        return res;
+      }
+
+      return value;
+    });
+
     // Register this node with WeakRef
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
 
@@ -515,6 +562,11 @@ export class StateTreeNode implements IStateTreeNode {
 
     // Mark as dead
     this.$isAlive = false;
+    try {
+      globalStore.set(this.isAliveAtom, false);
+    } catch (e) {
+      // Ignore store errors during teardown
+    }
 
     // Notify lifecycle listeners
     notifyLifecycleChange(this, false);
@@ -800,6 +852,11 @@ export function clearAllRegistries(): void {
     const node = entry.node.deref();
     if (node) {
       node.$isAlive = false;
+      try {
+        globalStore.set(node.isAliveAtom, false);
+      } catch (e) {
+        // Ignore store errors during teardown
+      }
     }
   }
   nodeRegistry.clear();