jotai-state-tree 1.4.2 → 1.4.4

package/dist/{chunk-Q6QPBXHH.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();
@@ -953,29 +996,32 @@ function unfreeze(target) {
 }
 
 // src/undo.ts
-var undoManagersRegistry = /* @__PURE__ */ new WeakMap();
-var timeTravelManagersRegistry = /* @__PURE__ */ new WeakMap();
-var UndoManager = class {
+import { atom as atom2 } from "jotai";
+var historyTrackersRegistry = /* @__PURE__ */ new WeakMap();
+var HistoryTracker = class {
   constructor(target, options = {}) {
-    this.historyEntries = [];
-    this.currentIndex = -1;
-    this.isUndoing = false;
-    this.isRedoing = false;
+    // Transient state
+    this.autoRecord = false;
+    this.isApplyingHistory = false;
     this.skipRecording = false;
     this.grouping = false;
     this.actionGrouping = false;
     this.currentGroup = [];
     this.currentGroupInverse = [];
+    this.lastChangeTime = 0;
     this.disposer = null;
     this.actionDisposer = null;
-    this.lastChangeTime = 0;
     this.target = target;
-    this.options = {
-      maxHistoryLength: options.maxHistoryLength ?? 100,
-      groupByTime: options.groupByTime ?? false,
-      groupingWindow: options.groupingWindow ?? 200
-    };
-    undoManagersRegistry.set(target, this);
+    this.maxHistoryLength = options.maxHistoryLength ?? options.maxSnapshots ?? 100;
+    this.groupByTime = options.groupByTime ?? false;
+    this.groupingWindow = options.groupingWindow ?? 200;
+    this.autoRecord = options.autoRecord ?? false;
+    const initialSnapshot = getSnapshot(target);
+    this.historyAtom = atom2({
+      entries: [],
+      currentIndex: -1,
+      initialSnapshot
+    });
     this.disposer = onPatch(target, (patch, reversePatch) => {
       this.recordPatch(patch, reversePatch);
     });
@@ -988,32 +1034,18 @@ var UndoManager = class {
       }
     });
   }
-  get canUndo() {
-    return this.currentIndex >= 0;
-  }
-  get canRedo() {
-    return this.currentIndex < this.historyEntries.length - 1;
-  }
-  get undoLevels() {
-    return this.currentIndex + 1;
-  }
-  get redoLevels() {
-    return this.historyEntries.length - this.currentIndex - 1;
-  }
-  get history() {
-    return [...this.historyEntries];
-  }
-  get historyIndex() {
-    return this.currentIndex;
-  }
   recordPatch(patch, reversePatch) {
-    if (this.isUndoing || this.isRedoing || this.skipRecording) {
+    if (!this.autoRecord) {
+      return;
+    }
+    if (this.isApplyingHistory || this.skipRecording) {
       return;
     }
     const node = getStateTreeNode(this.target);
     if (node.getRoot().$isApplyingHistory) {
       return;
     }
+    const store = getGlobalStore();
     const now = Date.now();
     if (isActionRunning() && !this.grouping) {
       this.grouping = true;
@@ -1031,86 +1063,172 @@ var UndoManager = class {
       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.push({ ...patch });
-      lastEntry.timestamp = now;
-    } else {
-      if (this.currentIndex < this.historyEntries.length - 1) {
-        this.historyEntries.splice(this.currentIndex + 1);
-      }
-      this.historyEntries.push({
-        patches: [reversePatch],
-        inversePatches: [{ ...patch }],
-        timestamp: now
-      });
-      this.currentIndex++;
-      if (this.historyEntries.length > this.options.maxHistoryLength) {
-        const excess = this.historyEntries.length - this.options.maxHistoryLength;
-        this.historyEntries.splice(0, excess);
-        this.currentIndex -= excess;
+    store.set(this.historyAtom, (prev) => {
+      let entries = prev.currentIndex < prev.entries.length - 1 ? prev.entries.slice(0, prev.currentIndex + 1) : [...prev.entries];
+      if (this.groupByTime && entries.length > 0 && now - this.lastChangeTime < this.groupingWindow && prev.currentIndex === prev.entries.length - 1) {
+        const lastEntry = { ...entries[entries.length - 1] };
+        lastEntry.patches = [...lastEntry.patches, reversePatch];
+        lastEntry.inversePatches = [...lastEntry.inversePatches, { ...patch }];
+        lastEntry.timestamp = now;
+        lastEntry.snapshot = getSnapshot(this.target);
+        entries[entries.length - 1] = lastEntry;
+        this.lastChangeTime = now;
+        return {
+          ...prev,
+          entries
+        };
+      } else {
+        const newEntry = {
+          patches: [reversePatch],
+          inversePatches: [{ ...patch }],
+          timestamp: now,
+          snapshot: getSnapshot(this.target)
+        };
+        entries.push(newEntry);
+        let newIndex = entries.length - 1;
+        if (entries.length > this.maxHistoryLength) {
+          const excess = entries.length - this.maxHistoryLength;
+          entries = entries.slice(excess);
+          newIndex -= excess;
+        }
+        this.lastChangeTime = now;
+        return {
+          ...prev,
+          entries,
+          currentIndex: newIndex
+        };
       }
-    }
-    this.lastChangeTime = now;
+    });
   }
   undo() {
-    if (!this.canUndo) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (state.currentIndex < 0) {
       return;
     }
     const node = getStateTreeNode(this.target);
     const rootNode = node.getRoot();
     const wasApplying = rootNode.$isApplyingHistory;
     rootNode.$isApplyingHistory = true;
-    this.isUndoing = true;
+    this.isApplyingHistory = true;
     try {
-      const entry = this.historyEntries[this.currentIndex];
+      const entry = state.entries[state.currentIndex];
       for (let i = entry.patches.length - 1; i >= 0; i--) {
         applyPatch(this.target, entry.patches[i]);
       }
-      this.currentIndex--;
-      const tt = timeTravelManagersRegistry.get(this.target);
-      if (tt) {
-        const N = tt.snapshots.length;
-        const M = this.historyEntries.length;
-        const ttIndex = this.currentIndex + 1 + (N - 1 - M);
-        tt.index = Math.max(0, Math.min(N - 1, ttIndex));
-      }
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: prev.currentIndex - 1
+      }));
     } finally {
-      this.isUndoing = false;
+      this.isApplyingHistory = false;
       rootNode.$isApplyingHistory = wasApplying;
     }
   }
   redo() {
-    if (!this.canRedo) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (state.currentIndex >= state.entries.length - 1) {
       return;
     }
     const node = getStateTreeNode(this.target);
     const rootNode = node.getRoot();
     const wasApplying = rootNode.$isApplyingHistory;
     rootNode.$isApplyingHistory = true;
-    this.isRedoing = true;
+    this.isApplyingHistory = true;
     try {
-      this.currentIndex++;
-      const entry = this.historyEntries[this.currentIndex];
+      const nextIndex = state.currentIndex + 1;
+      const entry = state.entries[nextIndex];
       for (const patch of entry.inversePatches) {
         applyPatch(this.target, patch);
       }
-      const tt = timeTravelManagersRegistry.get(this.target);
-      if (tt) {
-        const N = tt.snapshots.length;
-        const M = this.historyEntries.length;
-        const ttIndex = this.currentIndex + 1 + (N - 1 - M);
-        tt.index = Math.max(0, Math.min(N - 1, ttIndex));
-      }
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: nextIndex
+      }));
     } finally {
-      this.isRedoing = false;
+      this.isApplyingHistory = false;
       rootNode.$isApplyingHistory = wasApplying;
     }
   }
