jotai-state-tree 1.2.0 → 1.2.1

package/dist/{chunk-3TQNT4MR.mjs → chunk-UOYV4J7H.mjs}

@@ -77,6 +77,9 @@ var StateTreeNode = class {
     this.patchListeners = /* @__PURE__ */ new Set();
     /** Volatile state (non-serialized) */
     this.volatileState = {};
+    /** Cached snapshot for structural sharing optimization */
+    this.cachedSnapshot = void 0;
+    this.isSnapshotDirty = true;
     this.$id = generateNodeId();
     this.$type = type;
     this.$env = env ?? parent?.$env;
@@ -86,6 +89,15 @@ var StateTreeNode = class {
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
     nodeFinalizationRegistry.register(this, this.$id, this);
   }
+  invalidateSnapshot() {
+    if (!this.isSnapshotDirty) {
+      this.isSnapshotDirty = true;
+      this.cachedSnapshot = void 0;
+      if (this.$parent) {
+        this.$parent.invalidateSnapshot();
+      }
+    }
+  }
   /** Set the instance reference */
   setInstance(instance) {
     const entry = nodeRegistry.get(this.$id);
@@ -110,6 +122,9 @@ var StateTreeNode = class {
       );
     }
     const oldValue = this.getValue();
+    if (oldValue === value) {
+      return;
+    }
     globalStore.set(this.valueAtom, value);
     this.notifyPatch(
       { op: "replace", path: this.$path, value },
@@ -127,6 +142,7 @@ var StateTreeNode = class {
     child.$env = child.$env ?? this.$env;
     this.children.set(key, child);
     lifecycleHookHandlers.runAfterAttach?.(child);
+    this.invalidateSnapshot();
   }
   /** Recursively update the path of a node and all its children */
   updatePathRecursively(node, newPath) {
@@ -142,6 +158,7 @@ var StateTreeNode = class {
     if (child) {
       child.destroy();
       this.children.delete(key);
+      this.invalidateSnapshot();
     }
   }
   /** Get a child node */
@@ -204,6 +221,7 @@ var StateTreeNode = class {
   }
   /** Notify snapshot listeners */
   notifySnapshotChange() {
+    this.invalidateSnapshot();
     let current = this;
     while (current) {
       const snapshot = getSnapshotFromNode(current);
@@ -261,6 +279,7 @@ var StateTreeNode = class {
   detach() {
     if (this.$parent) {
       lifecycleHookHandlers.runBeforeDetach?.(this);
+      const parent = this.$parent;
       for (const [key, child] of this.$parent.children) {
         if (child === this) {
           this.$parent.children.delete(key);
@@ -269,6 +288,7 @@ var StateTreeNode = class {
       }
       this.$parent = null;
       this.$path = "";
+      parent.invalidateSnapshot();
     }
   }
 };
@@ -283,38 +303,44 @@ function hasStateTreeNode(instance) {
   return instance !== null && typeof instance === "object" && $treenode in instance;
 }
 function getSnapshotFromNode(node) {
+  if (!node.isSnapshotDirty && node.cachedSnapshot !== void 0) {
+    return node.cachedSnapshot;
+  }
   const type = node.$type;
   const value = node.getValue();
+  let snapshot;
   if (type._kind === "model") {
-    const snapshot = {};
+    const modelSnapshot = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      modelSnapshot[key] = getSnapshotFromNode(childNode);
     }
     if (node.postProcessor) {
-      return node.postProcessor(snapshot);
+      snapshot = node.postProcessor(modelSnapshot);
+    } else {
+      snapshot = modelSnapshot;
     }
-    return snapshot;
-  }
-  if (type._kind === "array") {
+  } else if (type._kind === "array") {
     const arr = value;
-    return arr.map((_, index) => {
+    snapshot = arr.map((_, index) => {
       const childNode = node.getChild(String(index));
       return childNode ? getSnapshotFromNode(childNode) : arr[index];
     });
-  }
-  if (type._kind === "map") {
-    const snapshot = {};
+  } else if (type._kind === "map") {
+    const mapSnapshot = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      mapSnapshot[key] = getSnapshotFromNode(childNode);
     }
-    return snapshot;
-  }
-  if (type._kind === "reference") {
-    return node.identifierValue ?? value;
+    snapshot = mapSnapshot;
+  } else if (type._kind === "reference") {
+    snapshot = node.identifierValue ?? value;
+  } else {
+    snapshot = value;
   }
-  return value;
+  node.cachedSnapshot = snapshot;
+  node.isSnapshotDirty = false;
+  return snapshot;
 }
 function applySnapshotToNode(node, snapshot) {
   if (!node.$isAlive) {

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, x as IReversibleJsonPatch } from './tree-B2tSEN1S.mjs';
-export { L as CustomTypeOptions, D as IAnyComplexType, E as IAnyMixin, G as IJsonPatch, z as IMSTArray, A as IMSTMap, y as IStateTreeNode, H as IValidationContext, K as IValidationError, J as IValidationResult, B as ModelInstance, F as ModelSelf, C as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, 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 './tree-B2tSEN1S.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, x as IReversibleJsonPatch } from './tree-BV2K9utF.mjs';
+export { L as CustomTypeOptions, D as IAnyComplexType, E as IAnyMixin, G as IJsonPatch, z as IMSTArray, A as IMSTMap, y as IStateTreeNode, H as IValidationContext, K as IValidationError, J as IValidationResult, B as ModelInstance, F as ModelSelf, C as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, 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 './tree-BV2K9utF.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, x as IReversibleJsonPatch } from './tree-B2tSEN1S.js';
-export { L as CustomTypeOptions, D as IAnyComplexType, E as IAnyMixin, G as IJsonPatch, z as IMSTArray, A as IMSTMap, y as IStateTreeNode, H as IValidationContext, K as IValidationError, J as IValidationResult, B as ModelInstance, F as ModelSelf, C as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, 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 './tree-B2tSEN1S.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, x as IReversibleJsonPatch } from './tree-BV2K9utF.js';
+export { L as CustomTypeOptions, D as IAnyComplexType, E as IAnyMixin, G as IJsonPatch, z as IMSTArray, A as IMSTMap, y as IStateTreeNode, H as IValidationContext, K as IValidationError, J as IValidationResult, B as ModelInstance, F as ModelSelf, C as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, 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 './tree-BV2K9utF.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/index.js

@@ -508,6 +508,9 @@ var StateTreeNode = class {
     this.patchListeners = /* @__PURE__ */ new Set();
     /** Volatile state (non-serialized) */
     this.volatileState = {};
+    /** Cached snapshot for structural sharing optimization */
+    this.cachedSnapshot = void 0;
+    this.isSnapshotDirty = true;
     this.$id = generateNodeId();
     this.$type = type;
     this.$env = env ?? parent?.$env;
@@ -517,6 +520,15 @@ var StateTreeNode = class {
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
     nodeFinalizationRegistry.register(this, this.$id, this);
   }
+  invalidateSnapshot() {
+    if (!this.isSnapshotDirty) {
+      this.isSnapshotDirty = true;
+      this.cachedSnapshot = void 0;
+      if (this.$parent) {
+        this.$parent.invalidateSnapshot();
+      }
+    }
+  }
   /** Set the instance reference */
   setInstance(instance) {
     const entry = nodeRegistry.get(this.$id);
@@ -541,6 +553,9 @@ var StateTreeNode = class {
       );
     }
     const oldValue = this.getValue();
+    if (oldValue === value) {
+      return;
+    }
     globalStore.set(this.valueAtom, value);
     this.notifyPatch(
       { op: "replace", path: this.$path, value },
@@ -558,6 +573,7 @@ var StateTreeNode = class {
     child.$env = child.$env ?? this.$env;
     this.children.set(key, child);
     lifecycleHookHandlers.runAfterAttach?.(child);
+    this.invalidateSnapshot();
   }
   /** Recursively update the path of a node and all its children */
   updatePathRecursively(node, newPath) {
@@ -573,6 +589,7 @@ var StateTreeNode = class {
     if (child) {
       child.destroy();
       this.children.delete(key);
+      this.invalidateSnapshot();
     }
   }
   /** Get a child node */
@@ -635,6 +652,7 @@ var StateTreeNode = class {
   }
   /** Notify snapshot listeners */
   notifySnapshotChange() {
+    this.invalidateSnapshot();
     let current = this;
     while (current) {
       const snapshot = getSnapshotFromNode(current);
@@ -692,6 +710,7 @@ var StateTreeNode = class {
   detach() {
     if (this.$parent) {
       lifecycleHookHandlers.runBeforeDetach?.(this);
+      const parent = this.$parent;
       for (const [key, child] of this.$parent.children) {
         if (child === this) {
           this.$parent.children.delete(key);
@@ -700,6 +719,7 @@ var StateTreeNode = class {
       }
       this.$parent = null;
       this.$path = "";
+      parent.invalidateSnapshot();
     }
   }
 };
@@ -714,38 +734,44 @@ function hasStateTreeNode(instance) {
   return instance !== null && typeof instance === "object" && $treenode in instance;
 }
 function getSnapshotFromNode(node) {
+  if (!node.isSnapshotDirty && node.cachedSnapshot !== void 0) {
+    return node.cachedSnapshot;
+  }
   const type = node.$type;
   const value = node.getValue();
+  let snapshot;
   if (type._kind === "model") {
-    const snapshot = {};
+    const modelSnapshot = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      modelSnapshot[key] = getSnapshotFromNode(childNode);
     }
     if (node.postProcessor) {
-      return node.postProcessor(snapshot);
+      snapshot = node.postProcessor(modelSnapshot);
+    } else {
+      snapshot = modelSnapshot;
     }
-    return snapshot;
-  }
-  if (type._kind === "array") {
+  } else if (type._kind === "array") {
     const arr = value;
-    return arr.map((_, index) => {
+    snapshot = arr.map((_, index) => {
       const childNode = node.getChild(String(index));
       return childNode ? getSnapshotFromNode(childNode) : arr[index];
     });
-  }
-  if (type._kind === "map") {
-    const snapshot = {};
+  } else if (type._kind === "map") {
+    const mapSnapshot = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      mapSnapshot[key] = getSnapshotFromNode(childNode);
     }
-    return snapshot;
-  }
-  if (type._kind === "reference") {
-    return node.identifierValue ?? value;
+    snapshot = mapSnapshot;
+  } else if (type._kind === "reference") {
+    snapshot = node.identifierValue ?? value;
+  } else {
+    snapshot = value;
   }
-  return value;
+  node.cachedSnapshot = snapshot;
+  node.isSnapshotDirty = false;
+  return snapshot;
 }
 function applySnapshotToNode(node, snapshot) {
   if (!node.$isAlive) {

package/dist/index.mjs

@@ -56,7 +56,7 @@ import {
   tryResolve,
   unfreeze,
   walk
-} from "./chunk-3TQNT4MR.mjs";
+} from "./chunk-UOYV4J7H.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 } from './tree-B2tSEN1S.mjs';
-export { az as hasStateTreeNode } from './tree-B2tSEN1S.mjs';
+import { ag as getGlobalStore } from './tree-BV2K9utF.mjs';
+export { az as hasStateTreeNode } from './tree-BV2K9utF.mjs';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import React, { ComponentType, FC, ReactNode } from 'react';
-import { ag as getGlobalStore } from './tree-B2tSEN1S.js';
-export { az as hasStateTreeNode } from './tree-B2tSEN1S.js';
+import { ag as getGlobalStore } from './tree-BV2K9utF.js';
+export { az as hasStateTreeNode } from './tree-BV2K9utF.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/react.js

@@ -126,6 +126,9 @@ var StateTreeNode = class {
     this.patchListeners = /* @__PURE__ */ new Set();
     /** Volatile state (non-serialized) */
     this.volatileState = {};
+    /** Cached snapshot for structural sharing optimization */
+    this.cachedSnapshot = void 0;
+    this.isSnapshotDirty = true;
     this.$id = generateNodeId();
     this.$type = type;
     this.$env = env ?? parent?.$env;
@@ -135,6 +138,15 @@ var StateTreeNode = class {
     nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
     nodeFinalizationRegistry.register(this, this.$id, this);
   }
+  invalidateSnapshot() {
+    if (!this.isSnapshotDirty) {
+      this.isSnapshotDirty = true;
+      this.cachedSnapshot = void 0;
+      if (this.$parent) {
+        this.$parent.invalidateSnapshot();
+      }
+    }
+  }
   /** Set the instance reference */
   setInstance(instance) {
     const entry = nodeRegistry.get(this.$id);
@@ -159,6 +171,9 @@ var StateTreeNode = class {
       );
     }
     const oldValue = this.getValue();
+    if (oldValue === value) {
+      return;
+    }
     globalStore.set(this.valueAtom, value);
     this.notifyPatch(
       { op: "replace", path: this.$path, value },
@@ -176,6 +191,7 @@ var StateTreeNode = class {
     child.$env = child.$env ?? this.$env;
     this.children.set(key, child);
     lifecycleHookHandlers.runAfterAttach?.(child);
+    this.invalidateSnapshot();
   }
   /** Recursively update the path of a node and all its children */
   updatePathRecursively(node, newPath) {
@@ -191,6 +207,7 @@ var StateTreeNode = class {
     if (child) {
       child.destroy();
       this.children.delete(key);
+      this.invalidateSnapshot();
     }
   }
   /** Get a child node */
@@ -253,6 +270,7 @@ var StateTreeNode = class {
   }
   /** Notify snapshot listeners */
   notifySnapshotChange() {
+    this.invalidateSnapshot();
     let current = this;
     while (current) {
       const snapshot = getSnapshotFromNode(current);
@@ -310,6 +328,7 @@ var StateTreeNode = class {
   detach() {
     if (this.$parent) {
       lifecycleHookHandlers.runBeforeDetach?.(this);
+      const parent = this.$parent;
       for (const [key, child] of this.$parent.children) {
         if (child === this) {
           this.$parent.children.delete(key);
@@ -318,6 +337,7 @@ var StateTreeNode = class {
       }
       this.$parent = null;
       this.$path = "";
+      parent.invalidateSnapshot();
     }
   }
 };
@@ -332,38 +352,44 @@ function hasStateTreeNode(instance) {
   return instance !== null && typeof instance === "object" && $treenode in instance;
 }
 function getSnapshotFromNode(node) {
+  if (!node.isSnapshotDirty && node.cachedSnapshot !== void 0) {
+    return node.cachedSnapshot;
+  }
   const type = node.$type;
   const value = node.getValue();
+  let snapshot;
   if (type._kind === "model") {
-    const snapshot = {};
+    const modelSnapshot = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      modelSnapshot[key] = getSnapshotFromNode(childNode);
     }
     if (node.postProcessor) {
-      return node.postProcessor(snapshot);
+      snapshot = node.postProcessor(modelSnapshot);
+    } else {
+      snapshot = modelSnapshot;
     }
-    return snapshot;
-  }
-  if (type._kind === "array") {
+  } else if (type._kind === "array") {
     const arr = value;
-    return arr.map((_, index) => {
+    snapshot = arr.map((_, index) => {
       const childNode = node.getChild(String(index));
       return childNode ? getSnapshotFromNode(childNode) : arr[index];
     });
-  }
-  if (type._kind === "map") {
-    const snapshot = {};
+  } else if (type._kind === "map") {
+    const mapSnapshot = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      mapSnapshot[key] = getSnapshotFromNode(childNode);
     }
-    return snapshot;
-  }
-  if (type._kind === "reference") {
-    return node.identifierValue ?? value;
+    snapshot = mapSnapshot;
+  } else if (type._kind === "reference") {
+    snapshot = node.identifierValue ?? value;
+  } else {
+    snapshot = value;
   }
-  return value;
+  node.cachedSnapshot = snapshot;
+  node.isSnapshotDirty = false;
+  return snapshot;
 }
 function getSnapshot(target) {
   const node = getStateTreeNode(target);

package/dist/react.mjs

@@ -9,7 +9,7 @@ import {
   onPatch,
   onSnapshot,
   setActiveTrackingFn
-} from "./chunk-3TQNT4MR.mjs";
+} from "./chunk-UOYV4J7H.mjs";
 
 // src/react.ts
 import React, {

package/dist/{tree-B2tSEN1S.d.mts → tree-BV2K9utF.d.mts}

@@ -343,6 +343,10 @@ declare class StateTreeNode implements IStateTreeNode {
     identifierValue?: string | number;
     /** Type name for identifier registry */
     identifierTypeName?: string;
+    /** Cached snapshot for structural sharing optimization */
+    cachedSnapshot: unknown;
+    isSnapshotDirty: boolean;
+    invalidateSnapshot(): void;
     constructor(type: IAnyType, initialValue: unknown, env?: unknown, parent?: StateTreeNode, pathSegment?: string);
     /** Set the instance reference */
     setInstance(instance: unknown): void;

package/dist/{tree-B2tSEN1S.d.ts → tree-BV2K9utF.d.ts}

@@ -343,6 +343,10 @@ declare class StateTreeNode implements IStateTreeNode {
     identifierValue?: string | number;
     /** Type name for identifier registry */
     identifierTypeName?: string;
+    /** Cached snapshot for structural sharing optimization */
+    cachedSnapshot: unknown;
+    isSnapshotDirty: boolean;
+    invalidateSnapshot(): void;
     constructor(type: IAnyType, initialValue: unknown, env?: unknown, parent?: StateTreeNode, pathSegment?: string);
     /** Set the instance reference */
     setInstance(instance: unknown): void;

package/package.json

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

package/src/__tests__/performance.test.ts

@@ -270,7 +270,7 @@ describe("Performance", () => {
           },
         }));
 
-      const instance = Model.create({ value: 0 });
+      const instance = Model.create({ value: -1 });
 
       // Add many listeners
       const disposers: (() => void)[] = [];
@@ -312,7 +312,7 @@ describe("Performance", () => {
           },
         }));
 
-      const instance = Model.create({ value: 0 });
+      const instance = Model.create({ value: -1 });
 
       const disposers: (() => void)[] = [];
       let patchCount = 0;

package/src/__tests__/snapshot-sharing.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+import { types, getSnapshot, applySnapshot } from "../index";
+
+describe("Snapshot Structural Sharing", () => {
+  it("should reuse snapshot references if nothing changes", () => {
+    const Child = types.model("Child", {
+      id: types.identifier,
+      value: types.string,
+    });
+
+    const Root = types.model("Root", {
+      child1: Child,
+      child2: Child,
+    });
+
+    const root = Root.create({
+      child1: { id: "1", value: "A" },
+      child2: { id: "2", value: "B" },
+    });
+
+    const snap1 = getSnapshot<any>(root);
+    const snap2 = getSnapshot<any>(root);
+
+    // If no changes occurred, snapshot references should be identical
+    expect(snap1).toBe(snap2);
+    expect(snap1.child1).toBe(snap2.child1);
+    expect(snap1.child2).toBe(snap2.child2);
+  });
+
+  it("should share unmodified branch references when a sub-branch changes", () => {
+    const Child = types
+      .model("Child", {
+        id: types.identifier,
+        value: types.string,
+      })
+      .actions((self) => ({
+        setValue(val: string) {
+          self.value = val;
+        },
+      }));
+
+    const Root = types.model("Root", {
+      child1: Child,
+      child2: Child,
+    });
+
+    const root = Root.create({
+      child1: { id: "1", value: "A" },
+      child2: { id: "2", value: "B" },
+    });
+
+    const snap1 = getSnapshot<any>(root);
+
+    // Modify child1
+    root.child1.setValue("A-modified");
+
+    const snap2 = getSnapshot<any>(root);
+
+    // The root and child1 snapshots should be new objects
+    expect(snap2).not.toBe(snap1);
+    expect(snap2.child1).not.toBe(snap1.child1);
+    expect(snap2.child1.value).toBe("A-modified");
+
+    // The child2 snapshot should be exactly the same object reference!
+    expect(snap2.child2).toBe(snap1.child2);
+    expect(snap2.child2.value).toBe("B");
+  });
+
+  it("should perform structural sharing with arrays", () => {
+    const Item = types
+      .model("Item", {
+        id: types.identifier,
+        name: types.string,
+      })
+      .actions((self) => ({
+        setName(name: string) {
+          self.name = name;
+        },
+      }));
+
+    const Root = types.model("Root", {
+      items: types.array(Item),
+    });
+
+    const root = Root.create({
+      items: [
+        { id: "1", name: "Item 1" },
+        { id: "2", name: "Item 2" },
+      ],
+    });
+
+    const snap1 = getSnapshot<any>(root);
+
+    // Modify Item 2
+    root.items[1].setName("Item 2-modified");
+
+    const snap2 = getSnapshot<any>(root);
+
+    expect(snap2).not.toBe(snap1);
+    expect(snap2.items).not.toBe(snap1.items);
+    
+    // Unmodified Item 1 snapshot should have identical reference
+    expect(snap2.items[0]).toBe(snap1.items[0]);
+    // Modified Item 2 snapshot should have a new reference
+    expect(snap2.items[1]).not.toBe(snap1.items[1]);
+  });
+
+  it("should perform structural sharing with maps", () => {
+    const Item = types
+      .model("Item", {
+        id: types.identifier,
+        name: types.string,
+      })
+      .actions((self) => ({
+        setName(name: string) {
+          self.name = name;
+        },
+      }));
+
+    const Root = types.model("Root", {
+      items: types.map(Item),
+    });
+
+    const root = Root.create({
+      items: {
+        a: { id: "1", name: "Item A" },
+        b: { id: "2", name: "Item B" },
+      },
+    });
+
+    const snap1 = getSnapshot<any>(root);
+
+    // Modify Item B
+    root.items.get("b")!.setName("Item B-modified");
+
+    const snap2 = getSnapshot<any>(root);
+
+    expect(snap2).not.toBe(snap1);
+    expect(snap2.items).not.toBe(snap1.items);
+
+    // Unmodified Item A snapshot should have identical reference
+    expect(snap2.items.a).toBe(snap1.items.a);
+    // Modified Item B snapshot should have a new reference
+    expect(snap2.items.b).not.toBe(snap1.items.b);
+  });
+
+  it("should handle applySnapshot and correctly update caching", () => {
+    const Child = types.model("Child", {
+      value: types.string,
+    });
+
+    const Root = types.model("Root", {
+      child1: Child,
+      child2: Child,
+    });
+
+    const root = Root.create({
+      child1: { value: "A" },
+      child2: { value: "B" },
+    });
+
+    const snap1 = getSnapshot<any>(root);
+
+    // Apply snapshot updating only child1
+    applySnapshot(root, {
+      child1: { value: "A-updated" },
+      child2: { value: "B" },
+    });
+
+    const snap2 = getSnapshot<any>(root);
+
+    expect(snap2).not.toBe(snap1);
+    expect(snap2.child1).not.toBe(snap1.child1);
+    expect(snap2.child1.value).toBe("A-updated");
+
+    // child2 was not modified, so it should keep the same reference
+    expect(snap2.child2).toBe(snap1.child2);
+  });
+});

package/src/tree.ts

@@ -202,6 +202,20 @@ export class StateTreeNode implements IStateTreeNode {
   /** Type name for identifier registry */
   identifierTypeName?: string;
 
+  /** Cached snapshot for structural sharing optimization */
+  cachedSnapshot: unknown = undefined;
+  isSnapshotDirty = true;
+
+  invalidateSnapshot() {
+    if (!this.isSnapshotDirty) {
+      this.isSnapshotDirty = true;
+      this.cachedSnapshot = undefined;
+      if (this.$parent) {
+        this.$parent.invalidateSnapshot();
+      }
+    }
+  }
+
   constructor(
     type: IAnyType,
     initialValue: unknown,
@@ -254,6 +268,9 @@ export class StateTreeNode implements IStateTreeNode {
     }
 
     const oldValue = this.getValue();
+    if (oldValue === value) {
+      return;
+    }
     globalStore.set(this.valueAtom, value);
 
     // Notify patch listeners
@@ -276,6 +293,7 @@ export class StateTreeNode implements IStateTreeNode {
     child.$env = child.$env ?? this.$env;
     this.children.set(key, child);
     lifecycleHookHandlers.runAfterAttach?.(child);
+    this.invalidateSnapshot();
   }
 
   /** Recursively update the path of a node and all its children */
@@ -295,6 +313,7 @@ export class StateTreeNode implements IStateTreeNode {
     if (child) {
       child.destroy();
       this.children.delete(key);
+      this.invalidateSnapshot();
     }
   }
 
@@ -376,6 +395,7 @@ export class StateTreeNode implements IStateTreeNode {
 
   /** Notify snapshot listeners */
   private notifySnapshotChange() {
+    this.invalidateSnapshot();
     let current: StateTreeNode | null = this;
     while (current) {
       const snapshot = getSnapshotFromNode(current);
@@ -464,6 +484,7 @@ export class StateTreeNode implements IStateTreeNode {
       // Run beforeDetach hook
       lifecycleHookHandlers.runBeforeDetach?.(this);
 
+      const parent = this.$parent;
       // Find our key in parent's children
       for (const [key, child] of this.$parent.children) {
         if (child === this) {
@@ -473,6 +494,7 @@ export class StateTreeNode implements IStateTreeNode {
       }
       this.$parent = null;
       this.$path = "";
+      parent.invalidateSnapshot();
     }
   }
 }
@@ -501,50 +523,54 @@ export function hasStateTreeNode(instance: unknown): boolean {
 
 /** Get snapshot from a node */
 export function getSnapshotFromNode(node: StateTreeNode): unknown {
+  if (!node.isSnapshotDirty && node.cachedSnapshot !== undefined) {
+    return node.cachedSnapshot;
+  }
+
   const type = node.$type;
   const value = node.getValue();
+  let snapshot: unknown;
 
   // Handle based on type kind
   if (type._kind === "model") {
-    const snapshot: Record<string, unknown> = {};
+    const modelSnapshot: Record<string, unknown> = {};
     const children = node.getChildren();
 
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      modelSnapshot[key] = getSnapshotFromNode(childNode);
     }
 
     // Apply post processor if exists
     if (node.postProcessor) {
-      return node.postProcessor(snapshot);
+      snapshot = node.postProcessor(modelSnapshot);
+    } else {
+      snapshot = modelSnapshot;
     }
-
-    return snapshot;
-  }
-
-  if (type._kind === "array") {
+  } else if (type._kind === "array") {
     const arr = value as unknown[];
-    return arr.map((_, index) => {
+    snapshot = arr.map((_, index) => {
       const childNode = node.getChild(String(index));
       return childNode ? getSnapshotFromNode(childNode) : arr[index];
     });
-  }
-
-  if (type._kind === "map") {
-    const snapshot: Record<string, unknown> = {};
+  } else if (type._kind === "map") {
+    const mapSnapshot: Record<string, unknown> = {};
     const children = node.getChildren();
     for (const [key, childNode] of children) {
-      snapshot[key] = getSnapshotFromNode(childNode);
+      mapSnapshot[key] = getSnapshotFromNode(childNode);
     }
-    return snapshot;
-  }
-
-  if (type._kind === "reference") {
+    snapshot = mapSnapshot;
+  } else if (type._kind === "reference") {
     // Return the identifier, not the resolved value
-    return node.identifierValue ?? value;
+    snapshot = node.identifierValue ?? value;
+  } else {
+    // For primitives and frozen, return the value directly
+    snapshot = value;
   }
 
-  // For primitives and frozen, return the value directly
-  return value;
+  node.cachedSnapshot = snapshot;
+  node.isSnapshotDirty = false;
+
+  return snapshot;
 }
 
 /** Apply snapshot to a node */