jotai-state-tree 1.3.3 → 1.3.5

package/dist/{chunk-OAXK4KFM.mjs → chunk-E6MXYAAH.mjs}

@@ -4,6 +4,13 @@ var lifecycleHookHandlers = {};
 function setLifecycleHookHandlers(handlers) {
   lifecycleHookHandlers = handlers;
 }
+var isApplyingSnapshotOrPatch = false;
+function getIsApplyingSnapshotOrPatch() {
+  return isApplyingSnapshotOrPatch;
+}
+function setIsApplyingSnapshotOrPatch(value) {
+  isApplyingSnapshotOrPatch = value;
+}
 var globalStore = createStore();
 function getGlobalStore() {
   return globalStore;
@@ -69,6 +76,7 @@ var StateTreeNode = class {
     this.$parent = null;
     this.$path = "";
     this.$isAlive = true;
+    this.$isApplyingHistory = false;
     /** Child nodes - uses Map but children are explicitly destroyed */
     this.children = /* @__PURE__ */ new Map();
     /** Snapshot listeners */
@@ -221,9 +229,9 @@ var StateTreeNode = class {
   }
   /** Notify snapshot listeners */
   notifySnapshotChange() {
-    this.invalidateSnapshot();
     let current = this;
     while (current) {
+      current.invalidateSnapshot();
       const snapshot = getSnapshotFromNode(current);
       current.snapshotListeners.forEach((listener) => listener(snapshot));
       current = current.$parent;
@@ -359,9 +367,19 @@ function applySnapshotToNode(node, snapshot) {
       }
     }
   } else if (type._kind === "array" && Array.isArray(snapshot)) {
-    node.setValue(snapshot);
+    const mstArray = node.getInstance();
+    if (mstArray) {
+      mstArray.replace(snapshot);
+    } else {
+      node.setValue(snapshot);
+    }
   } else if (type._kind === "map" && typeof snapshot === "object" && snapshot !== null) {
-    node.setValue(snapshot);
+    const mstMap = node.getInstance();
+    if (mstMap) {
+      mstMap.replace(snapshot);
+    } else {
+      node.setValue(snapshot);
+    }
   } else {
     node.setValue(snapshot);
   }
@@ -522,7 +540,13 @@ function getSnapshot(target) {
 }
 function applySnapshot(target, snapshot) {
   const node = getStateTreeNode(target);
-  applySnapshotToNode(node, snapshot);
+  const wasApplying = getIsApplyingSnapshotOrPatch();
+  setIsApplyingSnapshotOrPatch(true);
+  try {
+    applySnapshotToNode(node, snapshot);
+  } finally {
+    setIsApplyingSnapshotOrPatch(wasApplying);
+  }
 }
 function onSnapshot(target, listener) {
   const node = getStateTreeNode(target);
@@ -535,8 +559,14 @@ function onPatch(target, listener) {
 function applyPatch(target, patch) {
   const patches = Array.isArray(patch) ? patch : [patch];
   const rootNode = getStateTreeNode(target).getRoot();
-  for (const p of patches) {
-    applyPatchToNode(rootNode, p);
+  const wasApplying = getIsApplyingSnapshotOrPatch();
+  setIsApplyingSnapshotOrPatch(true);
+  try {
+    for (const p of patches) {
+      applyPatchToNode(rootNode, p);
+    }
+  } finally {
+    setIsApplyingSnapshotOrPatch(wasApplying);
   }
 }
 function applyPatchToNode(rootNode, patch) {
@@ -552,37 +582,61 @@ function applyPatchToNode(rootNode, patch) {
   const key = pathParts[pathParts.length - 1];
   switch (patch.op) {
     case "replace": {
-      const childNode = node.getChild(key);
-      if (childNode) {
-        applySnapshotToNode(childNode, patch.value);
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = parseInt(key, 10);
+        instance[index] = patch.value;
+      } else if (instance && instance instanceof Map) {
+        instance.set(key, patch.value);
       } else {
-        const currentValue = node.getValue();
-        currentValue[key] = patch.value;
-        node.setValue(currentValue);
+        const childNode = node.getChild(key);
+        if (childNode) {
+          applySnapshotToNode(childNode, patch.value);
+        } else {
+          const currentValue = node.getValue();
+          currentValue[key] = patch.value;
+          node.setValue(currentValue);
+        }
       }
       break;
     }
     case "add": {
-      const currentValue = node.getValue();
-      if (Array.isArray(currentValue)) {
-        const index = key === "-" ? currentValue.length : parseInt(key, 10);
-        currentValue.splice(index, 0, patch.value);
-        node.setValue([...currentValue]);
-      } else if (typeof currentValue === "object" && currentValue !== null) {
-        currentValue[key] = patch.value;
-        node.setValue({ ...currentValue });
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = key === "-" ? instance.length : parseInt(key, 10);
+        instance.splice(index, 0, patch.value);
+      } else if (instance && instance instanceof Map) {
+        instance.set(key, patch.value);
+      } else {
+        const currentValue = node.getValue();
+        if (Array.isArray(currentValue)) {
+          const index = key === "-" ? currentValue.length : parseInt(key, 10);
+          currentValue.splice(index, 0, patch.value);
+          node.setValue([...currentValue]);
+        } else if (typeof currentValue === "object" && currentValue !== null) {
+          currentValue[key] = patch.value;
+          node.setValue({ ...currentValue });
+        }
       }
       break;
     }
     case "remove": {
-      const currentValue = node.getValue();
-      if (Array.isArray(currentValue)) {
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
         const index = parseInt(key, 10);
-        currentValue.splice(index, 1);
-        node.setValue([...currentValue]);
-      } else if (typeof currentValue === "object" && currentValue !== null) {
-        delete currentValue[key];
-        node.setValue({ ...currentValue });
+        instance.splice(index, 1);
+      } else if (instance && instance instanceof Map) {
+        instance.delete(key);
+      } else {
+        const currentValue = node.getValue();
+        if (Array.isArray(currentValue)) {
+          const index = parseInt(key, 10);
+          currentValue.splice(index, 1);
+          node.setValue([...currentValue]);
+        } else if (typeof currentValue === "object" && currentValue !== null) {
+          delete currentValue[key];
+          node.setValue({ ...currentValue });
+        }
       }
       break;
     }
@@ -636,7 +690,7 @@ function isActionRunning() {
 }
 function trackAction(node, name, args, fn) {
   const previousAction = currentAction;
-  currentAction = { name, args, tree: node };
+  currentAction = { name, args, tree: node, parent: previousAction };
   try {
     const result = fn();
     const call = {
@@ -847,6 +901,7 @@ function unfreeze(target) {
 
 export {
   setLifecycleHookHandlers,
+  getIsApplyingSnapshotOrPatch,
   getGlobalStore,
   setGlobalStore,
   resetGlobalStore,
@@ -858,6 +913,7 @@ export {
   $treenode,
   getStateTreeNode,
   hasStateTreeNode,
+  getSnapshotFromNode,
   applySnapshotToNode,
   resolveIdentifier,
   getRegistryStats,

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-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 { 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-BMaFqD3f.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-BMaFqD3f.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-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 { 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-BMaFqD3f.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-BMaFqD3f.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/index.js

@@ -441,6 +441,13 @@ var lifecycleHookHandlers = {};
 function setLifecycleHookHandlers(handlers) {
   lifecycleHookHandlers = handlers;
 }
+var isApplyingSnapshotOrPatch = false;
+function getIsApplyingSnapshotOrPatch() {
+  return isApplyingSnapshotOrPatch;
+}
+function setIsApplyingSnapshotOrPatch(value) {
+  isApplyingSnapshotOrPatch = value;
+}
 var globalStore = (0, import_jotai.createStore)();
 function getGlobalStore() {
   return globalStore;
@@ -500,6 +507,7 @@ var StateTreeNode = class {
     this.$parent = null;
     this.$path = "";
     this.$isAlive = true;
+    this.$isApplyingHistory = false;
     /** Child nodes - uses Map but children are explicitly destroyed */
     this.children = /* @__PURE__ */ new Map();
     /** Snapshot listeners */
@@ -652,9 +660,9 @@ var StateTreeNode = class {
   }
   /** Notify snapshot listeners */
   notifySnapshotChange() {
-    this.invalidateSnapshot();
     let current = this;
     while (current) {
+      current.invalidateSnapshot();
       const snapshot = getSnapshotFromNode(current);
       current.snapshotListeners.forEach((listener) => listener(snapshot));
       current = current.$parent;
@@ -790,9 +798,19 @@ function applySnapshotToNode(node, snapshot) {
       }
     }
   } else if (type._kind === "array" && Array.isArray(snapshot)) {
-    node.setValue(snapshot);
+    const mstArray = node.getInstance();
+    if (mstArray) {
+      mstArray.replace(snapshot);
+    } else {
+      node.setValue(snapshot);
+    }
   } else if (type._kind === "map" && typeof snapshot === "object" && snapshot !== null) {
-    node.setValue(snapshot);
+    const mstMap = node.getInstance();
+    if (mstMap) {
+      mstMap.replace(snapshot);
+    } else {
+      node.setValue(snapshot);
+    }
   } else {
     node.setValue(snapshot);
   }
@@ -953,7 +971,13 @@ function getSnapshot(target) {
 }
 function applySnapshot(target, snapshot) {
   const node = getStateTreeNode(target);
-  applySnapshotToNode(node, snapshot);
+  const wasApplying = getIsApplyingSnapshotOrPatch();
+  setIsApplyingSnapshotOrPatch(true);
+  try {
+    applySnapshotToNode(node, snapshot);
+  } finally {
+    setIsApplyingSnapshotOrPatch(wasApplying);
+  }
 }
 function onSnapshot(target, listener) {
   const node = getStateTreeNode(target);
@@ -966,8 +990,14 @@ function onPatch(target, listener) {
 function applyPatch(target, patch) {
   const patches = Array.isArray(patch) ? patch : [patch];
   const rootNode = getStateTreeNode(target).getRoot();
-  for (const p of patches) {
-    applyPatchToNode(rootNode, p);
+  const wasApplying = getIsApplyingSnapshotOrPatch();
+  setIsApplyingSnapshotOrPatch(true);
+  try {
+    for (const p of patches) {
+      applyPatchToNode(rootNode, p);
+    }
+  } finally {
+    setIsApplyingSnapshotOrPatch(wasApplying);
   }
 }
 function applyPatchToNode(rootNode, patch) {
@@ -983,37 +1013,61 @@ function applyPatchToNode(rootNode, patch) {
   const key = pathParts[pathParts.length - 1];
   switch (patch.op) {
     case "replace": {
-      const childNode = node.getChild(key);
-      if (childNode) {
-        applySnapshotToNode(childNode, patch.value);
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = parseInt(key, 10);
+        instance[index] = patch.value;
+      } else if (instance && instance instanceof Map) {
+        instance.set(key, patch.value);
       } else {
-        const currentValue = node.getValue();
-        currentValue[key] = patch.value;
-        node.setValue(currentValue);
+        const childNode = node.getChild(key);
+        if (childNode) {
+          applySnapshotToNode(childNode, patch.value);
+        } else {
+          const currentValue = node.getValue();
+          currentValue[key] = patch.value;
+          node.setValue(currentValue);
+        }
       }
       break;
     }
     case "add": {
-      const currentValue = node.getValue();
-      if (Array.isArray(currentValue)) {
-        const index = key === "-" ? currentValue.length : parseInt(key, 10);
-        currentValue.splice(index, 0, patch.value);
-        node.setValue([...currentValue]);
-      } else if (typeof currentValue === "object" && currentValue !== null) {
-        currentValue[key] = patch.value;
-        node.setValue({ ...currentValue });
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = key === "-" ? instance.length : parseInt(key, 10);
+        instance.splice(index, 0, patch.value);
+      } else if (instance && instance instanceof Map) {
+        instance.set(key, patch.value);
+      } else {
+        const currentValue = node.getValue();
+        if (Array.isArray(currentValue)) {
+          const index = key === "-" ? currentValue.length : parseInt(key, 10);
+          currentValue.splice(index, 0, patch.value);
+          node.setValue([...currentValue]);
+        } else if (typeof currentValue === "object" && currentValue !== null) {
+          currentValue[key] = patch.value;
+          node.setValue({ ...currentValue });
+        }
       }
       break;
     }
     case "remove": {
-      const currentValue = node.getValue();
-      if (Array.isArray(currentValue)) {
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
         const index = parseInt(key, 10);
-        currentValue.splice(index, 1);
-        node.setValue([...currentValue]);
-      } else if (typeof currentValue === "object" && currentValue !== null) {
-        delete currentValue[key];
-        node.setValue({ ...currentValue });
+        instance.splice(index, 1);
+      } else if (instance && instance instanceof Map) {
+        instance.delete(key);
+      } else {
+        const currentValue = node.getValue();
+        if (Array.isArray(currentValue)) {
+          const index = parseInt(key, 10);
+          currentValue.splice(index, 1);
+          node.setValue([...currentValue]);
+        } else if (typeof currentValue === "object" && currentValue !== null) {
+          delete currentValue[key];
+          node.setValue({ ...currentValue });
+        }
       }
       break;
     }
@@ -1067,7 +1121,7 @@ function isActionRunning() {
 }
 function trackAction(node, name, args, fn) {
   const previousAction = currentAction;
-  currentAction = { name, args, tree: node };
+  currentAction = { name, args, tree: node, parent: previousAction };
   try {
     const result = fn();
     const call = {
@@ -1623,6 +1677,9 @@ function canWrite(node) {
   if (!node.$isAlive) {
     return false;
   }
+  if (getIsApplyingSnapshotOrPatch()) {
+    return true;
+  }
   if (typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production") {
     return true;
   }
@@ -2418,6 +2475,13 @@ var MSTArray = class _MSTArray extends Array {
     return [...this];
   }
   syncToNode() {
+    const oldArray = this.node.getValue() || [];
+    const newArray = [...this];
+    const oldSnapshots = /* @__PURE__ */ new Map();
+    for (let i = 0; i < oldArray.length; i++) {
+      const childNode = this.node.getChild(String(i));
+      oldSnapshots.set(i, childNode ? getSnapshotFromNode(childNode) : oldArray[i]);
+    }
     const existingChildNodes = /* @__PURE__ */ new Set();
     for (const [, child] of this.node.getChildren()) {
       existingChildNodes.add(child);
@@ -2469,7 +2533,59 @@ var MSTArray = class _MSTArray extends Array {
     for (const [key, childNode] of newChildren) {
       this.node.addChild(key, childNode);
     }
-    this.node.setValue([...this]);
+    const patches = [];
+    const reversePatches = [];
+    if (newArray.length > oldArray.length && oldArray.every((val, idx) => val === newArray[idx])) {
+      for (let i = oldArray.length; i < newArray.length; i++) {
+        const childNode = this.node.getChild(String(i));
+        const valSnap = childNode ? getSnapshotFromNode(childNode) : newArray[i];
+        patches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: valSnap
+        });
+        reversePatches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+      }
+    } else if (newArray.length < oldArray.length && newArray.every((val, idx) => val === oldArray[idx])) {
+      for (let i = oldArray.length - 1; i >= newArray.length; i--) {
+        const oldValSnap = oldSnapshots.get(i);
+        patches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+        reversePatches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: oldValSnap
+        });
+      }
+    } else {
+      const oldSnap = oldArray.map((_, idx) => oldSnapshots.get(idx));
+      const newSnap = newArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : newArray[idx];
+      });
+      patches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: newSnap
+      });
+      reversePatches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: oldSnap
+      });
+    }
+    const store = getGlobalStore();
+    store.set(this.node.valueAtom, newArray);
+    this.node.invalidateSnapshot();
+    patches.forEach((patch, idx) => {
+      this.node.notifyPatch(patch, reversePatches[idx]);
+    });
+    this.node.notifyVolatileChange();
   }
 };
 var ArrayType = class {
@@ -3557,9 +3673,11 @@ var UndoManager = class {
     this.isRedoing = false;
     this.skipRecording = false;
     this.grouping = false;
+    this.actionGrouping = false;
     this.currentGroup = [];
     this.currentGroupInverse = [];
     this.disposer = null;
+    this.actionDisposer = null;
     this.lastChangeTime = 0;
     this.target = target;
     this.options = {
@@ -3570,6 +3688,14 @@ var UndoManager = class {
     this.disposer = onPatch(target, (patch, reversePatch) => {
       this.recordPatch(patch, reversePatch);
     });
+    this.actionDisposer = onAction(target, () => {
+      const current = getCurrentAction();
+      if (current && !current.parent) {
+        if (this.actionGrouping) {
+          this.endGroup();
+        }
+      }
+    });
   }
   get canUndo() {
     return this.currentIndex >= 0;
@@ -3593,16 +3719,31 @@ var UndoManager = class {
     if (this.isUndoing || this.isRedoing || this.skipRecording) {
       return;
     }
+    const node = getStateTreeNode(this.target);
+    if (node.getRoot().$isApplyingHistory) {
+      return;
+    }
     const now = Date.now();
+    if (isActionRunning() && !this.grouping) {
+      this.grouping = true;
+      this.actionGrouping = true;
+      this.currentGroup = [];
+      this.currentGroupInverse = [];
+      Promise.resolve().then(() => {
+        if (this.actionGrouping) {
+          this.endGroup();
+        }
+      });
+    }
     if (this.grouping) {
       this.currentGroup.push(reversePatch);
-      this.currentGroupInverse.unshift({ ...patch });
+      this.currentGroupInverse.push({ ...patch });
       return;
     }
     if (this.options.groupByTime && this.historyEntries.length > 0 && now - this.lastChangeTime < this.options.groupingWindow && this.currentIndex === this.historyEntries.length - 1) {
       const lastEntry = this.historyEntries[this.currentIndex];
       lastEntry.patches.push(reversePatch);
-      lastEntry.inversePatches.unshift({ ...patch });
+      lastEntry.inversePatches.push({ ...patch });
       lastEntry.timestamp = now;
     } else {
       if (this.currentIndex < this.historyEntries.length - 1) {
@@ -3626,6 +3767,10 @@ var UndoManager = class {
     if (!this.canUndo) {
       return;
     }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
     this.isUndoing = true;
     try {
       const entry = this.historyEntries[this.currentIndex];
@@ -3635,12 +3780,17 @@ var UndoManager = class {
       this.currentIndex--;
     } finally {
       this.isUndoing = false;
+      rootNode.$isApplyingHistory = wasApplying;
     }
   }
   redo() {
     if (!this.canRedo) {
       return;
     }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
     this.isRedoing = true;
     try {
       this.currentIndex++;
@@ -3650,6 +3800,7 @@ var UndoManager = class {
       }
     } finally {
       this.isRedoing = false;
+      rootNode.$isApplyingHistory = wasApplying;
     }
   }
   clear() {
@@ -3658,9 +3809,11 @@ var UndoManager = class {
     this.currentGroup = [];
     this.currentGroupInverse = [];
     this.grouping = false;
+    this.actionGrouping = false;
   }
   startGroup() {
     this.grouping = true;
+    this.actionGrouping = false;
     this.currentGroup = [];
     this.currentGroupInverse = [];
   }
@@ -3669,6 +3822,7 @@ var UndoManager = class {
       return;
     }
     this.grouping = false;
+    this.actionGrouping = false;
     if (this.currentGroup.length > 0) {
       if (this.currentIndex < this.historyEntries.length - 1) {
         this.historyEntries.splice(this.currentIndex + 1);
@@ -3701,6 +3855,10 @@ var UndoManager = class {
       this.disposer();
       this.disposer = null;
     }
+    if (this.actionDisposer) {
+      this.actionDisposer();
+      this.actionDisposer = null;
+    }
     this.clear();
   }
 };
@@ -3719,9 +3877,12 @@ var TimeTravelManager = class {
     this.record();
     if (this.autoRecord) {
       this.disposer = onPatch(target, () => {
-        if (!this.isApplying) {
-          this.record();
+        if (this.isApplying) return;
+        const node = getStateTreeNode(this.target);
+        if (node.getRoot().$isApplyingHistory) {
+          return;
         }
+        this.record();
       });
     }
   }
@@ -3759,12 +3920,17 @@ var TimeTravelManager = class {
   }
   goTo(index) {
     if (index < 0 || index >= this.snapshots.length) return;
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
     this.isApplying = true;
     try {
       this.index = index;
       applySnapshot(this.target, this.snapshots[index]);
     } finally {
       this.isApplying = false;
+      rootNode.$isApplyingHistory = wasApplying;
     }
   }
   getSnapshot(index) {