+  goTo(index) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const maxIdx = state.entries.length;
+    if (index < 0 || index > maxIdx) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isApplyingHistory = true;
+    try {
+      const targetSnapshot = index === 0 ? state.initialSnapshot : state.entries[index - 1].snapshot;
+      applySnapshot(this.target, targetSnapshot);
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: index - 1
+      }));
+    } finally {
+      this.isApplyingHistory = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  goBack() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const currentSnapshotIndex = state.currentIndex + 1;
+    if (currentSnapshotIndex > 0) {
+      this.goTo(currentSnapshotIndex - 1);
+    }
+  }
+  goForward() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const currentSnapshotIndex = state.currentIndex + 1;
+    if (currentSnapshotIndex < state.entries.length) {
+      this.goTo(currentSnapshotIndex + 1);
+    }
+  }
+  record() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    let entries = state.currentIndex < state.entries.length - 1 ? state.entries.slice(0, state.currentIndex + 1) : [...state.entries];
+    const newEntry = {
+      patches: [],
+      inversePatches: [],
+      timestamp: Date.now(),
+      snapshot: getSnapshot(this.target)
+    };
+    entries.push(newEntry);
+    let newIndex = entries.length - 1;
+    if (entries.length > this.maxHistoryLength) {
+      const excess = entries.length - this.maxHistoryLength;
+      entries = entries.slice(excess);
+      newIndex -= excess;
+    }
+    store.set(this.historyAtom, {
+      ...state,
+      entries,
+      currentIndex: newIndex
+    });
+  }
+  getSnapshot(index) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (index < 0 || index > state.entries.length) {
+      throw new Error(`[jotai-state-tree] Invalid snapshot index: ${index}`);
+    }
+    return index === 0 ? state.initialSnapshot : state.entries[index - 1].snapshot;
+  }
   clear() {
-    this.historyEntries = [];
-    this.currentIndex = -1;
+    const store = getGlobalStore();
+    store.set(this.historyAtom, {
+      entries: [],
+      currentIndex: -1,
+      initialSnapshot: getSnapshot(this.target)
+    });
     this.currentGroup = [];
     this.currentGroupInverse = [];
     this.grouping = false;
@@ -1129,20 +1247,28 @@ var UndoManager = class {
     this.grouping = false;
     this.actionGrouping = false;
     if (this.currentGroup.length > 0) {
-      if (this.currentIndex < this.historyEntries.length - 1) {
-        this.historyEntries.splice(this.currentIndex + 1);
-      }
-      this.historyEntries.push({
-        patches: this.currentGroup,
-        inversePatches: this.currentGroupInverse,
-        timestamp: Date.now()
+      const store = getGlobalStore();
+      store.set(this.historyAtom, (prev) => {
+        let entries = prev.currentIndex < prev.entries.length - 1 ? prev.entries.slice(0, prev.currentIndex + 1) : [...prev.entries];
+        const newEntry = {
+          patches: [...this.currentGroup],
+          inversePatches: [...this.currentGroupInverse],
+          timestamp: Date.now(),
+          snapshot: getSnapshot(this.target)
+        };
+        entries.push(newEntry);
+        let newIndex = entries.length - 1;
+        if (entries.length > this.maxHistoryLength) {
+          const excess = entries.length - this.maxHistoryLength;
+          entries = entries.slice(excess);
+          newIndex -= excess;
+        }
+        return {
+          ...prev,
+          entries,
+          currentIndex: newIndex
+        };
       });
-      this.currentIndex++;
-      if (this.historyEntries.length > this.options.maxHistoryLength) {
-        const excess = this.historyEntries.length - this.options.maxHistoryLength;
-        this.historyEntries.splice(0, excess);
-        this.currentIndex -= excess;
-      }
     }
     this.currentGroup = [];
     this.currentGroupInverse = [];
@@ -1156,7 +1282,7 @@ var UndoManager = class {
     }
   }
   dispose() {
-    undoManagersRegistry.delete(this.target);
+    historyTrackersRegistry.delete(this.target);
     if (this.disposer) {
       this.disposer();
       this.disposer = null;
@@ -1165,143 +1291,113 @@ var UndoManager = class {
       this.actionDisposer();
       this.actionDisposer = null;
     }
-    this.clear();
   }
 };
-function createUndoManager(target, options) {
-  return new UndoManager(target, options);
-}
-var TimeTravelManager = class {
-  constructor(target, options = {}) {
-    this.snapshots = [];
-    this.index = -1;
-    this.isApplying = false;
-    this.disposer = null;
-    this.actionDisposer = null;
-    this.pendingRecord = false;
-    this.actionGrouping = false;
-    this.target = target;
-    this.maxSnapshots = options.maxSnapshots ?? 50;
-    this.autoRecord = options.autoRecord ?? false;
-    timeTravelManagersRegistry.set(target, this);
-    this.record();
-    if (this.autoRecord) {
-      this.disposer = onPatch(target, () => {
-        if (this.isApplying) return;
-        const node = getStateTreeNode(this.target);
-        if (node.getRoot().$isApplyingHistory) {
-          return;
-        }
-        if (isActionRunning()) {
-          this.pendingRecord = true;
-          if (!this.actionGrouping) {
-            this.actionGrouping = true;
-            Promise.resolve().then(() => {
-              if (this.actionGrouping) {
-                this.commitPendingRecord();
-              }
-            });
-          }
-        } else {
-          this.record();
-        }
-      });
-      this.actionDisposer = onAction(target, () => {
-        const current = getCurrentAction();
-        if (current && !current.parent) {
-          if (this.actionGrouping) {
-            this.commitPendingRecord();
-          }
-        }
-      });
-    }
-  }
-  commitPendingRecord() {
-    this.actionGrouping = false;
-    if (this.pendingRecord) {
-      this.pendingRecord = false;
-      this.record();
-    }
-  }
-  get currentIndex() {
-    return this.index;
-  }
-  get snapshotCount() {
-    return this.snapshots.length;
-  }
-  get canGoBack() {
-    return this.index > 0;
-  }
-  get canGoForward() {
-    return this.index < this.snapshots.length - 1;
-  }
-  record() {
-    if (this.index < this.snapshots.length - 1) {
-      this.snapshots.splice(this.index + 1);
-    }
-    this.snapshots.push(getSnapshot(this.target));
-    this.index++;
-    if (this.snapshots.length > this.maxSnapshots) {
-      const excess = this.snapshots.length - this.maxSnapshots;
-      this.snapshots.splice(0, excess);
-      this.index -= excess;
-    }
-  }
-  goBack() {
-    if (!this.canGoBack) return;
-    this.goTo(this.index - 1);
+function getOrCreateHistoryTracker(target, options = {}) {
+  let tracker = historyTrackersRegistry.get(target);
+  if (!tracker) {
+    tracker = new HistoryTracker(target, options);
+    historyTrackersRegistry.set(target, tracker);
   }
-  goForward() {
-    if (!this.canGoForward) return;
-    this.goTo(this.index + 1);
-  }
-  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]);
-      const undo = undoManagersRegistry.get(this.target);
-      if (undo) {
-        const N = this.snapshots.length;
-        const M = undo.historyEntries.length;
-        const undoIndex = this.index - 1 - (N - 1 - M);
-        undo.currentIndex = Math.max(-1, Math.min(M - 1, undoIndex));
-      }
-    } finally {
-      this.isApplying = false;
-      rootNode.$isApplyingHistory = wasApplying;
-    }
-  }
-  getSnapshot(index) {
-    if (index < 0 || index >= this.snapshots.length) {
-      throw new Error(`[jotai-state-tree] Invalid snapshot index: ${index}`);
+  return tracker;
+}
+function createUndoManager(target, options) {
+  const tracker = getOrCreateHistoryTracker(target, options);
+  tracker.autoRecord = true;
+  const store = getGlobalStore();
+  return {
+    get canUndo() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex >= 0;
+    },
+    get canRedo() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex < state.entries.length - 1;
+    },
+    get undoLevels() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1;
+    },
+    get redoLevels() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries.length - state.currentIndex - 1;
+    },
+    get history() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries;
+    },
+    get historyIndex() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex;
+    },
+    undo() {
+      tracker.undo();
+    },
+    redo() {
+      tracker.redo();
+    },
+    clear() {
+      tracker.clear();
+    },
+    startGroup() {
+      tracker.startGroup();
+    },
+    endGroup() {
+      tracker.endGroup();
+    },
+    withoutUndo(fn) {
+      return tracker.withoutUndo(fn);
+    },
+    dispose() {
+      tracker.dispose();
     }
