r-state-tree 0.6.3 → 0.8.0

package/dist/r-state-tree.js

@@ -58,6 +58,152 @@ const modelType = {
   type: "model"
   /* model */
 };
+const computedType = {
+  type: "computed"
+  /* computed */
+};
+function makeDecorator(type) {
+  return function(value, context) {
+    context.metadata[context.name] = type;
+    return value;
+  };
+}
+function makeChildDecorator(typeObj) {
+  return function(valueOrChildType, context) {
+    if (context !== void 0) {
+      return makeDecorator(typeObj)(valueOrChildType, context);
+    }
+    const childCtor = valueOrChildType;
+    const typeWithCtor = typeObj(childCtor);
+    const decorator = function(value, context2) {
+      return makeDecorator(typeWithCtor)(value, context2);
+    };
+    decorator.type = typeWithCtor?.type;
+    decorator.childType = childCtor;
+    return decorator;
+  };
+}
+const child = makeChildDecorator(childType);
+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);
+function hasConfigLike(value) {
+  if (!value) return false;
+  const t = typeof value;
+  if (t !== "object" && t !== "function") return false;
+  return "type" in value;
+}
+function normalizeEntry(entry) {
+  if (!entry) return void 0;
+  if (hasConfigLike(entry)) return entry;
+  if (typeof entry === "function") {
+    if (entry === id) return idType;
+    if (entry === state) return stateType;
+    if (entry === model) return modelType;
+    if (entry === child) return childType;
+    if (entry === modelRef) {
+      throw new Error(
+        "r-state-tree: modelRef requires a model constructor, for example `modelRef(User)`"
+      );
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function getConfigType(entry) {
+  const normalized = normalizeEntry(entry);
+  return normalized && hasConfigLike(normalized) ? normalized.type : void 0;
+}
+function getConfigChildType(entry) {
+  const normalized = normalizeEntry(entry);
+  if (!normalized || !hasConfigLike(normalized)) return void 0;
+  if (typeof normalized === "function") {
+    return normalized.childType;
+  }
+  return normalized.childType;
+}
+function getParentConstructor(Ctor) {
+  return Ctor?.prototype ? Object.getPrototypeOf(Ctor.prototype)?.constructor : void 0;
+}
+function getCtorChain(ctor) {
+  const chain = [];
+  let node = ctor;
+  while (node) {
+    chain.push(node);
+    const parent = getParentConstructor(node);
+    if (!parent || parent === Object || parent === Function) {
+      break;
+    }
+    node = parent;
+  }
+  chain.reverse();
+  return chain;
+}
+function getMetadataSymbol() {
+  const sym = Symbol.metadata;
+  return typeof sym === "symbol" ? sym : void 0;
+}
+function getOwnMetadata(ctor) {
+  const metadataSymbol = getMetadataSymbol();
+  if (!metadataSymbol) return void 0;
+  return Object.prototype.hasOwnProperty.call(ctor, metadataSymbol) ? ctor[metadataSymbol] : void 0;
+}
+function getOwnStaticTypes(ctor) {
+  return Object.prototype.hasOwnProperty.call(ctor, "types") ? ctor.types : void 0;
+}
+function mergeInto(target, source2) {
+  if (!source2 || typeof source2 !== "object") return;
+  for (const key of Reflect.ownKeys(source2)) {
+    const value = source2[key];
+    const normalized = normalizeEntry(value);
+    if (normalized) {
+      target[key] = normalized;
+    }
+  }
+}
+const configurationCache = /* @__PURE__ */ new WeakMap();
+function refsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].ctor !== b[i].ctor) return false;
+    if (a[i].typesRef !== b[i].typesRef) return false;
+    if (a[i].metaRef !== b[i].metaRef) return false;
+  }
+  return true;
+}
+function getConfigurationForCtor(ctor) {
+  if (!ctor) return {};
+  const chain = getCtorChain(ctor);
+  const refs = chain.map((c) => ({
+    ctor: c,
+    typesRef: getOwnStaticTypes(c),
+    metaRef: getOwnMetadata(c)
+  }));
+  const cached = configurationCache.get(ctor);
+  if (cached && refsEqual(cached.refs, refs)) {
+    return cached.merged;
+  }
+  const merged = {};
+  for (let i = 0; i < refs.length; i++) {
+    const { typesRef, metaRef } = refs[i];
+    mergeInto(merged, metaRef);
+    mergeInto(merged, typesRef);
+  }
+  configurationCache.set(ctor, { refs, merged });
+  return merged;
+}
+function getConfigurationValue(ctor, key) {
+  return getConfigurationForCtor(ctor)[key];
+}
 function isNonPrimitive(val) {
   return val != null && (typeof val === "object" || typeof val === "function");
 }
