r-state-tree 0.7.0 → 0.8.1

package/dist/r-state-tree.js

@@ -84,7 +84,15 @@ function makeChildDecorator(typeObj) {
   };
 }
 const child = makeChildDecorator(childType);
-const modelRef = makeChildDecorator(modelRefType);
+const modelRefDecorator = makeChildDecorator(modelRefType);
+function modelRef(childCtor, context) {
+  if (context !== void 0) {
+    throw new Error(
+      "r-state-tree: @modelRef requires a model constructor, for example `@modelRef(User)`"
+    );
+  }
+  return modelRefDecorator(childCtor);
+}
 const model = makeDecorator(modelType);
 const id = makeDecorator(idType);
 const state = makeDecorator(stateType);
@@ -102,7 +110,11 @@ function normalizeEntry(entry) {
     if (entry === state) return stateType;
     if (entry === model) return modelType;
     if (entry === child) return childType;
-    if (entry === modelRef) return modelRefType;
+    if (entry === modelRef) {
+      throw new Error(
+        "r-state-tree: modelRef requires a model constructor, for example `modelRef(User)`"
+      );
+    }
     return void 0;
   }
   return void 0;
@@ -668,9 +680,10 @@ function reaction(fn, callback) {
     if (Object.is(currentValue, nextValue)) {
       return;
     }
+    const previousValue = currentValue;
     currentValue = nextValue;
     untracked(() => {
-      callback(nextValue);
+      callback(nextValue, previousValue);
     });
   });
 }