-    return this.snapshots[index];
-  }
-  clear() {
-    this.snapshots = [];
-    this.index = -1;
-    this.record();
+  };
+}
+function createTimeTravelManager(target, options) {
+  const tracker = getOrCreateHistoryTracker(target, options);
+  if (options?.autoRecord) {
+    tracker.autoRecord = true;
   }
-  dispose() {
-    timeTravelManagersRegistry.delete(this.target);
-    if (this.disposer) {
-      this.disposer();
-      this.disposer = null;
-    }
-    if (this.actionDisposer) {
-      this.actionDisposer();
-      this.actionDisposer = null;
+  const store = getGlobalStore();
+  return {
+    get currentIndex() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1;
+    },
+    get snapshotCount() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries.length + 1;
+    },
+    get canGoBack() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1 > 0;
+    },
+    get canGoForward() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1 < state.entries.length + 1 - 1;
+    },
+    record() {
+      tracker.record();
+    },
+    goBack() {
+      tracker.goBack();
+    },
+    goForward() {
+      tracker.goForward();
+    },
+    goTo(index) {
+      tracker.goTo(index);
+    },
+    getSnapshot(index) {
+      return tracker.getSnapshot(index);
+    },
+    clear() {
+      tracker.clear();
+    },
+    dispose() {
+      tracker.dispose();
     }
-  }
-};
-function createTimeTravelManager(target, options) {
-  return new TimeTravelManager(target, options);
+  };
 }
 var ActionRecorder = class {
   constructor(target) {
@@ -1443,6 +1539,7 @@ export {
   freeze,
   isFrozen,
   unfreeze,
+  getOrCreateHistoryTracker,
   createUndoManager,
   createTimeTravelManager,
   createActionRecorder

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-DL1pyOkT.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-DL1pyOkT.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';