@@ -74,10 +220,12 @@ function getPropertyType(key, obj) {
   if (plain) {
     return "observable";
   }
-  const metadata = obj.constructor[Symbol.metadata];
-  const config = metadata?.[key];
+  const config = getConfigurationValue(
+    obj.constructor,
+    key
+  );
   if (config) {
-    switch (config.type) {
+    switch (getConfigType(config)) {
       case ObservableCfgTypes.computed:
         return "computed";
       case ModelCfgTypes.state:
@@ -532,9 +680,10 @@ function reaction(fn, callback) {
     if (Object.is(currentValue, nextValue)) {
       return;
     }
+    const previousValue = currentValue;
     currentValue = nextValue;
     untracked(() => {
-      callback(nextValue);
+      callback(nextValue, previousValue);
     });
   });
 }
@@ -616,11 +765,12 @@ function signal(value) {
 }
 function computed(value, context) {
   if (context && typeof context === "object" && "kind" in context) {
-    context.metadata[context.name] = { type: "computed" };
+    context.metadata[context.name] = computedType;
     return value;
   }
   return internalCreateComputed(value).c;
 }
+computed.type = computedType.type;
 function source(obj) {
   return getSource(obj);
 }
@@ -1470,9 +1620,22 @@ function createFilterMethod(method) {
     function(callback, thisArg) {
       const adm = getAdministration(this);
       adm.reportObserved();
-      return adm.source[method]((_element, index) => {
-        return callback.call(thisArg, this[index], index, this);
-      });
+      const observedInput = [];
+      observedInput.length = adm.source.length;
+      const keys = Object.keys(adm.source);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const idx = Number(key);
+        if (!Number.isNaN(idx)) {
+          observedInput[idx] = this[idx];
+        }
+      }
+      return Array.prototype[method].call(
+        observedInput,
+        (_element, index) => {
+          return callback.call(thisArg, this[index], index, this);
+        }
+      );
     }
   );
 }