@@ -1925,7 +1938,7 @@ function createCircularMountError(frame) {
   const chain = formatMountChain(frame);
   const models = frame.modelsKeys.length === 0 ? "no models provided" : `models: ${frame.modelsKeys.join(", ")}`;
   return new Error(
-    `r-state-tree: detected circular store/model creation while mounting ${chain} (using ${models}). Passing models into child stores during mount can create recursive wiring. Move child store/model creation into storeDidMount or break the cycle.`
+    `r-state-tree: detected circular store/model creation while mounting ${chain} (using ${models}). Passing models into child stores during mount can create recursive wiring. Break the ownership cycle.`
   );
 }
 function updateProps(props, newProps) {
@@ -1984,8 +1997,8 @@ class StoreAdministration extends PreactObjectAdministration {
     PreactObjectAdministration.proxyTraps,
     {
       get(target, name) {
-        if (name === "key") {
-          return target.key;
+        if (name === "key" || name === Symbol.dispose) {
+          return Reflect.get(target, name);
         }
         const adm = getAdministration(target);
         switch (getConfigType(adm.configuration[name])) {
@@ -2018,10 +2031,11 @@ class StoreAdministration extends PreactObjectAdministration {
     }
   );
   parent = null;
-  mounted = false;
+  mountedSignal = createSignal(false);
+  disposed = false;
   contextCache = /* @__PURE__ */ new Map();
   childStoreDataMap = /* @__PURE__ */ new Map();
-  reactionsUnsub = [];
+  reactiveRegistrations = /* @__PURE__ */ new Set();
   configurationGetter;
   setConfiguration(configurationGetter) {
     this.configurationGetter = configurationGetter;
@@ -2045,7 +2059,9 @@ class StoreAdministration extends PreactObjectAdministration {
         }
       });
       childStoreData.value.set(stores);
-      stores.forEach((s) => getStoreAdm(s).mount(this, name));
+      if (this.isMounted) {
+        stores.forEach((s) => getStoreAdm(s).mount(this, name));
+      }
       return stores;
     }
     const newStores = /* @__PURE__ */ new Set();
@@ -2095,8 +2111,10 @@ class StoreAdministration extends PreactObjectAdministration {
     if (newStores.size || removedStores.size || keyedIndexChanged) {
       batch(() => childStoreData.value.set(stores));
     }
-    removedStores.forEach((s) => getStoreAdm(s).unmount());
-    newStores.forEach((s) => getStoreAdm(s).mount(this, name));
+    removedStores.forEach((s) => getStoreAdm(s).dispose(true));
+    if (this.isMounted) {
+      newStores.forEach((s) => getStoreAdm(s).mount(this, name));
+    }
     return stores;
   }
   setSingleStore(name, element) {
@@ -2106,16 +2124,18 @@ class StoreAdministration extends PreactObjectAdministration {
     );
     const { key, Type, props } = element || {};
     if (!element) {
-      oldStore && getStoreAdm(oldStore).unmount();
+      oldStore && getStoreAdm(oldStore).dispose(true);
       batch(() => childStoreData.value.set(null));
       return null;
     } else if (!oldStore || oldStore.props.key !== key || !(oldStore instanceof Type)) {
       if (oldStore) {
-        getStoreAdm(oldStore).unmount();
+        getStoreAdm(oldStore).dispose(true);
       }
       const childStore = this.createChildStore(element);
       batch(() => childStoreData.value.set(childStore));
-      getStoreAdm(childStore).mount(this, name);
+      if (this.isMounted) {
+        getStoreAdm(childStore).mount(this, name);
+      }
       return childStore;
     } else {
       batch(() => updateProps(oldStore.props, props));
@@ -2155,7 +2175,8 @@ class StoreAdministration extends PreactObjectAdministration {
   getStore(name) {
     const childStoreData = this.childStoreDataMap.get(name);
     if (!childStoreData) {
-      return this.initializeStore(name);
+      untracked(() => this.initializeStore(name));
+      return this.childStoreDataMap.get(name).value.get();
     } else {
       const storeElement = untracked(() => childStoreData.computed.get());
       validateStoreChildValue(storeElement, name);
@@ -2171,6 +2192,9 @@ class StoreAdministration extends PreactObjectAdministration {
   isRoot() {
     return !this.parent;
   }
+  get isMounted() {
+    return this.mountedSignal.get();
+  }
   getContextValue(contextId, provideSymbol, defaultValue, hasDefault) {
     let computed2 = this.contextCache.get(contextId);
     if (!computed2) {
@@ -2204,12 +2228,43 @@ class StoreAdministration extends PreactObjectAdministration {
     }
     return void 0;
   }
+  register(start) {
+    if (this.disposed) {
+      throw new Error(
+        "r-state-tree: cannot register reactive resources on a disposed store"
+      );
+    }
+    const registration = { start, disposed: false };
+    this.reactiveRegistrations.add(registration);
+    if (this.isMounted) registration.stop = registration.start();
+    return () => {
+      if (registration.disposed) return;
+      registration.disposed = true;
+      this.reactiveRegistrations.delete(registration);
+      registration.stop?.();
+      registration.stop = void 0;
+    };
+  }
+  startReactiveRegistrations() {
+    this.reactiveRegistrations.forEach((registration) => {
+      if (!registration.disposed && !registration.stop) {
+        registration.stop = registration.start();
+      }
+    });
+  }
   reaction(track, callback) {
-    const unsub = reaction(track, callback);
-    this.reactionsUnsub.push(unsub);
-    return unsub;
+    return this.register(() => reaction(track, callback));
+  }
+  effect(callback) {
+    return this.register(() => effect(callback));
   }
-  mount(parent = null, childName) {
+  mount(parent = null, childName, activationQueue) {
+    if (this.disposed) {
+      throw new Error("r-state-tree: cannot mount a disposed store");
+    }
+    if (this.isMounted) {
+      throw new Error("r-state-tree: store is already mounted");
+    }
     const frame = {
       storeName: this.proxy.constructor.name || "Store",
       childName,
@@ -2219,20 +2274,31 @@ class StoreAdministration extends PreactObjectAdministration {
       throw createCircularMountError(frame);
     }
     mountingStack.push(frame);
+    const isOutermostMount = activationQueue === void 0;
+    const registrationsToStart = activationQueue ?? [];
     try {
-      this.parent = parent || null;
-      this.childStoreDataMap.forEach(({ value }, name) => {
-        const stores = value.get();
-        if (Array.isArray(stores)) {
-          stores?.forEach((s) => getStoreAdm(s)?.mount(this, name));
-        } else if (stores) {
-          getStoreAdm(stores)?.mount(this, name);
-        }
+      batch(() => {
+        this.parent = parent || null;
+        this.childStoreDataMap.forEach(({ value }, name) => {
+          const stores = value.get();
+          if (Array.isArray(stores)) {
+            stores?.forEach(
+              (s) => getStoreAdm(s)?.mount(this, name, registrationsToStart)
+            );
+          } else if (stores) {
+            getStoreAdm(stores)?.mount(this, name, registrationsToStart);
+          }
+        });
+        this.mountedSignal.set(true);
+        registrationsToStart.push(this);
       });
-      this.mounted = true;
-      batch(() => this.proxy.storeDidMount?.());
+      if (isOutermostMount) {
+        registrationsToStart.forEach(
+          (store) => store.startReactiveRegistrations()
+        );
+      }
     } catch (error) {
-      if (error instanceof RangeError && /call stack/i.test(error.message)) {
+      if (error instanceof Error && (error instanceof RangeError && /call stack/i.test(error.message) || /cycle detected/i.test(error.message))) {
         throw createCircularMountError(frame);
       }
       throw error;
@@ -2240,25 +2306,36 @@ class StoreAdministration extends PreactObjectAdministration {
       mountingStack.pop();
     }
   }
-  unmount() {
-    this.proxy.storeWillUnmount?.();
-    this.mounted = false;
-    this.childStoreDataMap.forEach((data) => {
-      const { value, computed: computed2, listener } = data;
-      const stores = value.get();
-      if (Array.isArray(stores)) {
-        stores?.forEach((s) => getStoreAdm(s)?.unmount());
-      } else if (stores) {
-        getStoreAdm(stores)?.unmount();
-      }
-      computed2.clear();
-      listener.dispose();
+  dispose(internal = false) {
+    if (this.disposed) return;
+    if (!internal && !this.isRoot()) {
+      throw new Error("r-state-tree: can only dispose root stores");
+    }
+    batch(() => {
+      this.childStoreDataMap.forEach((data) => {
+        const { value, computed: computed2, listener } = data;
+        const stores = value.get();
+        if (Array.isArray(stores)) {
+          stores?.forEach((s) => getStoreAdm(s)?.dispose(true));
+        } else if (stores) {
+          getStoreAdm(stores)?.dispose(true);
+        }
+        computed2.clear();
+        listener.dispose();
+      });
+      this.childStoreDataMap.clear();
+      this.contextCache.forEach((computed2) => computed2.clear());
+      this.contextCache.clear();
+      this.parent = null;
     });
-    this.childStoreDataMap.clear();
-    this.contextCache.forEach((computed2) => computed2.clear());
-    this.contextCache.clear();
-    this.reactionsUnsub.forEach((u) => u());
-    this.parent = null;
+    this.disposed = true;
+    this.reactiveRegistrations.forEach((registration) => {
+      registration.disposed = true;
+      registration.stop?.();
+      registration.stop = void 0;
+    });
+    this.reactiveRegistrations.clear();
+    this.mountedSignal.set(false);
   }
 }
 let initEnabled$1 = false;
@@ -2304,141 +2381,109 @@ class Store {
   get key() {
     return this.props.key;
   }
+  get isMounted() {
+    return getStoreAdm(this).isMounted;
+  }
   reaction(track, callback) {
     return getStoreAdm(this).reaction(track, callback);
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  storeDidMount() {
+  effect(callback) {
+    return getStoreAdm(this).effect(callback);
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  storeWillUnmount() {
+  [Symbol.dispose]() {
+    getStoreAdm(this).dispose();
   }
 }
 const attachedIdMap = /* @__PURE__ */ new WeakMap();
 const idMap = /* @__PURE__ */ new WeakMap();
-let loadingSnapshot = false;
-const potentialDups = /* @__PURE__ */ new Set();
-function onSnapshotLoad(fn) {
-  const wasLoadingSnapshot = loadingSnapshot;
-  loadingSnapshot = true;
-  try {
-    return fn();
-  } finally {
-    if (!wasLoadingSnapshot) {
-      loadingSnapshot = false;
-      const rootMap = /* @__PURE__ */ new Map();
-      try {
-        potentialDups.forEach((model2) => {
-          const root = getModelAdm(model2).root.proxy;
-          let set = rootMap.get(root);
-          if (!set) {
-            set = /* @__PURE__ */ new Set();
-            rootMap.set(root, set);
-          }
-          if (idMap.has(model2)) {
-            const id2 = idMap.get(model2);
-            if (set.has(id2)) {
-              throw new Error(
-                "r-state-tree duplicate ids detected after snapshot was loaded"
-              );
-            }
-            set.add(id2);
-          }
-        });
-      } finally {
-        potentialDups.clear();
-      }
+function getModelType(model2) {
+  return Object.getPrototypeOf(model2).constructor;
+}
+function entriesFor(model2) {
+  const entries = [];
+  attachedIdMap.get(model2)?.forEach((ids, Type) => {
+    ids.forEach((value, id22) => {
+      if (value) entries.push([Type, id22, value]);
+    });
+  });
+  const id2 = idMap.get(model2);
+  if (id2 != null) entries.push([getModelType(model2), id2, model2]);
+  return entries;
+}
+function assertAvailable(node, entries) {
+  const map = attachedIdMap.get(node);
+  for (const [Type, id2, model2] of entries) {
+    const existing = map?.get(Type)?.get(id2);
+    if (existing && existing !== model2) {
+      throw new Error(
+        `r-state-tree: id: ${id2} is already assigned to another model`
+      );
     }
   }
 }
+function bucket(node, Type) {
+  let map = attachedIdMap.get(node);
+  if (!map) {
+    map = observable(/* @__PURE__ */ new Map());
+    attachedIdMap.set(node, map);
+  }
+  let ids = map.get(Type);
+  if (!ids) {
+    ids = observable(/* @__PURE__ */ new Map());
+    map.set(Type, ids);
+  }
+  return ids;
+}
 function setIdentifier(model2, id2) {
-  const prevId = idMap.get(model2);
-  idMap.set(model2, id2);
-  if (prevId == null) {
-    if (model2.parent) {
-      onModelAttached(model2);
-    }
-  } else if (prevId !== id2) {
-    updateIdentifier(model2);
+  const previousId = idMap.get(model2);
+  if (previousId === id2) return;
+  const Type = getModelType(model2);
+  const ancestors = [];
+  let node = model2.parent;
+  while (node) {
+    assertAvailable(node, [[Type, id2, model2]]);
+    ancestors.push(node);
+    node = node.parent;
   }
+  for (const ancestor of ancestors) {
+    const ids = bucket(ancestor, Type);
+    if (previousId != null && ids.get(previousId) === model2)
+      ids.delete(previousId);
+    ids.set(id2, model2);
+  }
+  idMap.set(model2, id2);
 }
 function getIdentifier(model2) {
   return idMap.get(model2);
 }
-function getModelById(root, id2) {
-  const map = attachedIdMap.get(root);
-  return map?.get(id2);
+function getModelById(root, Type, id2) {
+  return attachedIdMap.get(root)?.get(Type)?.get(id2);
 }
-function updateIdentifier(model2) {
-  const id2 = idMap.get(model2);
+function onModelAttached(model2) {
+  const entries = entriesFor(model2);
+  if (!entries.length) return;
+  const ancestors = [];
   let node = model2.parent;
   while (node) {
-    const map = attachedIdMap.get(node);
-    if (map) {
-      map.set(id2, model2);
-    }
+    assertAvailable(node, entries);
+    ancestors.push(node);
     node = node.parent;
   }
-}
-function onModelAttached(model2) {
-  const attachedMap = attachedIdMap.get(model2);
-  const id2 = idMap.get(model2);
-  if (attachedMap || id2 != null) {
-    const id22 = idMap.get(model2);
-    let node = model2.parent;
-    while (node) {
-      let map = attachedIdMap.get(node);
-      if (!map) {
-        map = observable(/* @__PURE__ */ new Map());
-        attachedIdMap.set(node, map);
-      }
-      attachedMap?.forEach((value, key) => {
-        if (map.has(key)) {
-          if (loadingSnapshot) {
-            potentialDups.add(model2);
-            potentialDups.add(map.get(key));
-          } else {
-            throw new Error(
-              `r-state-tree: id: ${key} is already assigned to another model`
-            );
-          }
-        }
-        map.set(key, value);
-      });
-      if (id22 != null) {
-        if (map.has(id22)) {
-          if (loadingSnapshot) {
-            potentialDups.add(model2);
-            potentialDups.add(map.get(id22));
-          } else {
-            throw new Error(
-              `r-state-tree: id: ${id22} is already assigned to another model`
-            );
-          }
-        }
-        map.set(id22, model2);
-      }
-      node = node.parent;
-    }
+  for (const ancestor of ancestors) {
+    for (const [Type, id2, value] of entries)
+      bucket(ancestor, Type).set(id2, value);
   }
 }
 function onModelDetached(model2) {
-  const id2 = idMap.get(model2);
-  if (attachedIdMap.has(model2) || id2 != null) {
-    const attachedMap = attachedIdMap.get(model2);
-    let node = model2.parent;
-    while (node) {
-      const map = attachedIdMap.get(node);
-      if (map) {
-        attachedMap?.forEach((value, key) => {
-          map.delete(key);
-        });
-        if (id2 != null) {
-          map.delete(id2);
-        }
-      }
-      node = node.parent;
+  const entries = entriesFor(model2);
+  let node = model2.parent;
+  while (node) {
+    const map = attachedIdMap.get(node);
+    for (const [Type, id2, value] of entries) {
+      const ids = map?.get(Type);
+      if (ids?.get(id2) === value) ids.delete(id2);
     }
+    node = node.parent;
   }
 }
 const listenerMap = /* @__PURE__ */ new WeakMap();
@@ -2494,19 +2539,28 @@ class ObservableListener {
   notify(ev) {
     if (!this.listeners) return;
     this.notifying = true;
-    for (let i = 0; i < this.listeners.length; i++) {
-      this.listeners[i](ev);
+    try {
+      for (let i = 0; i < this.listeners.length; i++) {
+        this.listeners[i](ev);
+      }
+    } finally {
+      this.notifying = false;
     }
-    this.notifying = false;
   }
 }
 class ChildModelsAdministration extends ArrayAdministration {
   set(index, newValue) {
     return batch(() => {
+      const oldValue = this.source[index];
       const result = super.set(index, newValue);
       const sourceValue = getSource(newValue);
-      if (this.source[index] !== sourceValue) {
-        notifyArrayUpdate(this.proxy, index, this.source[index], sourceValue);
+      if (oldValue !== sourceValue) {
+        try {
+          notifyArrayUpdate(this.proxy, index, oldValue, sourceValue);
+        } catch (error) {
+          super.set(index, oldValue);
+          throw error;
+        }
       }
       return result;
     });
@@ -2515,7 +2569,12 @@ class ChildModelsAdministration extends ArrayAdministration {
     return batch(() => {
       const deleted = super.spliceWithArray(index, deleteCount, newItems);
       if (deleteCount || newItems?.length) {
-        notifySpliceArray(this.proxy, index, newItems ?? [], deleted);
+        try {
+          notifySpliceArray(this.proxy, index, newItems ?? [], deleted);
+        } catch (error) {
+          super.spliceWithArray(index, newItems?.length ?? 0, deleted);
+          throw error;
+        }
       }
       return deleted;
     });
@@ -2594,6 +2653,9 @@ class ModelAdministration extends PreactObjectAdministration {
     {
       get(target, prop, proxy) {
         const adm = getAdministration(target);
+        if (prop === Symbol.dispose) {
+          return Reflect.get(target, prop, proxy);
+        }
         if (prop === "parent") {
           return target.parent;
         }
@@ -2612,6 +2674,7 @@ class ModelAdministration extends PreactObjectAdministration {
       },
       set(target, name, value) {
         const adm = getAdministration(target);
+        adm.assertUsable();
         adm.writeInProgress.add(name);
         try {
           switch (adm.getCfgType(name)) {
@@ -2674,6 +2737,8 @@ class ModelAdministration extends PreactObjectAdministration {
   computedSnapshot;
   snapshotMap = /* @__PURE__ */ new Map();
   contextCache = /* @__PURE__ */ new Map();
+  ownedDisposers = /* @__PURE__ */ new Set();
+  disposed = false;
   parentName = null;
   get parent() {
     this.parentAtom.reportObserved();
@@ -2688,6 +2753,29 @@ class ModelAdministration extends PreactObjectAdministration {
   setConfiguration(configurationGetter) {
     this.configurationGetter = configurationGetter;
   }
+  assertUsable() {
+    if (this.disposed) {
+      throw new Error("r-state-tree: cannot use a disposed model");
+    }
+  }
+  own(disposer) {
+    this.assertUsable();
+    let active = true;
+    const wrapped = () => {
+      if (!active) return;
+      active = false;
+      this.ownedDisposers.delete(wrapped);
+      disposer();
+    };
+    this.ownedDisposers.add(wrapped);
+    return wrapped;
+  }
+  reaction(track, callback) {
+    return this.own(reaction(track, callback));
+  }
+  effect(callback) {
+    return this.own(effect(callback));
+  }
   get configuration() {
     return this.configurationGetter?.() ?? {};
   }
@@ -2757,8 +2845,8 @@ class ModelAdministration extends PreactObjectAdministration {
       );
     }
     if (v !== void 0) {
-      this.source[name] = v;
       setIdentifier(this.proxy, v);
+      this.source[name] = v;
     }
   }
   setModel(name, newModel) {
@@ -2813,11 +2901,30 @@ class ModelAdministration extends PreactObjectAdministration {
       name,
       observe(this.proxy[name], (event) => {
         if (event.type === "updateArray") {
-          getModelAdm(event.oldValue).detach();
-          getModelAdm(event.newValue).attach(this, name);
+          const oldAdm = getModelAdm(event.oldValue);
+          const newAdm = getModelAdm(event.newValue);
+          oldAdm.detach();
+          try {
+            newAdm.attach(this, name);
+          } catch (error) {
+            oldAdm.attach(this, name);
+            throw error;
+          }
         } else if (event.type === "spliceArray") {
+          const attached = [];
           event.removed.forEach((model2) => getModelAdm(model2).detach());
-          event.added.forEach((model2) => getModelAdm(model2).attach(this, name));
+          try {
+            event.added.forEach((model2) => {
+              getModelAdm(model2).attach(this, name);
+              attached.push(model2);
+            });
+          } catch (error) {
+            attached.forEach((model2) => getModelAdm(model2).detach());
+            event.removed.forEach(
+              (model2) => getModelAdm(model2).attach(this, name)
+            );
+            throw error;
+          }
         }
       })
     );
@@ -2832,7 +2939,9 @@ class ModelAdministration extends PreactObjectAdministration {
   getModelRef(name) {
     const a = this.getReferencedAtom(name);
     a.reportObserved();
-    return this.source[name] != null ? getModelById(this.root.proxy, this.source[name]) : void 0;
+    const Type = this.getRequiredModelRefType(name);
+    const root = this.getReactiveRoot().proxy;
+    return this.source[name] != null ? getModelById(root, Type, this.source[name]) : void 0;
   }
   getModelRefs(name) {
     const a = this.getReferencedAtom(name);
@@ -2841,7 +2950,9 @@ class ModelAdministration extends PreactObjectAdministration {
       if (!this.referencedModels) this.referencedModels = /* @__PURE__ */ new Map();
       c = createComputed(() => {
         a.reportObserved();
-        const models = (this.source[name] || []).map((id2) => getModelById(this.root.proxy, id2)).filter((m) => !!m);
+        const Type = this.getRequiredModelRefType(name);
+        const root = this.getReactiveRoot().proxy;
+        const models = (this.source[name] || []).map((id2) => getModelById(root, Type, id2)).filter((m) => !!m);
         return models;
       });
       this.referencedModels.set(name, c);
@@ -2851,6 +2962,7 @@ class ModelAdministration extends PreactObjectAdministration {
   setModelRef(name, modelValue) {
     let id2 = void 0;
     if (modelValue) {
+      this.assertModelRefType(name, modelValue);
       id2 = getIdentifier(modelValue);
       if (id2 == null) {
         throw new Error(
@@ -2863,6 +2975,7 @@ class ModelAdministration extends PreactObjectAdministration {
   }
   setModelRefs(name, modelValue) {
     const ids = modelValue.map((model2) => {
+      this.assertModelRefType(name, model2);
       const id2 = getIdentifier(model2);
       if (id2 == null) {
         throw new Error(
@@ -2874,31 +2987,87 @@ class ModelAdministration extends PreactObjectAdministration {
     this.source[name] = ids;
     this.referencedAtoms?.get(name)?.reportChanged();
   }
+  getRequiredModelRefType(name) {
+    const Type = this.getCfgChildType(name);
+    if (!Type) {
+      throw new Error(
+        `r-state-tree: modelRef '${String(name)}' requires a model constructor`
+      );
+    }
+    return Type;
+  }
+  assertModelRefType(name, model2) {
+    const Type = this.getRequiredModelRefType(name);
+    if (!(model2 instanceof Type)) {
+      throw new Error(
+        `r-state-tree: modelRef '${String(name)}' must reference ${Type.name}`
+      );
+    }
+  }
   attach(parent = null, parentName = null) {
+    this.assertUsable();
     if (this.parent) {
       throw new Error(
         "r-state-tree: child model already attached to a parent. Did you mean to use modelRef?"
       );
     }
-    if (parent) {
-      this.parent = parent;
-      this.root = parent.root;
-      this.parentName = parentName;
-    }
     batch(() => {
-      onModelAttached(this.proxy);
-      this.proxy.modelDidAttach();
+      if (parent) {
+        this.parent = parent;
+        this.root = parent.root;
+        this.parentName = parentName;
+      }
+      try {
+        onModelAttached(this.proxy);
+      } catch (error) {
+        this.parent = null;
+        this.root = this;
+        this.parentName = null;
+        throw error;
+      }
     });
   }
+  getReactiveRoot() {
+    const parent = this.parent;
+    return parent ? parent.getReactiveRoot() : this;
+  }
   detach() {
     batch(() => {
-      this.proxy.modelWillDetach();
       onModelDetached(this.proxy);
+      this.contextCache.forEach((computed2) => computed2.clear());
+      this.contextCache.clear();
+      this.parent = null;
+      this.parentName = null;
+      this.root = this;
     });
+  }
+  dispose(internal = false) {
+    if (this.disposed) return;
+    if (!internal && this.parent) {
+      throw new Error(
+        "r-state-tree: cannot directly dispose an attached child model"
+      );
+    }
+    batch(() => {
+      this.activeModels.forEach((name) => {
+        const child2 = this.proxy[name];
+        if (Array.isArray(child2)) {
+          child2.forEach((model2) => getModelAdm(model2).dispose(true));
+        } else if (child2) {
+          getModelAdm(child2).dispose(true);
+        }
+      });
+      if (this.parent) onModelDetached(this.proxy);
+      this.parent = null;
+      this.parentName = null;
+      this.root = this;
+    });
+    this.disposed = true;
+    this.modelsTraceUnsub.forEach((dispose) => dispose());
+    this.modelsTraceUnsub.clear();
     this.contextCache.forEach((computed2) => computed2.clear());
     this.contextCache.clear();
-    this.parent = null;
-    this.root = this;
+    Array.from(this.ownedDisposers).forEach((dispose) => dispose());
   }
   getContextValue(contextId, provideSymbol, defaultValue, hasDefault) {
     let computed2 = this.contextCache.get(contextId);
@@ -3001,85 +3170,94 @@ class ModelAdministration extends PreactObjectAdministration {
       }
       return true;
     };
-    onSnapshotLoad(() => {
-      untracked(() => {
-        batch(() => {
-          Object.keys(snapshot).forEach((key) => {
-            const type = this.getCfgType(key);
-            const childType2 = this.getCfgChildType(key);
-            const value = snapshot[key];
-            switch (type) {
-              case ModelCfgTypes.state:
-                this.proxy[key] = this.hydrateStateValue(this.proxy[key], value);
-                break;
-              case ModelCfgTypes.modelRef:
-                if (Array.isArray(value)) {
-                  if (value?.[0] instanceof Model) {
-                    this.proxy[key] = value;
-                  } else {
-                    this.source[key] = value.map(
-                      (snapshot2) => getSnapshotRefId(snapshot2)
-                    );
-                    this.referencedAtoms?.get(key)?.reportChanged();
-                  }
-                  break;
-                } else if (value instanceof Model) {
+    untracked(() => {
+      batch(() => {
+        Object.keys(snapshot).forEach((key) => {
+          const type = this.getCfgType(key);
+          const childType2 = this.getCfgChildType(key);
+          const value = snapshot[key];
+          switch (type) {
+            case ModelCfgTypes.state:
+              this.proxy[key] = this.hydrateStateValue(this.proxy[key], value);
+              break;
+            case ModelCfgTypes.modelRef:
+              if (Array.isArray(value)) {
+                if (value?.[0] instanceof Model) {
                   this.proxy[key] = value;
                 } else {
-                  this.source[key] = getSnapshotRefId(value);
+                  this.source[key] = value.map(
+                    (snapshot2) => getSnapshotRefId(snapshot2)
+                  );
                   this.referencedAtoms?.get(key)?.reportChanged();
                 }
                 break;
-              case ModelCfgTypes.id:
-                this.setId(key, value);
-                break;
-              case CommonCfgTypes.child:
-                let model2;
-                if (Array.isArray(value)) {
-                  const Ctor = childType2;
-                  this.proxy[key] = value?.map(
-                    (snapshot2, index) => {
-                      snapshot2 = snapshot2 ?? {};
-                      let model22;
-                      if (snapshot2 instanceof Model) {
-                        model22 = snapshot2;
+              } else if (value instanceof Model) {
+                this.proxy[key] = value;
+              } else {
+                this.source[key] = getSnapshotRefId(value);
+                this.referencedAtoms?.get(key)?.reportChanged();
+              }
+              break;
+            case ModelCfgTypes.id:
+              this.setId(key, value);
+              break;
+            case CommonCfgTypes.child:
+              let model2;
+              if (Array.isArray(value)) {
+                const Ctor = childType2;
+                const snapshotIds = /* @__PURE__ */ new Set();
+                for (const childSnapshot of value) {
+                  if (childSnapshot instanceof Model) continue;
+                  const snapshotId = childType2 ? getSnapshotId(childSnapshot ?? {}, Ctor) : null;
+                  if (snapshotId != null && snapshotIds.has(snapshotId)) {
+                    throw new Error(
+                      "r-state-tree duplicate ids detected after snapshot was loaded"
+                    );
+                  }
+                  if (snapshotId != null) snapshotIds.add(snapshotId);
+                }
+                this.proxy[key] = value?.map(
+                  (snapshot2, index) => {
+                    snapshot2 = snapshot2 ?? {};
+                    let model22;
+                    if (snapshot2 instanceof Model) {
+                      model22 = snapshot2;
+                    } else {
+                      ensureChildTypes(key);
+                      const id2 = childType2 && getSnapshotId(snapshot2, Ctor);
+                      const foundModel = id2 != null ? getModelById(this.root.proxy, Ctor, id2) : this.proxy[key][index];
+                      const adm = foundModel && getModelAdm(foundModel);
+                      if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
+                        adm.loadSnapshot(snapshot2);
+                        model22 = foundModel;
                       } else {
-                        ensureChildTypes(key);
-                        const id2 = childType2 && getSnapshotId(snapshot2, Ctor);
-                        const foundModel = id2 != null ? getModelById(this.root.proxy, id2) : this.proxy[key][index];
-                        const adm = foundModel && getModelAdm(foundModel);
-                        if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
-                          adm.loadSnapshot(snapshot2);
-                          model22 = foundModel;
-                        } else {
-                          model22 = Ctor.create(snapshot2);
-                        }
+                        model22 = Ctor.create(snapshot2);
                       }
-                      return model22;
                     }
-                  );
-                  break;
-                } else if (value instanceof Model) {
-                  model2 = value;
-                } else {
-                  ensureChildTypes(key);
-                  const id2 = childType2 && getSnapshotId(value, childType2);
-                  if (id2 != null && this.proxy[key] && id2 === getIdentifier(this.proxy[key])) {
-                    const adm = getModelAdm(this.proxy[key]);
-                    adm.loadSnapshot(value);
-                    model2 = this.proxy[key];
-                  } else {
-                    model2 = childType2.create(value);
+                    return model22;
                   }
-                }
-                this.proxy[key] = model2;
-                break;
-              default:
-                console.warn(
-                  `r-state-tree: invalid key '${key}' found in snapshot, ignored.`
                 );
-            }
-          });
+                break;
+              } else if (value instanceof Model) {
+                model2 = value;
+              } else {
+                ensureChildTypes(key);
+                const id2 = childType2 && getSnapshotId(value, childType2);
+                if (id2 != null && this.proxy[key] && this.proxy[key] instanceof childType2 && id2 === getIdentifier(this.proxy[key])) {
+                  const adm = getModelAdm(this.proxy[key]);
+                  adm.loadSnapshot(value);
+                  model2 = this.proxy[key];
+                } else {
+                  model2 = childType2.create(value);
+                }
+              }
+              this.proxy[key] = model2;
+              break;
+            default:
+              console.warn(
+                `r-state-tree: invalid key '${key}' found in snapshot, ignored.`
+              );
+          }
         });
       });
     });
@@ -3094,11 +3272,14 @@ class ModelAdministration extends PreactObjectAdministration {
     }
     return this.computedSnapshot.get();
   }
+  getSnapshotForRollback() {
+    return this.toJSON();
+  }
 }
 let initEnabled = false;
 class Model {
   static childTypes = {};
-  static create(snapshot, ...args) {
+  static create(snapshot) {
     let instance;
     try {
       initEnabled = true;
@@ -3107,8 +3288,12 @@ class Model {
       initEnabled = false;
     }
     const adm = getModelAdm(instance);
-    snapshot && adm.loadSnapshot(snapshot);
-    instance.modelDidInit(snapshot, ...args);
+    try {
+      snapshot && adm.loadSnapshot(snapshot);
+    } catch (error) {
+      adm.dispose(true);
+      throw error;
+    }
     return instance;
   }
   constructor() {
@@ -3132,31 +3317,33 @@ class Model {
   get parent() {
     return getModelAdm(this).parent?.proxy ?? null;
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  modelDidInit(snapshot, ...args) {
+  reaction(track, callback) {
+    return getModelAdm(this).reaction(track, callback);
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  modelDidAttach() {
+  effect(callback) {
+    return getModelAdm(this).effect(callback);
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  modelWillDetach() {
+  [Symbol.dispose]() {
+    getModelAdm(this).dispose();
   }
 }
+function findModelById(root, ModelType, id2) {
+  return getModelById(getModelAdm(root).root.proxy, ModelType, id2);
+}
 function mount(container) {
   return allowNewStore(() => {
     const element = container;
     const s = new element.Type(element.props);
-    getStoreAdm(s).mount();
+    const adm = getStoreAdm(s);
+    try {
+      adm.mount();
+    } catch (error) {
+      adm.dispose(true);
+      throw error;
+    }
     return s;
   });
 }
-function unmount(container) {
-  const internalStore = getStoreAdm(container);
-  if (!internalStore.isRoot()) {
-    throw new Error("r-state-tree: can only unmount root stores");
-  }
-  internalStore.unmount();
-}
 function toSnapshot(model2) {
   return getModelAdm(model2).getSnapshot();
 }
@@ -3176,7 +3363,13 @@ function onSnapshotDiff(model2, callback) {
 }
 function applySnapshot(model2, snapshot) {
   const adm = getModelAdm(model2);
-  adm.loadSnapshot(snapshot);
+  const previousSnapshot = adm.getSnapshotForRollback();
+  try {
+    adm.loadSnapshot(snapshot);
+  } catch (error) {
+    adm.loadSnapshot(previousSnapshot);
+    throw error;
+  }
   return model2;
 }
 const CONTEXT_SYMBOL = Symbol("context");
@@ -3283,6 +3476,7 @@ export {
   createContext,
   createStore,
   effect2 as effect,
+  findModelById,
   getSignal,
   id,
   isObservable,
@@ -3300,7 +3494,6 @@ export {
   state,
   toObservableTree,
   toSnapshot,
-  unmount,
   untracked2 as untracked,
   updateStore
 };