r-state-tree 0.5.0 → 0.6.0

package/dist/r-state-tree.js

@@ -1,5 +1,5 @@
-import { batch, Signal, signal, computed as computed$1, untracked, effect } from "@preact/signals-core";
-import { Signal as Signal2, batch as batch2, effect as effect2, signal as signal2, untracked as untracked2 } from "@preact/signals-core";
+import { batch, signal as signal$1, Signal, computed as computed$1, untracked, effect } from "@preact/signals-core";
+import { Signal as Signal2, batch as batch2, effect as effect2, untracked as untracked2 } from "@preact/signals-core";
 var lib = {};
 var hasRequiredLib;
 function requireLib() {
@@ -16,8 +16,6 @@ var CommonCfgTypes = /* @__PURE__ */ ((CommonCfgTypes2) => {
 })(CommonCfgTypes || {});
 var ModelCfgTypes = /* @__PURE__ */ ((ModelCfgTypes2) => {
   ModelCfgTypes2["state"] = "state";
-  ModelCfgTypes2["stateShallow"] = "stateShallow";
-  ModelCfgTypes2["stateSignal"] = "stateSignal";
   ModelCfgTypes2["id"] = "id";
   ModelCfgTypes2["modelRef"] = "modelRef";
   return ModelCfgTypes2;
@@ -27,9 +25,6 @@ var StoreCfgTypes = /* @__PURE__ */ ((StoreCfgTypes2) => {
   return StoreCfgTypes2;
 })(StoreCfgTypes || {});
 var ObservableCfgTypes = /* @__PURE__ */ ((ObservableCfgTypes2) => {
-  ObservableCfgTypes2["observable"] = "observable";
-  ObservableCfgTypes2["observableShallow"] = "observableShallow";
-  ObservableCfgTypes2["observableSignal"] = "observableSignal";
   ObservableCfgTypes2["computed"] = "computed";
   return ObservableCfgTypes2;
 })(ObservableCfgTypes || {});
@@ -46,14 +41,6 @@ const stateType = {
   type: "state"
   /* state */
 };
-const stateShallowType = {
-  type: "stateShallow"
-  /* stateShallow */
-};
-const stateSignalType = {
-  type: "stateSignal"
-  /* stateSignal */
-};
 const modelRefType = Object.assign(
   function(childType2) {
     return { type: "modelRef", childType: childType2 };
@@ -78,32 +65,29 @@ function isPropertyKey(val) {
   return typeof val === "string" || typeof val === "number" || typeof val === "symbol";
 }
 function getPropertyType(key, obj) {
-  const hasMetadata = obj.constructor[Symbol.metadata] !== void 0;
+  const ctor = obj.constructor;
+  const hasMetadata = ctor != null && ctor[Symbol.metadata] !== void 0;
   const descriptor = getPropertyDescriptor$1(obj, key);
   if (descriptor?.value && typeof descriptor.value === "function") {
     return "action";
   }
-  const isGetter = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
+  const isAccessor = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
   if (!hasMetadata) {
-    if (isGetter) {
+    if (descriptor?.get) {
       return "computed";
     }
+    if (isAccessor) {
+      return null;
+    }
     return "observable";
   }
   const metadata = obj.constructor[Symbol.metadata];
-  if (metadata && metadata[key]) {
-    const config = metadata[key];
+  const config = metadata?.[key];
+  if (config) {
     switch (config.type) {
       case ObservableCfgTypes.computed:
         return "computed";
-      case ObservableCfgTypes.observableShallow:
-      case ModelCfgTypes.stateShallow:
-        return "observableShallow";
-      case ObservableCfgTypes.observableSignal:
-      case ModelCfgTypes.stateSignal:
-        return "observableSignal";
       case ModelCfgTypes.state:
-      case ObservableCfgTypes.observable:
       case ModelCfgTypes.id:
       case ModelCfgTypes.modelRef:
       case CommonCfgTypes.child:
@@ -111,7 +95,7 @@ function getPropertyType(key, obj) {
         return "observable";
     }
   }
-  return null;
+  return isAccessor ? null : "observable";
 }
 function getPropertyDescriptor$1(obj, key) {
   let node = obj;
@@ -140,7 +124,7 @@ class Administration {
   atom;
   valuesMap;
   isObserved = false;
-  forceObservedAtoms;
+  forceObservedAtom;
   constructor(source2) {
     this.atom = createObservedAtom();
     this.source = source2;
@@ -150,13 +134,9 @@ class Administration {
     );
   }
   flushChange() {
-    if (this.forceObservedAtoms?.length) {
-      batch(() => {
-        for (let i = 0; i < this.forceObservedAtoms.length; i++) {
-          this.forceObservedAtoms[i].reportChanged();
-        }
-      });
-      this.forceObservedAtoms = void 0;
+    if (this.forceObservedAtom) {
+      this.forceObservedAtom.reportChanged();
+      this.forceObservedAtom = void 0;
     }
   }
   getNode() {
@@ -165,9 +145,7 @@ class Administration {
   reportChanged() {
     this.atom.reportChanged();
   }
-  reportObserveDeep() {
-  }
-  reportObserved(deep = false) {
+  reportObserved() {
     const entry = circularRefSet == null;
     if (entry) {
       circularRefSet = /* @__PURE__ */ new WeakSet();
@@ -175,15 +153,10 @@ class Administration {
       return;
     }
     circularRefSet.add(this);
-    const atom = createAtom();
-    if (!this.forceObservedAtoms) {
-      this.forceObservedAtoms = [];
-    }
-    this.forceObservedAtoms.push(atom);
-    atom.reportObserved();
-    if (deep) {
-      this.reportObserveDeep();
+    if (!this.forceObservedAtom) {
+      this.forceObservedAtom = createAtom();
     }
+    this.forceObservedAtom.reportObserved();
     if (entry) {
       circularRefSet = null;
     }
@@ -246,6 +219,9 @@ class NodeMap {
   reportChanged(key, value) {
     return this.get(key)?.reportChanged(value);
   }
+  keys() {
+    return this.map?.keys() ?? [];
+  }
 }
 class AtomMap extends NodeMap {
   createNode() {
@@ -263,31 +239,34 @@ class ObjectAdministration extends Administration {
   valuesMap;
   computedMap;
   types;
+  isWriting = false;
   static proxyTraps = {
     has(target, name) {
       const adm = getAdministration(target);
-      if (!(name in Object.prototype) && isPropertyKey(name))
+      if (isPropertyKey(name) && (!(name in Object.prototype) || Object.prototype.hasOwnProperty.call(adm.source, name)))
         return adm.has(name);
       return Reflect.has(adm.source, name);
     },
     get(target, name) {
       const adm = getAdministration(target);
-      if (!(name in Object.prototype) && isPropertyKey(name) && (typeof adm.source !== "function" || name !== "prototype")) {
-        return adm.read(name);
+      if (isPropertyKey(name) && (!(name in Object.prototype) || Object.prototype.hasOwnProperty.call(adm.source, name)) && (typeof adm.source !== "function" || name !== "prototype")) {
+        return adm.read(name, arguments[2]);
       }
-      return Reflect.get(adm.source, name, adm.proxy);
+      return Reflect.get(adm.source, name, arguments[2]);
     },
     set(target, name, value) {
       if (!isPropertyKey(name)) return false;
       const adm = getAdministration(target);
-      adm.write(name, value);
-      return true;
+      const receiver = arguments[3];
+      if (receiver === adm.proxy) {
+        return adm.write(name, value);
+      }
+      return Reflect.set(adm.source, name, value, receiver);
     },
     deleteProperty(target, name) {
       if (!isPropertyKey(name)) return false;
       const adm = getAdministration(target);
-      adm.remove(name);
-      return true;
+      return adm.remove(name);
     },
     ownKeys(target) {
       const adm = getAdministration(target);
@@ -296,21 +275,47 @@ class ObjectAdministration extends Administration {
         adm.atom.reportObserved();
       });
       return Reflect.ownKeys(adm.source);
+    },
+    defineProperty(target, name, descriptor) {
+      const adm = getAdministration(target);
+      if (adm.isWriting) {
+        return Reflect.defineProperty(adm.source, name, descriptor);
+      }
+      const result = Reflect.defineProperty(adm.source, name, descriptor);
+      if (result) {
+        batch(() => {
+          adm.types.delete(name);
+          adm.flushChange();
+          adm.keysAtom.reportChanged();
+          adm.hasMap.reportChanged(name);
+          if ("value" in descriptor) {
+            if (isObservable(descriptor.value)) {
+              adm.explicitObservables.add(name);
+            } else {
+              adm.explicitObservables.delete(name);
+            }
+            adm.valuesMap.reportChanged(name, descriptor.value);
+          } else {
+            adm.valuesMap.reportChanged(name, void 0);
+          }
+        });
+      }
+      return result;
     }
   };
   constructor(source2 = {}) {
     super(source2);
     this.keysAtom = createAtom();
     this.hasMap = new AtomMap(this.atom);
-    this.valuesMap = new SignalMap();
+    this.valuesMap = new SignalMap(this.atom);
     this.types = /* @__PURE__ */ new Map();
   }
   get(key) {
     return Reflect.get(this.source, key, this.proxy);
   }
   set(key, value) {
-    batch(() => {
-      Reflect.set(this.source, key, value, this.proxy);
+    return batch(() => {
+      return Reflect.set(this.source, key, value, this.proxy);
     });
   }
   getComputed(key) {
@@ -338,17 +343,6 @@ class ObjectAdministration extends Administration {
     }
     return type;
   }
-  reportObserveDeep() {
-    Object.getOwnPropertyNames(this.source).forEach((name) => {
-      const type = this.getType(name);
-      if (type === "observable") {
-        const value = this.source[name];
-        if (value && typeof value === "object") {
-          getAdministration(getObservable(value))?.reportObserved();
-        }
-      }
-    });
-  }
   reportChanged() {
     this.types.clear();
     super.reportChanged();
@@ -363,14 +357,13 @@ class ObjectAdministration extends Administration {
     }
     return resolveNode(this.valuesMap.getOrCreate(key, this.source[key]));
   }
-  read(key) {
+  read(key, receiver = this.proxy) {
     const type = this.getType(key);
     if (type === null) {
-      return this.get(key);
+      return Reflect.get(this.source, key, receiver);
     }
     switch (type) {
       case "observable":
-      case "observableShallow":
       case "action": {
         if (key in this.source) {
           this.valuesMap.reportObserved(key, this.source[key]);
@@ -380,48 +373,66 @@ class ObjectAdministration extends Administration {
           this.hasMap.reportObserved(key);
         }
         if (type === "observable") {
-          return getObservable(this.get(key));
-        }
-        if (type === "observableShallow") {
-          return getShallowObservable(this.get(key));
+          const value = Reflect.get(this.source, key, receiver);
+          const shouldWrap = this.explicitObservables.has(key) || isObservable(value);
+          if (shouldWrap && value && typeof value === "object" && !Object.isFrozen(value)) {
+            const desc = getPropertyDescriptor$1(this.source, key);
+            if (desc && !desc.configurable && !desc.writable) {
+              return value;
+            }
+            const existingAdm = getAdministration(value);
+            if (existingAdm) {
+              return existingAdm.proxy;
+            }
+          }
+          return value;
         }
-        return getAction(this.get(key));
+        return getAction(
+          Reflect.get(this.source, key, receiver)
+        );
       }
-      case "observableSignal": {
-        if (key in this.source) {
-          this.valuesMap.reportObserved(key, this.source[key]);
+      case "computed": {
+        if (receiver === this.proxy) {
+          return this.callComputed(key);
         }
         this.atom.reportObserved();
-        if (this.atom.observing) {
-          this.hasMap.reportObserved(key);
-        }
-        return this.get(key);
-      }
-      case "computed": {
-        return this.callComputed(key);
+        return Reflect.get(this.source, key, receiver);
       }
       default:
         throw new Error(`unknown type passed to configure`);
     }
   }
+  explicitObservables = /* @__PURE__ */ new Set();
   write(key, newValue) {
     const type = this.getType(key);
     if (type === null) {
-      this.set(key, newValue);
-      return;
+      return this.set(key, newValue);
     }
     if (type === "computed") {
-      batch(() => this.set(key, newValue));
-      return;
+      return batch(() => this.set(key, newValue));
     }
     const had = key in this.source;
     const oldValue = this.get(key);
     const targetValue = getSource(newValue);
+    const oldExplicit = this.explicitObservables.has(key);
+    const newExplicit = isObservable(newValue);
+    if (newExplicit) {
+      this.explicitObservables.add(key);
+    } else {
+      this.explicitObservables.delete(key);
+    }
     if (type === "action" && typeof newValue !== "function" || type === "observable" && typeof newValue === "function") {
       this.types.delete(key);
     }
-    if (!had || (isObservable(oldValue) ? oldValue !== newValue : oldValue !== targetValue)) {
-      this.set(key, targetValue);
+    const changed = !had || !isObservable(oldValue) && oldExplicit !== newExplicit || (isObservable(oldValue) ? oldValue !== newValue : oldValue !== targetValue);
+    if (changed) {
+      this.isWriting = true;
+      try {
+        const result = this.set(key, targetValue);
+        if (!result) return false;
+      } finally {
+        this.isWriting = false;
+      }
       batch(() => {
         this.flushChange();
         if (!had) {
@@ -430,7 +441,9 @@ class ObjectAdministration extends Administration {
         }
         this.valuesMap.reportChanged(key, newValue);
       });
+      return true;
     }
+    return true;
   }
   has(key) {
     this.atom.reportObserved();
@@ -440,39 +453,27 @@ class ObjectAdministration extends Administration {
     return key in this.source;
   }
   remove(key) {
-    if (!(key in this.source)) return;
-    delete this.source[key];
-    batch(() => {
-      this.flushChange();
-      this.valuesMap.reportChanged(key, void 0);
-      this.keysAtom.reportChanged();
-      this.hasMap.reportChanged(key);
-      this.valuesMap.delete(key);
-    });
+    if (!(key in this.source)) return true;
+    const result = Reflect.deleteProperty(this.source, key);
+    if (result) {
+      batch(() => {
+        this.flushChange();
+        this.valuesMap.reportChanged(key, void 0);
+        this.keysAtom.reportChanged();
+        this.hasMap.reportChanged(key);
+        this.valuesMap.delete(key);
+      });
+    }
+    return result;
   }
 }
 class PreactObjectAdministration extends ObjectAdministration {
-  static proxyTraps = Object.assign(
-    {},
-    ObjectAdministration.proxyTraps,
-    {
-      get(target, prop, proxy) {
-        if (!(prop in target) && (typeof prop === "string" || typeof prop === "number") && String(prop)[0] === "$") {
-          return getSignal(proxy, prop.substring(1));
-        }
-        return ObjectAdministration.proxyTraps.get?.apply(
-          null,
-          arguments
-        );
-      }
-    }
-  );
 }
 function createObservedAtom() {
   let value = 0;
   const callbacks = /* @__PURE__ */ new Set();
   let observing = false;
-  const signal22 = new Signal(value, {
+  const signal2 = new Signal(value, {
     watched() {
       callbacks.forEach((callback) => callback(true));
       observing = true;
@@ -483,12 +484,12 @@ function createObservedAtom() {
     }
   });
   return {
-    node: signal22,
+    node: signal2,
     reportObserved() {
-      return signal22.value;
+      return signal2.value;
     },
     reportChanged() {
-      return signal22.value = ++value;
+      return signal2.value = ++value;
     },
     get observing() {
       return observing;
@@ -502,7 +503,7 @@ function createObservedAtom() {
   };
 }
 function createSignal(initialValue) {
-  const s = signal(initialValue);
+  const s = signal$1(initialValue);
   return {
     node: s,
     reportChanged(value) {
@@ -521,7 +522,7 @@ function createSignal(initialValue) {
 }
 function createAtom() {
   let value = 0;
-  const s = signal(value);
+  const s = signal$1(value);
   return {
     node: s,
     reportChanged() {
@@ -604,31 +605,12 @@ function createComputed(fn, context = null) {
     }
   };
 }
-function observableImpl(value, context) {
-  if (context && typeof context === "object" && "kind" in context) {
-    context.metadata[context.name] = { type: "observable" };
-    return value;
-  }
-  return getObservable(value);
+function observable(obj) {
+  return getObservable(obj);
 }
-function shallowDecorator(value, context) {
-  if (context && typeof context === "object" && "kind" in context) {
-    context.metadata[context.name] = { type: "observableShallow" };
-    return value;
-  }
-  throw new Error("observable.shallow can only be used as a decorator");
+function signal(value) {
+  return signal$1(value);
 }
-function signalDecorator(value, context) {
-  if (context && typeof context === "object" && "kind" in context) {
-    context.metadata[context.name] = { type: "observableSignal" };
-    return value;
-  }
-  throw new Error("observable.signal can only be used as a decorator");
-}
-const observable = Object.assign(observableImpl, {
-  shallow: shallowDecorator,
-  signal: signalDecorator
-});
 function computed(value, context) {
   if (context && typeof context === "object" && "kind" in context) {
     context.metadata[context.name] = { type: "computed" };
@@ -639,29 +621,24 @@ function computed(value, context) {
 function source(obj) {
   return getSource(obj);
 }
-class Observable {
-  constructor() {
-    return getObservableClassInstance(this);
-  }
-}
 function reportChanged(obj) {
   const adm = getAdministration(obj);
   adm.reportChanged();
   return obj;
 }
-function reportObserved(obj, opts) {
+function reportObserved(obj) {
   const adm = getAdministration(obj);
-  adm.reportObserved(opts?.deep);
+  adm.reportObserved();
   return obj;
 }
 const signalMap = /* @__PURE__ */ new WeakMap();
 function getSignal(obj, key) {
   const node = getInternalNode(obj, key);
   if (node instanceof Signal) {
-    let signal22 = signalMap.get(node);
-    if (!signal22) {
-      signal22 = new Signal();
-      Object.defineProperties(signal22, {
+    let signal2 = signalMap.get(node);
+    if (!signal2) {
+      signal2 = new Signal();
+      Object.defineProperties(signal2, {
         value: {
           get() {
             return obj[key];
@@ -676,9 +653,9 @@ function getSignal(obj, key) {
           }
         }
       });
-      signalMap.set(node, signal22);
+      signalMap.set(node, signal2);
     }
-    return signal22;
+    return signal2;
   }
   return node;
 }
@@ -687,17 +664,36 @@ class CollectionAdministration extends Administration {
   hasMap;
   valuesMap;
   keysAtom;
+  isWeak;
+  strongTracking = null;
+  weakTracking = null;
   static proxyTraps = {
     get(target, name) {
       const adm = getAdministration(target);
-      if (name === "size" && "size" in adm.source) {
+      if (name === "size" && !adm.isWeak && "size" in adm.source) {
         return adm.size;
       }
       const val = adm.source[name];
       const collectionMethods = adm.constructor.methods;
-      if (collectionMethods.hasOwnProperty(name) && typeof val === "function") {
+      if (collectionMethods.hasOwnProperty(name)) {
+        if (adm.isWeak && !isValidWeakMethod(name)) {
+          return val;
+        }
         return collectionMethods[name];
       }
+      if (typeof val === "function") {
+        return function() {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `r-state-tree: Calling uninstrumented collection method "${String(
+                name
+              )}". Reactivity is not guaranteed for this call.`
+            );
+          }
+          const result = val.apply(adm.source, arguments);
+          return result === adm.source ? adm.proxy : result;
+        };
+      }
       return val;
     }
   };
@@ -712,17 +708,71 @@ class CollectionAdministration extends Administration {
     entries: createMethod$1("entries"),
     keys: createMethod$1("keys"),
     values: createMethod$1("values"),
-    [Symbol.iterator]: createMethod$1(Symbol.iterator)
+    [Symbol.iterator]: createMethod$1(Symbol.iterator),
+    // New ES methods
+    union: createGenericMethod("union"),
+    intersection: createGenericMethod("intersection"),
+    difference: createGenericMethod("difference"),
+    symmetricDifference: createGenericMethod("symmetricDifference"),
+    isSubsetOf: createGenericMethod("isSubsetOf"),
+    isSupersetOf: createGenericMethod("isSupersetOf"),
+    isDisjointFrom: createGenericMethod("isDisjointFrom")
   };
   constructor(source2) {
     super(source2);
     this.hasMap = new AtomMap(this.atom);
-    this.valuesMap = new SignalMap();
+    this.valuesMap = new SignalMap(this.atom);
     this.keysAtom = createAtom();
     this.isMap = typeof source2.set === "function" && typeof source2.get === "function";
+    this.isWeak = source2 instanceof WeakMap || source2 instanceof WeakSet;
+    if (this.isWeak) {
+      this.weakTracking = /* @__PURE__ */ new WeakSet();
+    } else {
+      this.strongTracking = /* @__PURE__ */ new Set();
+    }
+  }
+  trackExplicitObservable(key) {
+    if (this.isWeak) {
+      if (isNonPrimitive(key)) {
+        this.weakTracking.add(key);
+      }
+    } else {
+      this.strongTracking.add(key);
+    }
+  }
+  untrackExplicitObservable(key) {
+    if (this.isWeak) {
+      if (isNonPrimitive(key)) {
+        this.weakTracking.delete(key);
+      }
+    } else {
+      this.strongTracking.delete(key);
+    }
+  }
+  hasExplicitObservable(key) {
+    if (this.isWeak) {
+      return isNonPrimitive(key) && this.weakTracking.has(key);
+    }
+    return this.strongTracking.has(key);
+  }
+  getProxyVariant(key) {
+    if (!isNonPrimitive(key)) return void 0;
+    const adm = getAdministration(key);
+    if (adm && adm.proxy && adm.proxy !== key) {
+      return adm.proxy;
+    }
+    return void 0;
+  }
+  getExistingKey(key) {
+    const target = getSource(key);
+    if (this.source.has(target)) return target;
+    if (this.source.has(key)) return key;
+    const proxy = this.getProxyVariant(key);
+    if (proxy !== void 0 && this.source.has(proxy)) return proxy;
+    return void 0;
   }
   hasEntry(key) {
-    return this.source.has(getSource(key)) || this.source.has(key);
+    return this.getExistingKey(key) !== void 0;
   }
   onCollectionChange(key) {
     batch(() => {
@@ -731,13 +781,6 @@ class CollectionAdministration extends Administration {
       this.flushChange();
     });
   }
-  reportObserveDeep() {
-    this.source.forEach?.((value) => {
-      if (value && typeof value === "object") {
-        getAdministration(getObservable(value))?.reportObserved();
-      }
-    });
-  }
   getNode(key) {
     if (key == null) {
       return resolveNode(this.atom);
@@ -758,13 +801,12 @@ class CollectionAdministration extends Administration {
     this.keysAtom.reportObserved();
     this.atom.reportObserved();
     this.source.forEach((value, key) => {
-      const observed = getObservable(this.isMap ? key : value);
-      callbackFn.call(
-        thisArg,
-        this.isMap ? this.get(key) : observed,
-        observed,
-        this.proxy
-      );
+      if (this.isMap) {
+        callbackFn.call(thisArg, this.get(key), key, this.proxy);
+        return;
+      }
+      const wrapped = this.wrapSetValue(key);
+      callbackFn.call(thisArg, wrapped, wrapped, this.proxy);
     });
   }
   get size() {
@@ -773,43 +815,68 @@ class CollectionAdministration extends Administration {
     return this.source.size;
   }
   add(value) {
+    const target = getSource(value);
+    if (isObservable(value)) {
+      this.trackExplicitObservable(target);
+    } else {
+      this.untrackExplicitObservable(target);
+      this.untrackExplicitObservable(value);
+    }
     if (!this.hasEntry(value)) {
-      const target = getSource(value);
       this.source.add(target);
       this.onCollectionChange(target);
     }
     return this;
   }
   delete(value) {
-    if (this.hasEntry(value)) {
-      const target = getSource(value);
-      this.source.delete(target);
-      this.source.delete(value);
-      this.onCollectionChange(target);
-      return true;
+    const existingKey = this.getExistingKey(value);
+    if (existingKey === void 0) return false;
+    const target = getSource(value);
+    this.untrackExplicitObservable(target);
+    this.untrackExplicitObservable(value);
+    const proxy = this.getProxyVariant(value);
+    if (proxy !== void 0) this.untrackExplicitObservable(proxy);
+    this.source.delete(existingKey);
+    this.source.delete(target);
+    this.source.delete(value);
+    if (proxy !== void 0) this.source.delete(proxy);
+    this.onCollectionChange(target);
+    return true;
+  }
+  wrapSetValue(value) {
+    if (this.hasExplicitObservable(value)) {
+      if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        const existingAdm = getAdministration(value);
+        if (existingAdm) return existingAdm.proxy;
+      }
     }
-    return false;
+    return value;
   }
   has(value) {
     this.atom.reportObserved();
-    if (this.atom.observing || true) {
-      const target = getSource(value);
-      this.hasMap.reportObserved(target);
-    }
+    const target = getSource(value);
+    this.hasMap.reportObserved(target);
     return this.hasEntry(value);
   }
   entries() {
+    this.keysAtom.reportObserved();
+    this.atom.reportObserved();
     const self = this;
-    const keys = this.keys();
+    const iterator = this.source.entries();
     return {
       [Symbol.iterator]: function() {
         return this;
       },
       next() {
-        const { done, value } = keys.next();
+        const { done, value } = iterator.next();
+        if (done) return { done: true, value: void 0 };
+        const [key, val] = value;
         return {
-          done,
-          value: done ? void 0 : [value, self.isMap ? self.get(value) : value]
+          done: false,
+          value: [
+            self.isMap ? key : self.wrapSetValue(key),
+            self.isMap ? self.get(key) : self.wrapSetValue(val)
+          ]
         };
       }
     };
@@ -817,19 +884,19 @@ class CollectionAdministration extends Administration {
   keys() {
     this.keysAtom.reportObserved();
     this.atom.reportObserved();
-    let nextIndex = 0;
-    const observableKeys = Array.from(this.source.keys()).map(
-      (o) => getObservable(o)
-    );
+    const self = this;
+    const iterator = this.source.keys();
     return {
       [Symbol.iterator]: function() {
         return this;
       },
       next() {
-        return nextIndex < observableKeys.length ? {
-          value: observableKeys[nextIndex++],
-          done: false
-        } : { done: true, value: void 0 };
+        const { done, value } = iterator.next();
+        if (done) return { done: true, value: void 0 };
+        return {
+          done: false,
+          value: self.isMap ? value : self.wrapSetValue(value)
+        };
       }
     };
   }
@@ -837,31 +904,54 @@ class CollectionAdministration extends Administration {
     const targetKey = getSource(key);
     const sourceMap = this.source;
     const has = this.has(key);
-    const value = sourceMap.get(targetKey) ?? sourceMap.get(key);
-    if (has) {
+    if (!has) return void 0;
+    const existingKey = this.getExistingKey(key);
+    const value = sourceMap.get(existingKey);
+    this.valuesMap.reportObserved(targetKey, value);
+    if (key !== targetKey) {
       this.valuesMap.reportObserved(key, value);
-      if (isShallowObservable(this.proxy)) {
-        return value;
+    }
+    const proxyKey = this.getProxyVariant(key);
+    if (proxyKey !== void 0 && proxyKey !== key && proxyKey !== targetKey) {
+      this.valuesMap.reportObserved(proxyKey, value);
+    }
+    if (this.hasExplicitObservable(targetKey) || this.hasExplicitObservable(key) || proxyKey !== void 0 && this.hasExplicitObservable(proxyKey)) {
+      if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        const existingAdm = getAdministration(value);
+        if (existingAdm) return existingAdm.proxy;
       }
-      return getObservable(value);
     }
-    return void 0;
+    return value;
   }
   set(key, value) {
     const targetKey = getSource(key);
     const targetValue = getSource(value);
     const sourceMap = this.source;
-    const hasKey = this.hasEntry(key);
-    const oldValue = sourceMap.get(targetKey) ?? sourceMap.get(key);
-    if (!hasKey || isObservable(oldValue) ? oldValue !== value : oldValue !== targetValue) {
+    if (isObservable(value)) {
+      this.trackExplicitObservable(targetKey);
+    } else {
+      this.untrackExplicitObservable(targetKey);
+      this.untrackExplicitObservable(key);
+    }
+    const existingKey = this.getExistingKey(key);
+    const hasKey = existingKey !== void 0;
+    const oldValue = hasKey ? sourceMap.get(existingKey) : void 0;
+    if (!hasKey || (isObservable(oldValue) ? oldValue !== value : oldValue !== targetValue)) {
       batch(() => {
         this.flushChange();
-        if (sourceMap.has(key)) {
-          sourceMap.set(key, targetValue);
+        if (existingKey !== void 0) {
+          sourceMap.set(existingKey, targetValue);
         } else {
           sourceMap.set(targetKey, targetValue);
         }
-        this.valuesMap.reportChanged(key, value);
+        this.valuesMap.reportChanged(targetKey, value);
+        if (key !== targetKey) {
+          this.valuesMap.reportChanged(key, value);
+        }
+        const proxyKey = this.getProxyVariant(key);
+        if (proxyKey !== void 0 && proxyKey !== key && proxyKey !== targetKey) {
+          this.valuesMap.reportChanged(proxyKey, value);
+        }
         if (!hasKey) {
           this.hasMap.reportChanged(targetKey);
           this.keysAtom.reportChanged();
@@ -871,20 +961,22 @@ class CollectionAdministration extends Administration {
     return this;
   }
   values() {
-    const self = this;
-    const keys = this.keys();
+    this.keysAtom.reportObserved();
+    this.atom.reportObserved();
     if (!this.isMap) {
-      return keys;
+      return this.keys();
     }
+    const entries = this.entries();
     return {
       [Symbol.iterator]: function() {
         return this;
       },
       next() {
-        const { done, value } = keys.next();
+        const { done, value } = entries.next();
+        if (done) return { done: true, value: void 0 };
         return {
-          done,
-          value: done ? void 0 : self.get(value)
+          done: false,
+          value: value[1]
         };
       }
     };
@@ -894,53 +986,177 @@ class CollectionAdministration extends Administration {
   }
   [Symbol.toStringTag] = "Set";
 }
+function isValidWeakMethod(name) {
+  const n = name;
+  return n === "get" || n === "set" || n === "add" || n === "has" || n === "delete";
+}
+function createGenericMethod(name) {
+  return function() {
+    const adm = getAdministration(this);
+    const method = adm.source[name];
+    if (typeof method !== "function") return method;
+    if (["union", "intersection", "difference", "symmetricDifference"].includes(
+      name
+    )) {
+      const other = arguments[0];
+      const result2 = /* @__PURE__ */ new Set();
+      if (name === "union") {
+        for (const item of this) result2.add(item);
+        for (const item of other) result2.add(item);
+      } else if (name === "intersection") {
+        for (const item of this) {
+          if (other.has(item)) result2.add(item);
+        }
+      } else if (name === "difference") {
+        for (const item of this) {
+          if (!other.has(item)) result2.add(item);
+        }
+      } else if (name === "symmetricDifference") {
+        for (const item of this) {
+          if (!other.has(item)) result2.add(item);
+        }
+        for (const item of other) {
+          if (!this.has(item)) result2.add(item);
+        }
+      }
+      return result2;
+    }
+    adm.keysAtom.reportObserved();
+    adm.atom.reportObserved();
+    const args = new Array(arguments.length);
+    for (let i = 0; i < arguments.length; i++) {
+      const arg = arguments[i];
+      args[i] = getSource(arg);
+      if (isObservable(arg)) {
+        reportObserved(arg);
+      }
+    }
+    const result = method.apply(adm.source, args);
+    if (result === adm.source) return adm.proxy;
+    return result;
+  };
+}
 function createMethod$1(method) {
   return function() {
     const adm = getAdministration(this);
-    return adm[method].apply(adm, arguments);
+    const result = adm[method].apply(adm, arguments);
+    if (method === "add" || method === "set") {
+      return this;
+    }
+    return result;
   };
 }
+function isArrayIndexKey(key) {
+  if (typeof key === "symbol") return false;
+  const keyStr = String(key);
+  const num = Number(keyStr);
+  return Number.isInteger(num) && num >= 0 && num < 4294967295 && // 2^32 - 1
+  String(num) === keyStr;
+}
 class ArrayAdministration extends Administration {
   valuesMap;
   keysAtom;
+  explicitObservables = /* @__PURE__ */ new Set();
+  syncExplicitObservablesFromSource() {
+    for (let i = 0; i < this.source.length; i++) {
+      const value = this.source[i];
+      if (isObservable(value)) {
+        this.explicitObservables.add(i);
+      }
+    }
+  }
   static proxyTraps = {
-    get(target, name) {
+    get(target, name, receiver) {
       const adm = getAdministration(target);
       if (name === "length") {
         return adm.getArrayLength();
       }
-      if (typeof name === "number") {
-        return adm.get(name);
-      }
-      if (typeof name === "string" && String(parseInt(name)) === name) {
-        return adm.get(parseInt(name));
+      if (isArrayIndexKey(name)) {
+        return adm.get(Number(name));
       }
       const arrayMethods = adm.constructor.methods;
       if (arrayMethods.hasOwnProperty(name)) {
         return arrayMethods[name];
       }
-      return adm.source[name];
+      return Reflect.get(adm.source, name, receiver);
     },
     set(target, name, value) {
       const adm = getAdministration(target);
       if (name === "length") {
-        adm.setArrayLength(value);
-      } else if (typeof name === "number") {
-        adm.set(name, value);
-      } else if (typeof name === "string" && String(parseInt(name)) === name) {
-        adm.set(parseInt(name), value);
+        return adm.setArrayLength(value);
+      } else if (isArrayIndexKey(name)) {
+        return adm.set(Number(name), value);
       } else {
-        adm.source[name] = value;
+        return Reflect.set(adm.source, name, value, arguments[3]);
       }
-      return true;
+    },
+    defineProperty(target, name, descriptor) {
+      const adm = getAdministration(target);
+      const result = Reflect.defineProperty(adm.source, name, descriptor);
+      if (result) {
+        batch(() => {
+          adm.flushChange();
+          if (name === "length") {
+            adm.keysAtom.reportChanged();
+            adm.atom.reportChanged();
+          } else if (isArrayIndexKey(name)) {
+            const index = Number(name);
+            adm.keysAtom.reportChanged();
+            adm.onArrayChanged(false, index, 1);
+          } else {
+            adm.atom.reportChanged();
+          }
+        });
+      }
+      return result;
+    },
+    deleteProperty(target, name) {
+      const adm = getAdministration(target);
+      const isIndex = isArrayIndexKey(name);
+      const had = name in adm.source;
+      const result = Reflect.deleteProperty(adm.source, name);
+      if (result && had && isIndex) {
+        const index = Number(name);
+        adm.onArrayChanged(true, index, 1);
+        adm.explicitObservables.delete(index);
+      }
+      return result;
+    },
+    ownKeys(target) {
+      const adm = getAdministration(target);
+      batch(() => {
+        adm.keysAtom.reportObserved();
+        adm.atom.reportObserved();
+      });
+      return Reflect.ownKeys(adm.source);
+    },
+    has(target, name) {
+      const adm = getAdministration(target);
+      if (isArrayIndexKey(name)) {
+        const index = Number(name);
+        adm.atom.reportObserved();
+        adm.valuesMap.reportObserved(index, adm.source[index]);
+        return index in adm.source;
+      }
+      return Reflect.has(adm.source, name);
     }
   };
   static methods = {
     fill(value, start, end) {
       const adm = getAdministration(this);
-      const oldLength = adm.source.length;
-      adm.source.fill(value, start, end);
-      adm.onArrayChanged(oldLength !== adm.source.length, start, end);
+      const shouldTrack = isObservable(value);
+      const targetValue = getSource(value);
+      adm.source.fill(targetValue, start, end);
+      const length = adm.source.length;
+      const from = start == null ? 0 : start < 0 ? Math.max(length + start, 0) : start;
+      const to = end == null ? length : end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
+      for (let i = from; i < to; i++) {
+        if (shouldTrack) adm.explicitObservables.add(i);
+        else adm.explicitObservables.delete(i);
+      }
+      if (from < to) {
+        adm.onArrayChanged(false, from, to - from);
+      }
       return this;
     },
     splice(index, deleteCount, ...newItems) {
@@ -976,16 +1192,43 @@ class ArrayAdministration extends Administration {
     },
     reverse() {
       const adm = getAdministration(this);
+      adm.syncExplicitObservablesFromSource();
+      const flags = new Array(adm.source.length);
+      for (let i = 0; i < flags.length; i++) {
+        flags[i] = adm.explicitObservables.has(i);
+      }
       adm.source.reverse();
+      flags.reverse();
+      adm.explicitObservables.clear();
+      for (let i = 0; i < flags.length; i++) {
+        if (flags[i]) adm.explicitObservables.add(i);
+      }
       adm.onArrayChanged(false, 0, adm.source.length);
       return this;
     },
     sort(compareFn) {
       const adm = getAdministration(this);
-      adm.onArrayChanged();
-      adm.source.sort(
-        compareFn && ((a, b) => compareFn(getObservable(a), getObservable(b)))
-      );
+      adm.syncExplicitObservablesFromSource();
+      const pairs = new Array(adm.source.length);
+      for (let i = 0; i < adm.source.length; i++) {
+        pairs[i] = {
+          value: this[i],
+          stored: adm.source[i],
+          observed: adm.explicitObservables.has(i)
+        };
+      }
+      const comparator = compareFn ?? ((a, b) => {
+        const as = String(a);
+        const bs = String(b);
+        return as < bs ? -1 : as > bs ? 1 : 0;
+      });
+      pairs.sort((a, b) => comparator(a.value, b.value));
+      adm.explicitObservables.clear();
+      for (let i = 0; i < pairs.length; i++) {
+        adm.source[i] = pairs[i].stored;
+        if (pairs[i].observed) adm.explicitObservables.add(i);
+      }
+      adm.onArrayChanged(false, 0, adm.source.length);
       return this;
     },
     join: createStringMethod("join"),
@@ -997,7 +1240,22 @@ class ArrayAdministration extends Administration {
     slice: createCopyMethod("slice"),
     concat: createCopyMethod("concat"),
     flat: createCopyMethod("flat"),
-    copyWithin: createCopyMethod("copyWithin"),
+    copyWithin(target, start, end) {
+      const adm = getAdministration(this);
+      adm.syncExplicitObservablesFromSource();
+      const flags = new Array(adm.source.length);
+      for (let i = 0; i < flags.length; i++) {
+        flags[i] = adm.explicitObservables.has(i);
+      }
+      adm.source.copyWithin(target, start, end);
+      flags.copyWithin(target, start, end);
+      adm.explicitObservables.clear();
+      for (let i = 0; i < flags.length; i++) {
+        if (flags[i]) adm.explicitObservables.add(i);
+      }
+      adm.onArrayChanged(false, 0, adm.source.length);
+      return this;
+    },
     every: createMapMethod("every"),
     forEach: createMapMethod("forEach"),
     map: createMapMethod("map"),
@@ -1011,17 +1269,9 @@ class ArrayAdministration extends Administration {
   };
   constructor(source2 = []) {
     super(source2);
-    this.valuesMap = new SignalMap();
+    this.valuesMap = new SignalMap(this.atom);
     this.keysAtom = createAtom();
   }
-  reportObserveDeep() {
-    for (let i = 0; i < this.source.length; i++) {
-      const value = this.source[i];
-      if (value && typeof value === "object") {
-        getAdministration(getObservable(value))?.reportObserved();
-      }
-    }
-  }
   getNode(key) {
     if (key == null) {
       return this.atom;
@@ -1031,52 +1281,98 @@ class ArrayAdministration extends Administration {
   get(index) {
     this.atom.reportObserved();
     this.valuesMap.reportObserved(index, this.source[index]);
-    if (isShallowObservable(this.proxy)) {
-      return this.source[index];
+    return this._getEffectiveValue(index);
+  }
+  _getEffectiveValue(index) {
+    const value = this.source[index];
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+      if (this.explicitObservables.has(index)) {
+        const existingAdm = getAdministration(value);
+        if (existingAdm) {
+          if (existingAdm.proxy !== value) {
+            const desc = Object.getOwnPropertyDescriptor(this.source, index);
+            if (desc && !desc.configurable && !desc.writable) {
+              if (process.env.NODE_ENV !== "production") {
+                console.warn(
+                  `r-state-tree: cannot return an observable proxy for arr[${index}] because it is a non-configurable, non-writable data property; returning the raw value to uphold Proxy invariants.`
+                );
+              }
+              this.explicitObservables.delete(index);
+              return value;
+            }
+          }
+          return existingAdm.proxy;
+        }
+      }
     }
-    return getObservable(this.source[index]);
+    return value;
   }
   set(index, newValue) {
     const values = this.source;
     const targetValue = getSource(newValue);
-    if (index < values.length) {
+    const oldLength = values.length;
+    let changed = true;
+    if (index < oldLength) {
       const oldValue = values[index];
-      const changed = isObservable(oldValue) ? newValue !== oldValue : targetValue !== oldValue;
-      if (changed) {
-        values[index] = targetValue;
-        this.onArrayChanged(false, index, 1);
-      }
-    } else if (index === values.length) {
-      this.spliceWithArray(index, 0, [newValue]);
+      const oldExplicit = this.explicitObservables.has(index);
+      const newExplicit = isObservable(newValue);
+      changed = !isObservable(oldValue) && oldExplicit !== newExplicit || (isObservable(oldValue) ? newValue !== oldValue : targetValue !== oldValue);
+    }
+    if (!changed) return true;
+    const result = Reflect.set(values, index, targetValue);
+    if (!result) return false;
+    const newLength = values.length;
+    const lengthChanged = newLength !== oldLength;
+    if (isObservable(newValue)) {
+      this.explicitObservables.add(index);
     } else {
-      throw new Error(
-        `Index out of bounds, ${index} is larger than ${values.length}`
-      );
+      this.explicitObservables.delete(index);
     }
+    this.onArrayChanged(lengthChanged, index, 1);
+    return true;
   }
   getArrayLength() {
     this.atom.reportObserved();
     this.keysAtom.reportObserved();
     return this.source.length;
   }
-  setArrayLength(newLength) {
-    if (typeof newLength !== "number" || newLength < 0)
-      throw new Error("Out of range: " + newLength);
+  setArrayLength(input) {
+    const num = Number(input);
+    const coerced = num >>> 0;
+    if (coerced !== num) {
+      throw new RangeError("Invalid array length");
+    }
+    const newLength = coerced;
     const currentLength = this.source.length;
-    if (newLength === currentLength) return;
-    else if (newLength > currentLength) {
-      const newItems = new Array(newLength - currentLength);
-      for (let i = 0; i < newLength - currentLength; i++)
-        newItems[i] = void 0;
-      this.spliceWithArray(currentLength, 0, newItems);
-    } else this.spliceWithArray(newLength, currentLength - newLength);
+    if (newLength === currentLength) return true;
+    const result = Reflect.set(this.source, "length", newLength);
+    if (!result) return false;
+    if (newLength < currentLength) {
+      const toRemove = [];
+      for (const index of this.explicitObservables) {
+        if (index >= newLength) {
+          toRemove.push(index);
+        }
+      }
+      for (const index of toRemove) {
+        this.explicitObservables.delete(index);
+      }
+      this.onArrayChanged(true, newLength, currentLength - newLength);
+    } else {
+      this.onArrayChanged(true, currentLength, newLength - currentLength);
+    }
+    return true;
   }
   spliceWithArray(index, deleteCount, newItems) {
     const length = this.source.length;
     const newTargetItems = [];
+    const newObservableIndices = [];
     if (newItems) {
       for (let i = 0; i < newItems.length; i++) {
         newTargetItems[i] = getSource(newItems[i]);
+        if (isObservable(newItems[i])) {
+          newObservableIndices.push(i);
+        }
       }
     }
     if (index === void 0) index = 0;
@@ -1085,15 +1381,39 @@ class ArrayAdministration extends Administration {
     if (arguments.length === 1) deleteCount = length - index;
     else if (deleteCount === void 0 || deleteCount === null) deleteCount = 0;
     else deleteCount = Math.max(0, Math.min(deleteCount, length - index));
-    const res = this.spliceItemsIntoValues(index, deleteCount, newTargetItems);
+    const removedItems = [];
+    for (let i = index; i < index + deleteCount; i++) {
+      removedItems.push(this._getEffectiveValue(i));
+    }
+    for (let i = index; i < index + deleteCount; i++) {
+      this.explicitObservables.delete(i);
+    }
+    const shift = (newItems?.length ?? 0) - deleteCount;
+    if (shift !== 0) {
+      const newExplicitObservables = /* @__PURE__ */ new Set();
+      for (const idx of this.explicitObservables) {
+        if (idx < index) {
+          newExplicitObservables.add(idx);
+        } else if (idx >= index + deleteCount) {
+          newExplicitObservables.add(idx + shift);
+        }
+      }
+      this.explicitObservables.clear();
+      for (const idx of newExplicitObservables) {
+        this.explicitObservables.add(idx);
+      }
+    }
+    for (const relativeIdx of newObservableIndices) {
+      this.explicitObservables.add(index + relativeIdx);
+    }
+    this.spliceItemsIntoValues(index, deleteCount, newTargetItems);
     if (deleteCount !== 0 || newTargetItems.length !== 0) {
-      this.onArrayChanged(
-        length !== this.source.length,
-        index,
-        Math.max(deleteCount ?? 0, newItems?.length ?? 0)
-      );
+      const shift2 = (newItems?.length ?? 0) - deleteCount;
+      const reindexing = shift2 !== 0 && index + deleteCount < length;
+      const count = reindexing ? Number.POSITIVE_INFINITY : Math.max(deleteCount ?? 0, newItems?.length ?? 0);
+      this.onArrayChanged(length !== this.source.length, index, count);
     }
-    return res;
+    return removedItems;
   }
   spliceItemsIntoValues(index, deleteCount, newItems) {
     return this.source.splice.apply(
@@ -1108,9 +1428,16 @@ class ArrayAdministration extends Administration {
       }
       if (index == null) {
         this.atom.reportChanged();
-      } else {
-        for (let i = index; i < index + count; i++) {
-          this.valuesMap.reportChanged(i, this.source[i]);
+      } else if (count !== void 0 && count > 0) {
+        const observedKeys = this.valuesMap.keys();
+        const end = index + count;
+        for (const key of observedKeys) {
+          if (typeof key === "number" && key >= index && key < end) {
+            const node = this.valuesMap.get(key);
+            if (node) {
+              node.reportChanged(this._getEffectiveValue(key));
+            }
+          }
         }
       }
       this.flushChange();
@@ -1126,7 +1453,7 @@ function createMethod(method, func) {
 function createStringMethod(method) {
   return createMethod(method, function() {
     const adm = getAdministration(this);
-    adm.reportObserved(false);
+    adm.reportObserved();
     const sourceArr = getSource(this);
     return sourceArr[method].apply(sourceArr, arguments);
   });
@@ -1134,7 +1461,7 @@ function createStringMethod(method) {
 function createSearchMethod(method) {
   return createMethod(method, function() {
     const adm = getAdministration(this);
-    adm.reportObserved(false);
+    adm.reportObserved();
     const target = arguments[0];
     const source2 = getSource(target);
     const sourceArr = getSource(this);
@@ -1150,10 +1477,38 @@ function createSearchMethod(method) {
 function createCopyMethod(method) {
   return createMethod(method, function() {
     const adm = getAdministration(this);
-    adm.reportObserved(false);
-    return getObservable(
-      adm.source[method].apply(adm.source, arguments)
-    );
+    adm.reportObserved();
+    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);
+    if (method === "concat") {
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (Array.isArray(arg) && isObservable(arg)) {
+          const argAdm = getAdministration(arg);
+          const argObserved = [];
+          argObserved.length = argAdm.source.length;
+          const argKeys = Object.keys(argAdm.source);
+          for (let j = 0; j < argKeys.length; j++) {
+            const argKey = argKeys[j];
+            const argIdx = Number(argKey);
+            if (!Number.isNaN(argIdx)) {
+              argObserved[argIdx] = arg[argIdx];
+            }
+          }
+          args[i] = argObserved;
+        }
+      }
+    }
+    return Array.prototype[method].apply(observedInput, args);
   });
 }
 function createMapMethod(method) {
@@ -1161,14 +1516,9 @@ function createMapMethod(method) {
     method,
     function(callback, thisArg) {
       const adm = getAdministration(this);
-      adm.reportObserved(false);
-      return adm.source[method]((element, index) => {
-        return callback.call(
-          thisArg,
-          element && typeof element === "object" ? getObservable(element) : element,
-          index,
-          this
-        );
+      adm.reportObserved();
+      return adm.source[method]((_element, index) => {
+        return callback.call(thisArg, this[index], index, this);
       });
     }
   );
@@ -1178,28 +1528,17 @@ function createFilterMethod(method) {
     method,
     function(callback, thisArg) {
       const adm = getAdministration(this);
-      adm.reportObserved(false);
-      return getObservable(
-        adm.source[method]((element, index) => {
-          return callback.call(
-            thisArg,
-            element && typeof element === "object" ? getObservable(element) : element,
-            index,
-            this
-          );
-        })
-      );
+      adm.reportObserved();
+      return adm.source[method]((_element, index) => {
+        return callback.call(thisArg, this[index], index, this);
+      });
     }
   );
 }
 function createReduceMethod(method) {
   return createMethod(method, function() {
     const adm = getAdministration(this);
-    adm.reportObserved(false);
-    const callback = arguments[0];
-    arguments[0] = (accumulator, currentValue, index) => {
-      return callback(accumulator, getObservable(currentValue), index, this);
-    };
+    adm.reportObserved();
     return adm.source[method].apply(adm.source, arguments);
   });
 }
@@ -1226,6 +1565,7 @@ function addDateSetMethod(method) {
       const adm = getAdministration(this);
       const res = adm.source[method].apply(adm.source, arguments);
       adm.atom.reportChanged();
+      adm.flushChange();
       return res;
     };
 }
@@ -1261,9 +1601,15 @@ function getAction(fn) {
 }
 function getObservableClassInstance(value) {
   const adm = new PreactObjectAdministration(value);
+  administrationMap.set(adm.proxy, adm);
   administrationMap.set(adm.source, adm);
   return adm.proxy;
 }
+class Observable {
+  constructor() {
+    return getObservableClassInstance(this);
+  }
+}
 function createObservableWithCustomAdministration(value, Adm) {
   const adm = new Adm(value);
   administrationMap.set(adm.proxy, adm);
@@ -1271,40 +1617,6 @@ function createObservableWithCustomAdministration(value, Adm) {
   return adm.proxy;
 }
 function getObservable(value) {
-  if (!value) {
-    return value;
-  }
-  const adm = getAdministration(value);
-  if (adm) {
-    return adm.proxy;
-  }
-  if ((typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
-    const obj = value;
-    let Adm = PreactObjectAdministration;
-    if (Array.isArray(obj)) {
-      Adm = ArrayAdministration;
-    } else if (obj instanceof Map || obj instanceof WeakMap) {
-      Adm = CollectionAdministration;
-    } else if (obj instanceof Set || obj instanceof WeakSet) {
-      Adm = CollectionAdministration;
-    } else if (obj instanceof Date) {
-      Adm = DateAdministration;
-    } else if (!isPlainObject(value)) {
-      return value;
-    }
-    const adm2 = new Adm(obj);
-    administrationMap.set(adm2.proxy, adm2);
-    administrationMap.set(adm2.source, adm2);
-    return adm2.proxy;
-  }
-  return value;
-}
-const shallowObservables = /* @__PURE__ */ new WeakSet();
-function isShallowObservable(obj) {
-  if (!obj || typeof obj !== "object") return false;
-  return shallowObservables.has(obj);
-}
-function getShallowObservable(value) {
   if (!value) {
     return value;
   }
@@ -1312,23 +1624,43 @@ function getShallowObservable(value) {
   if (existingAdm) {
     return existingAdm.proxy;
   }
-  if ((typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
+  if (typeof value === "function") {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `r-state-tree: functions are not observable containers. The function will be returned unchanged. Note: functions read from observable objects are still automatically batched as actions.`
+      );
+    }
+    return value;
+  }
+  if (typeof value === "object") {
     const obj = value;
     let Adm = null;
-    if (Array.isArray(obj)) {
-      Adm = ArrayAdministration;
-    } else if (obj instanceof Map || obj instanceof WeakMap) {
+    if (obj instanceof Map || obj instanceof WeakMap) {
       Adm = CollectionAdministration;
     } else if (obj instanceof Set || obj instanceof WeakSet) {
       Adm = CollectionAdministration;
+    } else if (obj instanceof Date) {
+      Adm = DateAdministration;
+    } else if (!Object.isFrozen(obj)) {
+      if (Array.isArray(obj)) {
+        Adm = ArrayAdministration;
+      } else if (isPlainObject(obj)) {
+        Adm = PreactObjectAdministration;
+      }
     }
     if (Adm) {
       const adm = new Adm(obj);
       administrationMap.set(adm.proxy, adm);
       administrationMap.set(adm.source, adm);
-      shallowObservables.add(adm.proxy);
       return adm.proxy;
     }
+    if (process.env.NODE_ENV !== "production" && !Object.isFrozen(obj)) {
+      const proto = Object.getPrototypeOf(obj);
+      const typeName = proto?.constructor?.name && proto.constructor.name !== "Object" ? `instance of ${proto.constructor.name}` : "non-plain object";
+      console.warn(
+        `r-state-tree: observable() was called with a ${typeName}. This object will NOT be made observable because proxying arbitrary class instances can break #private fields and built-in brand checks. To make a class observable, use 'class MyClass extends Observable'.`
+      );
+    }
   }
   return value;
 }
@@ -1357,19 +1689,77 @@ function getPropertyDescriptor(obj, key) {
   }
   return void 0;
 }
-function clone(val) {
-  if (Array.isArray(val)) {
-    return val.map((v) => clone(v));
-  } else if (val && typeof val === "object") {
-    const keys = Object.keys(val);
-    const cloned = {};
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      cloned[key] = clone(val[key]);
+function clone(val, path = "") {
+  if (val === null || val === void 0) {
+    return val;
+  }
+  if (typeof val !== "object") {
+    if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+      return val;
+    }
+    const atPath = path ? ` at path "${path}"` : "";
+    if (typeof val === "bigint") {
+      throw new Error(
+        `r-state-tree: snapshots do not support bigint${atPath}. Snapshots are JSON-only (primitives, arrays, plain objects, Dates as ISO strings).`
+      );
+    }
+    if (typeof val === "symbol") {
+      throw new Error(
+        `r-state-tree: snapshots do not support symbol${atPath}. Snapshots are JSON-only (primitives, arrays, plain objects, Dates as ISO strings).`
+      );
+    }
+    if (typeof val === "function") {
+      throw new Error(
+        `r-state-tree: snapshots do not support function${atPath}. Snapshots are JSON-only (primitives, arrays, plain objects, Dates as ISO strings).`
+      );
     }
-    return cloned;
+    throw new Error(
+      `r-state-tree: snapshots do not support ${typeof val}${atPath}. Snapshots are JSON-only (primitives, arrays, plain objects, Dates as ISO strings).`
+    );
+  }
+  if (val instanceof Signal) {
+    return clone(
+      val.value,
+      path
+    );
+  }
+  if (val instanceof Date) {
+    return val.toISOString();
+  }
+  if (Array.isArray(val)) {
+    return val.map(
+      (v, i) => clone(v, path ? `${path}[${i}]` : `[${i}]`)
+    );
+  }
+  if (!isPlainObject(val)) {
+    const typeName = getTypeName(val);
+    const atPath = path ? ` at path "${path}"` : "";
+    throw new Error(
+      `r-state-tree: snapshots do not support ${typeName}${atPath}. Snapshots are JSON-only (primitives, arrays, plain objects, Dates as ISO strings).`
+    );
   }
-  return val;
+  const keys = Object.keys(val);
+  const cloned = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const keyPath = path ? `${path}.${key}` : key;
+    cloned[key] = clone(val[key], keyPath);
+  }
+  return cloned;
+}
+function getTypeName(val) {
+  if (val instanceof Map) return "Map";
+  if (val instanceof Set) return "Set";
+  if (val instanceof WeakMap) return "WeakMap";
+  if (val instanceof WeakSet) return "WeakSet";
+  if (val instanceof RegExp) return "RegExp";
+  if (val instanceof Error) return "Error";
+  if (val instanceof Promise) return "Promise";
+  const proto = Object.getPrototypeOf(val);
+  if (proto?.constructor?.name && proto.constructor.name !== "Object") {
+    return `class instance (${proto.constructor.name})`;
+  }
+  return "non-plain object";
 }
 function getDiff(o1, o2, getConfig) {
   const config = getConfig(o2);
@@ -1442,7 +1832,9 @@ function updateProps(props, newProps) {
         }
       });
       if (newProps.models) {
-        if (!props.models) props.models = {};
+        if (!props.models || !isObservable(props.models)) {
+          props.models = getObservable(props.models || {});
+        }
         Object.assign(props.models, newProps.models);
       }
     });
@@ -1666,7 +2058,9 @@ class StoreAdministration extends PreactObjectAdministration {
     }
   }
   getModelRef(name) {
-    return this.proxy.props.models?.[name] ?? null;
+    const models = this.proxy.props.models;
+    const ref = models?.[name] ?? null;
+    return ref;
   }
   isRoot() {
     return !this.parent;
@@ -2004,11 +2398,12 @@ class ObservableListener {
 class ChildModelsAdministration extends ArrayAdministration {
   set(index, newValue) {
     return batch(() => {
-      super.set(index, newValue);
+      const result = super.set(index, newValue);
       const sourceValue = getSource(newValue);
       if (this.source[index] !== sourceValue) {
         notifyArrayUpdate(this.proxy, index, this.source[index], sourceValue);
       }
+      return result;
     });
   }
   spliceWithArray(index, deleteCount, newItems) {
@@ -2041,7 +2436,19 @@ function getIdKey(Ctor) {
 function getModelRefSnapshot(modelRef2) {
   const Ctor = Object.getPrototypeOf(modelRef2).constructor;
   const idKey = getIdKey(Ctor);
-  return idKey ? { [idKey]: getIdentifier(modelRef2) } : null;
+  if (!idKey) return null;
+  let id2 = getIdentifier(modelRef2);
+  if (id2 === void 0) {
+    const source2 = getSource(modelRef2);
+    id2 = getIdentifier(source2);
+    if (id2 === void 0) {
+      const adm = getAdministration(modelRef2);
+      if (adm && adm.proxy !== modelRef2) {
+        id2 = getIdentifier(adm.proxy);
+      }
+    }
+  }
+  return { [idKey]: id2 };
 }
 function getSnapshotId(snapshot, Ctor) {
   const idKey = getIdKey(Ctor);
@@ -2126,9 +2533,7 @@ class ModelAdministration extends PreactObjectAdministration {
               adm.setId(name, value);
               break;
             }
-            case ModelCfgTypes.state:
-            case ModelCfgTypes.stateShallow:
-            case ModelCfgTypes.stateSignal: {
+            case ModelCfgTypes.state: {
               adm.setState(name, value);
               break;
             }
@@ -2167,9 +2572,60 @@ class ModelAdministration extends PreactObjectAdministration {
   modelsTraceUnsub = /* @__PURE__ */ new Map();
   writeInProgress = /* @__PURE__ */ new Set();
   computedSnapshot;
+  snapshotAtom = createAtom();
   snapshotMap = /* @__PURE__ */ new Map();
   contextCache = /* @__PURE__ */ new Map();
   parentName = null;
+  /**
+   * `@state` fields are shallow-reactive (property-level assignment triggers reactivity)
+   * and participate in snapshots. Values stored in `@state` are not deep-wrapped.
+   *
+   * This helper walks a value and:
+   * - observes any observable containers found (proxy or source) so in-place mutations
+   *   invalidate `getSnapshot()` / `toSnapshot()`
+   * - avoids proxy traversal by preferring `getSource(...)`
+   * - guards against cycles via `WeakSet`
+   */
+  observeSnapshotValue(value, seen) {
+    if (value == null) return;
+    if (typeof value !== "object") return;
+    if (!seen) seen = /* @__PURE__ */ new WeakSet();
+    const obj = value;
+    if (seen.has(obj)) return;
+    seen.add(obj);
+    const adm = getAdministration(obj);
+    if (adm) {
+      adm.reportObserved();
+    }
+    const src = getSource(value);
+    if (src && typeof src === "object" && src !== value) {
+      this.observeSnapshotValue(src, seen);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        this.observeSnapshotValue(value[i], seen);
+      }
+      return;
+    }
+    if (value instanceof Map) {
+      value.forEach((v, k) => {
+        this.observeSnapshotValue(k, seen);
+        this.observeSnapshotValue(v, seen);
+      });
+      return;
+    }
+    if (value instanceof Set) {
+      value.forEach((v) => this.observeSnapshotValue(v, seen));
+      return;
+    }
+    if (value instanceof Date) {
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      this.observeSnapshotValue(value[key], seen);
+    }
+  }
   get parent() {
     this.parentAtom.reportObserved();
     return this._parent;
@@ -2198,12 +2654,15 @@ class ModelAdministration extends PreactObjectAdministration {
   setState(name, value) {
     const oldValue = this.source[name];
     if (value !== oldValue) {
-      PreactObjectAdministration.proxyTraps.set(
-        this.source,
-        name,
-        value,
-        this.proxy
-      );
+      batch(() => {
+        PreactObjectAdministration.proxyTraps.set(
+          this.source,
+          name,
+          value,
+          this.proxy
+        );
+        this.snapshotAtom.reportChanged();
+      });
     }
   }
   setId(name, v) {
@@ -2257,9 +2716,9 @@ class ModelAdministration extends PreactObjectAdministration {
       getModelAdm(currentValue).detach();
     } else if (Array.isArray(currentValue)) {
       const oldModels = currentValue;
-      const newModelSet = new Set(newModels);
+      const newModelSet = new Set(newModels.map((m) => getSource(m)));
       oldModels.forEach(
-        (child2) => newModelSet.has(child2) || getModelAdm(child2).detach()
+        (child2) => newModelSet.has(getSource(child2)) || getModelAdm(child2).detach()
       );
       this.modelsTraceUnsub.get(name)?.();
     }
@@ -2282,8 +2741,8 @@ class ModelAdministration extends PreactObjectAdministration {
       })
     );
     newModels.forEach((child2) => {
-      const oldModelSet = Array.isArray(currentValue) ? new Set(currentValue) : /* @__PURE__ */ new Set();
-      if (!oldModelSet.has(child2)) {
+      const oldModelSet = Array.isArray(currentValue) ? new Set(currentValue.map((m) => getSource(m))) : /* @__PURE__ */ new Set();
+      if (!oldModelSet.has(getSource(child2))) {
         const internalModel = getModelAdm(child2);
         internalModel.attach(this, name);
       }
@@ -2397,11 +2856,14 @@ class ModelAdministration extends PreactObjectAdministration {
   toJSON() {
     return Object.keys(this.configuration).reduce((json, key) => {
       switch (this.configuration[key].type) {
-        case ModelCfgTypes.state:
-        case ModelCfgTypes.stateShallow:
-        case ModelCfgTypes.stateSignal:
+        case ModelCfgTypes.state: {
+          const value = this.proxy[key];
+          this.observeSnapshotValue(value);
+          json[key] = clone(getSource(value), key);
+          break;
+        }
         case ModelCfgTypes.id:
-          json[key] = clone(getSource(this.proxy[key]));
+          json[key] = clone(getSource(this.proxy[key]), key);
           break;
         case ModelCfgTypes.modelRef:
           const model2 = this.proxy[key];
@@ -2465,8 +2927,6 @@ class ModelAdministration extends PreactObjectAdministration {
         const value = snapshot[key];
         switch (type) {
           case ModelCfgTypes.state:
-          case ModelCfgTypes.stateShallow:
-          case ModelCfgTypes.stateSignal:
             this.proxy[key] = value;
             break;
           case ModelCfgTypes.modelRef:
@@ -2542,6 +3002,7 @@ class ModelAdministration extends PreactObjectAdministration {
   getSnapshot() {
     if (!this.computedSnapshot) {
       this.computedSnapshot = createComputed(() => {
+        this.snapshotAtom.reportObserved();
         const json = this.toJSON();
         configMap.set(json, this.configuration);
         return json;
@@ -2660,6 +3121,73 @@ function createContext(defaultValue) {
     }
   };
 }
+function toObservableTree(value) {
+  return toObservableTreeInternal(value, /* @__PURE__ */ new Set(), "");
+}
+function buildPath(currentPath, key) {
+  if (typeof key === "number") {
+    return `${currentPath}[${key}]`;
+  }
+  return currentPath ? `${currentPath}.${key}` : key;
+}
+function toObservableTreeInternal(value, ancestorPath, path) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (ancestorPath.has(value)) {
+      throw new Error(
+        `r-state-tree: toObservableTree does not support circular references (cycle detected at path "${path}")`
+      );
+    }
+    ancestorPath.add(value);
+    const toWrap = [];
+    for (let i = 0; i < value.length; i++) {
+      const element = value[i];
+      if (Array.isArray(element) || isPlainObject(element)) {
+        toWrap.push({ index: i, element });
+      }
+    }
+    const proxy = observable(value);
+    for (const { index, element } of toWrap) {
+      proxy[index] = toObservableTreeInternal(
+        element,
+        ancestorPath,
+        buildPath(path, index)
+      );
+    }
+    ancestorPath.delete(value);
+    return proxy;
+  }
+  if (isPlainObject(value)) {
+    if (ancestorPath.has(value)) {
+      throw new Error(
+        `r-state-tree: toObservableTree does not support circular references (cycle detected at path "${path}")`
+      );
+    }
+    ancestorPath.add(value);
+    const toWrap = [];
+    const keys = Object.keys(value);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const propValue = value[key];
+      if (Array.isArray(propValue) || isPlainObject(propValue)) {
+        toWrap.push({ key, propValue });
+      }
+    }
+    const proxy = observable(value);
+    for (const { key, propValue } of toWrap) {
+      proxy[key] = toObservableTreeInternal(
+        propValue,
+        ancestorPath,
+        buildPath(path, key)
+      );
+    }
+    ancestorPath.delete(value);
+    return proxy;
+  }
+  return value;
+}
 function makeDecorator(type) {
   return function(value, context) {
     context.metadata[context.name] = type;
@@ -2682,10 +3210,7 @@ const child = makeChildDecorator(childType);
 const modelRef = makeChildDecorator(modelRefType);
 const model = makeDecorator(modelType);
 const id = makeDecorator(idType);
-const state = Object.assign(makeDecorator(stateType), {
-  shallow: makeDecorator(stateShallowType),
-  signal: makeDecorator(stateSignalType)
-});
+const state = makeDecorator(stateType);
 export {
   Model,
   Observable,
@@ -2710,9 +3235,10 @@ export {
   reaction,
   reportChanged,
   reportObserved,
-  signal2 as signal,
+  signal,
   source,
   state,
+  toObservableTree,
   toSnapshot,
   unmount,
   untracked2 as untracked,