@@ -1480,7 +1643,22 @@ function createReduceMethod(method) {
   return createMethod(method, function() {
     const adm = getAdministration(this);
     adm.reportObserved();
-    return adm.source[method].apply(adm.source, arguments);
+    const observedInput = [];
+    observedInput.length = adm.source.length;
+    const keys = Object.keys(adm.source);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const idx = Number(key);
+      if (!Number.isNaN(idx)) {
+        observedInput[idx] = this[idx];
+      }
+    }
+    const args = Array.from(arguments);
+    const callback = args[0];
+    args[0] = (acc, _element, index) => {
+      return callback(acc, this[index], index, this);
+    };
+    return Array.prototype[method].apply(observedInput, args);
   });
 }
 class DateAdministration extends Administration {
@@ -1714,7 +1892,7 @@ function getDiff(o1, o2, getConfig) {
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     if (obj1[key] !== obj2[key]) {
-      if (config?.[key]?.type === CommonCfgTypes.child) {
+      if (getConfigType(config?.[key]) === CommonCfgTypes.child) {
         const value = obj2[key];
         if (Array.isArray(value)) {
           diff[key] = value.map((model2, index) => {
@@ -1760,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) {
@@ -1819,11 +1997,11 @@ 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 (adm.configuration[name]?.type) {
+        switch (getConfigType(adm.configuration[name])) {
           case CommonCfgTypes.child:
             return adm.getStore(name);
           case StoreCfgTypes.model:
@@ -1840,7 +2018,7 @@ class StoreAdministration extends PreactObjectAdministration {
         if (name === "props") {
           throw new Error(`r-state-tree: ${name} is read-only`);
         }
-        if (adm.configuration[name]?.type === StoreCfgTypes.model) {
+        if (getConfigType(adm.configuration[name]) === StoreCfgTypes.model) {
           if (value !== void 0) {
             throw new Error(`r-state-tree: model ${String(name)} is read-only`);
           }
@@ -1853,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 = [];
+  ownedDisposers = /* @__PURE__ */ new Set();
   configurationGetter;
   setConfiguration(configurationGetter) {
     this.configurationGetter = configurationGetter;
@@ -1930,7 +2109,7 @@ class StoreAdministration extends PreactObjectAdministration {
     if (newStores.size || removedStores.size || keyedIndexChanged) {
       batch(() => childStoreData.value.set(stores));
     }
-    removedStores.forEach((s) => getStoreAdm(s).unmount());
+    removedStores.forEach((s) => getStoreAdm(s).dispose(true));
     newStores.forEach((s) => getStoreAdm(s).mount(this, name));
     return stores;
   }
@@ -1941,12 +2120,12 @@ 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));
@@ -1990,7 +2169,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);
@@ -2006,6 +2186,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) {
@@ -2039,12 +2222,37 @@ class StoreAdministration extends PreactObjectAdministration {
     }
     return void 0;
   }
+  own(disposer) {
+    if (this.disposed) {
+      disposer();
+      throw new Error(
+        "r-state-tree: cannot register reactive resources on a disposed store"
+      );
+    }
+    let active = true;
+    const wrapped = () => {
+      if (!active) return;
+      active = false;
+      this.ownedDisposers.delete(wrapped);
+      disposer();
+    };
+    this.ownedDisposers.add(wrapped);
+    return wrapped;
+  }
   reaction(track, callback) {
     const unsub = reaction(track, callback);
-    this.reactionsUnsub.push(unsub);
-    return unsub;
+    return this.own(unsub);
+  }
+  effect(callback) {
+    return this.own(effect(callback));
   }
   mount(parent = null, childName) {
+    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,
@@ -2055,19 +2263,20 @@ class StoreAdministration extends PreactObjectAdministration {
     }
     mountingStack.push(frame);
     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));
+          } else if (stores) {
+            getStoreAdm(stores)?.mount(this, name);
+          }
+        });
+        this.mountedSignal.set(true);
       });
-      this.mounted = true;
-      batch(() => this.proxy.storeDidMount?.());
     } 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;
@@ -2075,25 +2284,31 @@ 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.mountedSignal.set(false);
+    this.disposed = true;
+    Array.from(this.ownedDisposers).forEach((dispose) => dispose());
   }
 }
 let initEnabled$1 = false;
@@ -2117,9 +2332,6 @@ function updateStore(store, props) {
   return store;
 }
 class Store {
-  static get types() {
-    return this[Symbol.metadata];
-  }
   props;
   constructor(props) {
     if (!initEnabled$1) {
@@ -2131,7 +2343,9 @@ class Store {
     );
     const adm = getStoreAdm(observable2);
     adm.setConfiguration(
-      () => this.constructor.types ?? {}
+      () => getConfigurationForCtor(
+        this.constructor
+      ) ?? {}
     );
     adm.write("props", getObservable({}));
     updateProps(observable2.props, props);
@@ -2140,141 +2354,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();
@@ -2330,19 +2512,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;
     });
@@ -2351,7 +2542,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;
     });
@@ -2367,8 +2563,9 @@ function getModelAdm(model2) {
 }
 function getIdKey(Ctor) {
   if (!ctorIdKeyMap.has(Ctor)) {
-    const key = Object.keys(Ctor.types).find(
-      (prop) => Ctor.types[prop].type === ModelCfgTypes.id
+    const config = getConfigurationForCtor(Ctor);
+    const key = Object.keys(config).find(
+      (prop) => config[prop]?.type === ModelCfgTypes.id
     ) ?? null;
     ctorIdKeyMap.set(Ctor, key);
   }
@@ -2417,16 +2614,25 @@ function validateModelChildValue(value, propertyName) {
   );
 }
 class ModelAdministration extends PreactObjectAdministration {
+  getCfgType(name) {
+    return getConfigType(this.configuration[name]);
+  }
+  getCfgChildType(name) {
+    return getConfigChildType(this.configuration[name]);
+  }
   static proxyTraps = Object.assign(
     {},
     PreactObjectAdministration.proxyTraps,
     {
       get(target, prop, proxy) {
         const adm = getAdministration(target);
+        if (prop === Symbol.dispose) {
+          return Reflect.get(target, prop, proxy);
+        }
         if (prop === "parent") {
           return target.parent;
         }
-        switch (adm.configuration[prop]?.type) {
+        switch (adm.getCfgType(prop)) {
           case ModelCfgTypes.modelRef:
             if (Array.isArray(adm.source[prop])) {
               return adm.getModelRefs(prop);
@@ -2441,9 +2647,10 @@ class ModelAdministration extends PreactObjectAdministration {
       },
       set(target, name, value) {
         const adm = getAdministration(target);
+        adm.assertUsable();
         adm.writeInProgress.add(name);
         try {
-          switch (adm.configuration[name]?.type) {
+          switch (adm.getCfgType(name)) {
             case ModelCfgTypes.modelRef: {
               Array.isArray(value) ? adm.setModelRefs(name, value) : adm.setModelRef(name, value);
               return true;
@@ -2478,7 +2685,7 @@ class ModelAdministration extends PreactObjectAdministration {
       defineProperty(target, name, desc) {
         const adm = getAdministration(target);
         if (desc && "value" in desc && !adm.writeInProgress.has(name)) {
-          switch (adm.configuration[name]?.type) {
+          switch (adm.getCfgType(name)) {
             case ModelCfgTypes.modelRef:
             case CommonCfgTypes.child:
             case ModelCfgTypes.id: {
@@ -2503,6 +2710,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();
@@ -2517,6 +2726,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?.() ?? {};
   }
@@ -2542,6 +2774,39 @@ class ModelAdministration extends PreactObjectAdministration {
       });
     }
   }
+  hydrateStateValue(currentValue, snapshotValue) {
+    if (currentValue instanceof Signal) {
+      currentValue.value = this.hydrateStateValue(
+        currentValue.value,
+        snapshotValue
+      );
+      return currentValue;
+    }
+    if (Array.isArray(currentValue) && Array.isArray(snapshotValue)) {
+      const nextItems = snapshotValue.map(
+        (item, index) => this.hydrateStateValue(currentValue[index], item)
+      );
+      currentValue.splice(0, currentValue.length, ...nextItems);
+      return currentValue;
+    }
+    if (isPlainObject(currentValue) && isPlainObject(snapshotValue)) {
+      const currentRecord = currentValue;
+      const snapshotRecord = snapshotValue;
+      Object.keys(snapshotRecord).forEach((key) => {
+        currentRecord[key] = this.hydrateStateValue(
+          currentRecord[key],
+          snapshotRecord[key]
+        );
+      });
+      Object.keys(currentRecord).forEach((key) => {
+        if (!(key in snapshotRecord)) {
+          delete currentRecord[key];
+        }
+      });
+      return currentValue;
+    }
+    return snapshotValue;
+  }
   setId(name, v) {
     const id2 = getIdentifier(this.proxy);
     if (id2 === v) {
@@ -2553,8 +2818,8 @@ class ModelAdministration extends PreactObjectAdministration {
       );
     }
     if (v !== void 0) {
-      this.source[name] = v;
       setIdentifier(this.proxy, v);
+      this.source[name] = v;
     }
   }
   setModel(name, newModel) {
@@ -2609,11 +2874,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;
+          }
         }
       })
     );
@@ -2628,7 +2912,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);
@@ -2637,7 +2923,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);
@@ -2647,6 +2935,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(
@@ -2659,6 +2948,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(
@@ -2670,31 +2960,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);
@@ -2732,7 +3078,7 @@ class ModelAdministration extends PreactObjectAdministration {
   }
   toJSON() {
     return Object.keys(this.configuration).reduce((json, key) => {
-      switch (this.configuration[key].type) {
+      switch (getConfigType(this.configuration[key])) {
         case ModelCfgTypes.state: {
           json[key] = clone(this.proxy[key], key);
           break;
@@ -2789,88 +3135,103 @@ class ModelAdministration extends PreactObjectAdministration {
   }
   loadSnapshot(snapshot) {
     const ensureChildTypes = (key) => {
-      if (!this.configuration[key].childType) {
+      const childType2 = this.getCfgChildType(key);
+      if (!childType2) {
         throw new Error(
           "r-state-tree: child constructor must be specified to load snapshots with child/children. eg: `@child(ChildCtor) MyChild`"
         );
       }
       return true;
     };
-    onSnapshotLoad(() => {
-      Object.keys(snapshot).forEach((key) => {
-        const { type, childType: childType2 } = this.configuration[key] ?? {};
-        const value = snapshot[key];
-        switch (type) {
-          case ModelCfgTypes.state:
-            this.proxy[key] = value;
-            break;
-          case ModelCfgTypes.modelRef:
-            if (Array.isArray(value)) {
-              if (value?.[0] 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] = value.map(
+                    (snapshot2) => getSnapshotRefId(snapshot2)
+                  );
+                  this.referencedAtoms?.get(key)?.reportChanged();
+                }
+                break;
+              } else if (value instanceof Model) {
                 this.proxy[key] = value;
               } else {
-                this.source[key] = value.map(
-                  (snapshot2) => getSnapshotRefId(snapshot2)
-                );
+                this.source[key] = getSnapshotRefId(value);
                 this.referencedAtoms?.get(key)?.reportChanged();
               }
               break;
-            } 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;
-              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, id2) : this.proxy[key][index];
-                    const adm = foundModel && getModelAdm(foundModel);
-                    if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
-                      adm.loadSnapshot(snapshot2);
-                      model22 = foundModel;
+            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 {
-                      model22 = Ctor.create(snapshot2);
+                      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 {
+                        model22 = Ctor.create(snapshot2);
+                      }
                     }
+                    return model22;
                   }
-                  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];
+                );
+                break;
+              } else if (value instanceof Model) {
+                model2 = value;
               } else {
-                model2 = childType2.create(value);
+                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.`
-            );
-        }
+              this.proxy[key] = model2;
+              break;
+            default:
+              console.warn(
+                `r-state-tree: invalid key '${key}' found in snapshot, ignored.`
+              );
+          }
+        });
       });
     });
   }
@@ -2884,14 +3245,14 @@ class ModelAdministration extends PreactObjectAdministration {
     }
     return this.computedSnapshot.get();
   }
+  getSnapshotForRollback() {
+    return this.toJSON();
+  }
 }
 let initEnabled = false;
 class Model {
-  static get types() {
-    return this[Symbol.metadata];
-  }
   static childTypes = {};
-  static create(snapshot, ...args) {
+  static create(snapshot) {
     let instance;
     try {
       initEnabled = true;
@@ -2900,8 +3261,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() {
@@ -2916,38 +3281,42 @@ class Model {
     );
     const adm = getModelAdm(observable2);
     adm.setConfiguration(
-      () => this.constructor.types ?? {}
+      () => getConfigurationForCtor(
+        this.constructor
+      ) ?? {}
     );
     return observable2;
   }
   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();
 }
@@ -2967,7 +3336,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");
@@ -3062,29 +3437,6 @@ function toObservableTreeInternal(value, ancestorPath, path) {
   }
   return value;
 }
-function makeDecorator(type) {
-  return function(value, context) {
-    context.metadata[context.name] = type;
-    return value;
-  };
-}
-function makeChildDecorator(typeObj) {
-  return function(valueOrChildType, context) {
-    if (context !== void 0) {
-      return makeDecorator(typeObj)(valueOrChildType, context);
-    }
-    const childCtor = valueOrChildType;
-    return function(value, context2) {
-      const typeWithCtor = typeObj(childCtor);
-      return makeDecorator(typeWithCtor)(value, context2);
-    };
-  };
-}
-const child = makeChildDecorator(childType);
-const modelRef = makeChildDecorator(modelRefType);
-const model = makeDecorator(modelType);
-const id = makeDecorator(idType);
-const state = makeDecorator(stateType);
 export {
   Model,
   Observable,
@@ -3097,6 +3449,7 @@ export {
   createContext,
   createStore,
   effect2 as effect,
+  findModelById,
   getSignal,
   id,
   isObservable,
@@ -3114,7 +3467,6 @@ export {
   state,
   toObservableTree,
   toSnapshot,
-  unmount,
   untracked2 as untracked,
   updateStore
 };