r-state-tree 0.6.0 → 0.6.2

package/README.md

@@ -355,66 +355,45 @@ class ListStore extends Store {
 - Models: model fields are shallow-reactive, but values are not auto-wrapped. For raw `@state` arrays/objects, prefer **reassignment** (immutability) so snapshots stay up to date. If you want in-place mutation (`push`, `splice`, `set`, etc.) to trigger updates and snapshot invalidation, store an `observable()` container (or `signal()`) in `@state`.
 - Stores: store fields are shallow-reactive. Use `observable()` containers (or `signal()`) when you want in-place mutations of nested values/collections to trigger updates.
 
-## Observable classes
+### `Observable` base class
 
-For reactive class instances outside the Model/Store system, wrap state with `observable()`:
+For class instances that need to be reactive, extending the `Observable` base class is the supported pattern. This ensures compatibility with ES `#private` fields and built-in brand checks because the observable is created in the base constructor, allowing derived field initializers (including `#private`) to run on the observable.
 
 ```ts
-import { observable, computed, effect } from "r-state-tree";
+import { Observable, effect } from "r-state-tree";
 
-class Counter {
-	state = observable({ count: 0, step: 1 });
+class Counter extends Observable {
+	count = 0; // Public fields are automatically reactive
+	#internal = 0; // Private fields also work perfectly
 
-	@computed get doubled() {
-		return this.state.count * 2;
+	get total() {
+		return this.count + this.#internal;
 	}
 
 	increment() {
-		this.state.count += this.state.step;
+		this.count++;
+		this.#internal++;
 	}
 }
 
 const counter = new Counter();
 
+// Use an effect to track and react to property changes
 effect(() => {
-	console.log("Count:", counter.state.count, "Doubled:", counter.doubled);
+	console.log(`Visible: ${counter.count}, Total: ${counter.total}`);
 });
 
-counter.increment(); // Triggers the effect
-```
-
-### `Observable` base class
-
-For class instances that need to be reactive, extending the `Observable` base class is the supported pattern. This ensures compatibility with ES `#private` fields and built-in brand checks because the Proxy is created in the base constructor, allowing derived field initializers (including `#private`) to run on the Proxy.
-
-```ts
-import { Observable, effect } from "r-state-tree";
-
-class Counter extends Observable {
-	#count = 0; // Correctly works with #private
-
-	get count() {
-		return this.#count;
-	}
-
-	increment() {
-		this.#count++;
-	}
-}
-
-const counter = new Counter();
-effect(() => console.log(counter.count));
 counter.increment();
 ```
 
 > [!IMPORTANT] > **Why `extends Observable`?**
-> ES `#private` fields are brand-checked. If you proxy a class instance _after_ it has been created (post-hoc proxying), or if you return a proxy from a standard constructor, the private state is installed on the original `this`, but methods run with the Proxy as `this`, causing `TypeError: Cannot read private member`.
+> ES `#private` fields are brand-checked. If you wrap a class instance with `observable()` _after_ it has been created (post-hoc wrapping), or if you return an observable from a standard constructor, the private state is installed on the original `this`, but methods run with the observable as `this`, causing `TypeError: Cannot read private member`.
 >
-> `extends Observable` solves this by returning the Proxy from `super()`, so derived classes initialize their private fields directly on the Proxy receiver.
+> `extends Observable` solves this by returning the observable from `super()`, so derived classes initialize their private fields directly on the observable receiver.
 
 ### Limitations of `observable(instance)`
 
-The `observable()` function is selective about what it proxies. It wraps **supported containers** only:
+The `observable()` function is selective about what it makes observable. It wraps **supported containers** only:
 
 - Plain objects
 - Arrays
@@ -425,10 +404,10 @@ The `observable()` function is selective about what it proxies. It wraps **suppo
 
 If you pass an arbitrary class instance, built-in (like `URL`, `RegExp`, `Promise`, or DOM objects), or frozen object to `observable()`, it will **return the object unchanged** and emit a warning in development mode.
 
-This design prevents “silent failure” where a proxied object appears to work but throws `TypeError` when accessing private members or internal slots. For your own classes, use `extends Observable`. For third-party or built-in objects, use composition:
+This design prevents “silent failure” where an observable object appears to work but throws `TypeError` when accessing private members or internal slots. For your own classes, use `extends Observable`. For third-party or built-in objects, use composition:
 
 ```ts
-// ❌ Post-hoc proxying - returns raw URL, not a proxy
+// ❌ Post-hoc wrapping - returns raw URL, not an observable
 const url = observable(new URL("..."));
 
 // ✅ Composition - wrap a container instead
@@ -520,19 +499,19 @@ Create reactive structures outside Stores/Models. Supported: Objects, Arrays, Ma
 
 - Track reads with `effect`/`reaction`. Observables are **shallow**: reads are tracked on the observable container, but nested object mutations do **not** trigger unless you explicitly wrap nested values with `observable()` (or use signals).
 - Access backing values via `source(value)`; check if something is reactive with `isObservable(value)`.
-- Rule of thumb: `source(...)` returns the backing data, **not** a sanitizer—it's only proxy-free if you didn't manually seed proxies into the backing source.
+- Rule of thumb: `source(...)` returns the backing data, **not** a sanitizer—it's only observable-free if you didn't manually seed observables into the backing source.
 - Arrays: reading specific indices (`arr[i]`) or `length` tracks those; common mutators (`push/pop/shift/unshift/splice/reverse/sort/fill`) are reactive; non-index and symbol keys are not reactive.
 
 ### `source()` and structuredClone
 
-`source(x)` returns the backing value behind an observable proxy/container. It is **not** a “proxy stripper”.
+`source(x)` returns the backing value behind an observable. It is **not** a “observable stripper”.
 
 **One-way rule (important):**
 
 - If you mutate through the observable wrapper (e.g. `obj.prop = observable(child)`), r-state-tree stores the **raw backing value** in `source(obj).prop` (unwrap-on-write).
-- If you manually mutate backing sources yourself (e.g. `source(obj).prop = observable(child)`), r-state-tree does **not** sanitize or rewrite your data. In that case, `source(...)` may contain proxies.
+- If you manually mutate backing sources yourself (e.g. `source(obj).prop = observable(child)`), r-state-tree does **not** sanitize or rewrite your data. In that case, `source(...)` may contain observables.
 
-If you need to pass values to APIs that require cloneable data (e.g. `structuredClone`, `postMessage`), avoid seeding observable proxies into backing sources. Prefer reading via `source(...)` and keep your stored values plain/cloneable.
+If you need to pass values to APIs that require cloneable data (e.g. `structuredClone`, `postMessage`), avoid seeding observables into backing sources. Prefer reading via `source(...)` and keep your stored values plain/cloneable.
 
 ```ts
 import { observable, effect, computed, reaction } from "r-state-tree";
@@ -586,7 +565,7 @@ state.count++;
 Native methods that return copies of a collection—such as `Array.prototype.slice`, `filter`, and `concat`, or `Set.prototype.union` and `intersection`—behave according to the **Explicit Architecture**:
 
 - **Raw Return**: The returned container is a plain JavaScript object (raw, non-observable).
-- **Identity Preservation**: Each element in the returned container maintains the same identity it had in the observable source. If an element was a proxy (because it was explicitly owned), it remains a proxy in the raw result.
+- **Identity Preservation**: Each element in the returned container maintains the same identity it had in the observable source. If an element was an observable (because it was explicitly owned), it remains an observable in the raw result.
 
 This ensures that "derived" state is not automatically made reactive, while still allowing observers to maintain reference stability with existing objects in your state tree.
 
@@ -599,7 +578,7 @@ const sliced = arr.slice();
 isObservable(sliced); // false
 
 // Identity is preserved
-sliced[0] === item; // true (same proxy identity)
+sliced[0] === item; // true (same observable identity)
 
 // If you want the result to be reactive, wrap it explicitly
 const reactiveSlice = observable(arr.slice());
@@ -634,8 +613,8 @@ tree.user.tags[0] = "superadmin"; // triggers
 tree.newProp = { foo: 1 };
 isObservable(tree.newProp); // false — not wrapped
 
-// Source is proxy-free and clonable *as long as you don't manually seed proxies*
-// into backing data structures. r-state-tree unwraps proxies on writes performed
+// Source is observable-free and clonable *as long as you don't manually seed observables*
+// into backing data structures. r-state-tree unwraps observables on writes performed
 // through observable containers, but it does not sanitize user-mutated backing sources.
 const snapshot = structuredClone(source(tree));
 ```
@@ -1127,7 +1106,7 @@ const off = onSnapshot(m, (snap) =>
 - Forgetting stable keys for `@child` arrays causes identity churn.
 - Assuming **deep** reactivity: nested plain objects/arrays are not reactive unless you explicitly wrap them (or use `toObservableTree` for initial hydration).
 - Mutating raw `@state` arrays/objects in place (`push`, `obj.x = 1`) and expecting snapshots to update. Snapshots are memoized; use reassignment or store `observable()` containers / `signal()` values in `@state`.
-- Passing observable proxies to third‑party APIs that expect cloneable/serializable values (e.g. `structuredClone`). Use `source(value)` to get the backing value. It will be proxy-free for values written via r-state-tree’s observable APIs (unwrap-on-write), but `source(...)` is **not** guaranteed proxy-free if you manually seed proxies into backing sources.
+- Passing observables to third‑party APIs that expect cloneable/serializable values (e.g. `structuredClone`). Use `source(value)` to get the backing value. It will be observable-free for values written via r-state-tree’s observable APIs (unwrap-on-write), but `source(...)` is **not** guaranteed observable-free if you manually seed observables into backing sources.
 - Creating child stores in constructors: `@child` must be on getters so identity and lifecycle can be managed by the framework.
 - Passing `models` into child stores during mount can create a recursive mount loop. If a child needs parent models, create the child store/model inside `storeDidMount` instead of wiring it through `models` during the mount cycle.
 

package/dist/model/ModelAdministration.d.ts

@@ -16,11 +16,9 @@ export declare class ModelAdministration extends PreactObjectAdministration<any>
     private modelsTraceUnsub;
     private writeInProgress;
     private computedSnapshot;
-    private snapshotAtom;
     private snapshotMap;
     private contextCache;
     parentName: PropertyKey | null;
-    private observeSnapshotValue;
     get parent(): ModelAdministration | null;
     set parent(value: ModelAdministration | null);
     setConfiguration(configurationGetter: () => ModelConfiguration<any>): void;

package/dist/observables/array.d.ts

@@ -4,8 +4,9 @@ import { SignalMap } from "./internal/NodeMap";
 export declare class ArrayAdministration<T> extends Administration<T[]> {
     valuesMap: SignalMap<number>;
     keysAtom: AtomNode;
-    private explicitObservables;
-    private syncExplicitObservablesFromSource;
+    private observableSources;
+    private rawSources;
+    private trackValue;
     static proxyTraps: ProxyHandler<Array<unknown>>;
     static methods: Partial<{
         [K in keyof typeof Array.prototype as (typeof Array.prototype)[K] extends Function ? K : never]: (typeof Array.prototype)[K];

package/dist/observables/object.d.ts

@@ -7,7 +7,7 @@ export declare class ObjectAdministration<T extends object> extends Administrati
     hasMap: AtomMap<PropertyKey>;
     valuesMap: SignalMap<PropertyKey>;
     computedMap: Map<PropertyKey, ComputedNode<T[keyof T]>>;
-    types: Map<PropertyKey, PropertyType | null>;
+    types: Map<PropertyKey, PropertyType>;
     isWriting: boolean;
     static proxyTraps: ProxyHandler<object>;
     constructor(source?: T);

package/dist/r-state-tree.cjs

@@ -72,14 +72,7 @@ function getPropertyType(key, obj) {
   if (descriptor?.value && typeof descriptor.value === "function") {
     return "action";
   }
-  const isAccessor = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
   if (!hasMetadata) {
-    if (descriptor?.get) {
-      return "computed";
-    }
-    if (isAccessor) {
-      return null;
-    }
     return "observable";
   }
   const metadata = obj.constructor[Symbol.metadata];
@@ -96,7 +89,7 @@ function getPropertyType(key, obj) {
         return "observable";
     }
   }
-  return isAccessor ? null : "observable";
+  return "observable";
 }
 function getPropertyDescriptor$1(obj, key) {
   let node = obj;
@@ -315,9 +308,7 @@ class ObjectAdministration extends Administration {
     return Reflect.get(this.source, key, this.proxy);
   }
   set(key, value) {
-    return signalsCore.batch(() => {
-      return Reflect.set(this.source, key, value, this.proxy);
-    });
+    return signalsCore.batch(() => Reflect.set(this.source, key, value, this.proxy));
   }
   getComputed(key) {
     if (!this.computedMap) this.computedMap = /* @__PURE__ */ new Map();
@@ -360,55 +351,42 @@ class ObjectAdministration extends Administration {
   }
   read(key, receiver = this.proxy) {
     const type = this.getType(key);
-    if (type === null) {
+    if (type === "computed") {
+      if (receiver === this.proxy) {
+        return this.callComputed(key);
+      }
+      this.atom.reportObserved();
       return Reflect.get(this.source, key, receiver);
     }
-    switch (type) {
-      case "observable":
-      case "action": {
-        if (key in this.source) {
-          this.valuesMap.reportObserved(key, this.source[key]);
-        }
-        this.atom.reportObserved();
-        if (this.atom.observing) {
-          this.hasMap.reportObserved(key);
-        }
-        if (type === "observable") {
-          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;
-            }
-          }
+    if (key in this.source) {
+      this.valuesMap.reportObserved(key, this.source[key]);
+    }
+    this.atom.reportObserved();
+    if (this.atom.observing) {
+      this.hasMap.reportObserved(key);
+    }
+    if (type === "observable") {
+      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;
         }
-        return getAction(
-          Reflect.get(this.source, key, receiver)
-        );
-      }
-      case "computed": {
-        if (receiver === this.proxy) {
-          return this.callComputed(key);
+        const existingAdm = getAdministration(value);
+        if (existingAdm) {
+          return existingAdm.proxy;
         }
-        this.atom.reportObserved();
-        return Reflect.get(this.source, key, receiver);
       }
-      default:
-        throw new Error(`unknown type passed to configure`);
+      return value;
     }
+    return getAction(
+      Reflect.get(this.source, key, receiver)
+    );
   }
   explicitObservables = /* @__PURE__ */ new Set();
   write(key, newValue) {
     const type = this.getType(key);
-    if (type === null) {
-      return this.set(key, newValue);
-    }
     if (type === "computed") {
       return signalsCore.batch(() => this.set(key, newValue));
     }
@@ -592,8 +570,24 @@ function createListener(callback) {
   };
   return listener;
 }
+function internalCreateComputed(fn) {
+  const version = signalsCore.signal(0);
+  const c = signalsCore.computed(
+    () => {
+      version.value;
+      return fn();
+    },
+    {
+      unwatched() {
+        version.value++;
+      }
+    }
+  );
+  return { c, version };
+}
 function createComputed(fn, context = null) {
-  const c = signalsCore.computed(context ? fn.bind(context) : fn);
+  const bound = context ? fn.bind(context) : fn;
+  const { c } = internalCreateComputed(bound);
   return {
     node: c,
     get() {
@@ -602,6 +596,7 @@ function createComputed(fn, context = null) {
     clear: () => {
       signalsCore.untracked(() => {
         c._value = void 0;
+        c._globalVersion = -1;
       });
     }
   };
@@ -617,7 +612,7 @@ function computed(value, context) {
     context.metadata[context.name] = { type: "computed" };
     return value;
   }
-  return signalsCore.computed(value);
+  return internalCreateComputed(value).c;
 }
 function source(obj) {
   return getSource(obj);
@@ -683,17 +678,7 @@ class CollectionAdministration extends Administration {
         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;
       }
       return val;
     }
@@ -819,9 +804,6 @@ class CollectionAdministration extends Administration {
     const target = getSource(value);
     if (isObservable(value)) {
       this.trackExplicitObservable(target);
-    } else {
-      this.untrackExplicitObservable(target);
-      this.untrackExplicitObservable(value);
     }
     if (!this.hasEntry(value)) {
       this.source.add(target);
@@ -1054,15 +1036,40 @@ function isArrayIndexKey(key) {
   return Number.isInteger(num) && num >= 0 && num < 4294967295 && // 2^32 - 1
   String(num) === keyStr;
 }
+function reportConflict() {
+  if (process.env.NODE_ENV !== "production") {
+    throw new Error(
+      "r-state-tree: Cannot assign the same object as both observable and raw source in the same array. The value will be treated as observable."
+    );
+  }
+}
 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];
+  /**
+   * Parent-based ownership tracking: sources assigned as observable.
+   * Unlike index-based tracking, this doesn't require updates on reorder ops.
+   */
+  observableSources = /* @__PURE__ */ new WeakSet();
+  rawSources = /* @__PURE__ */ new WeakSet();
+  /**
+   * Track a value being assigned to this array.
+   * Detects conflicts if same source is assigned as both observable and raw.
+   */
+  trackValue(value) {
+    if (value && typeof value === "object") {
+      const source2 = getSource(value);
       if (isObservable(value)) {
-        this.explicitObservables.add(i);
+        if (this.rawSources.has(source2)) {
+          reportConflict();
+        }
+        this.observableSources.add(source2);
+      } else {
+        if (this.observableSources.has(source2)) {
+          reportConflict();
+        } else {
+          this.rawSources.add(source2);
+        }
       }
     }
   }
@@ -1119,7 +1126,6 @@ class ArrayAdministration extends Administration {
       if (result && had && isIndex) {
         const index = Number(name);
         adm.onArrayChanged(true, index, 1);
-        adm.explicitObservables.delete(index);
       }
       return result;
     },
@@ -1145,16 +1151,12 @@ class ArrayAdministration extends Administration {
   static methods = {
     fill(value, start, end) {
       const adm = getAdministration(this);
-      const shouldTrack = isObservable(value);
+      adm.trackValue(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);
       }
@@ -1193,41 +1195,24 @@ 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.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 pairs = adm.source.map((stored, i) => ({
+        value: this[i],
+        stored
+      }));
       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;
@@ -1243,17 +1228,7 @@ class ArrayAdministration extends Administration {
     flat: createCopyMethod("flat"),
     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;
     },
@@ -1287,23 +1262,20 @@ class ArrayAdministration extends Administration {
   _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;
+      if (this.observableSources.has(value)) {
+        const adm = getAdministration(value);
+        if (adm.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.`
+              );
             }
+            return value;
           }
-          return existingAdm.proxy;
         }
+        return adm.proxy;
       }
     }
     return value;
@@ -1312,23 +1284,17 @@ class ArrayAdministration extends Administration {
     const values = this.source;
     const targetValue = getSource(newValue);
     const oldLength = values.length;
+    this.trackValue(newValue);
     let changed = true;
     if (index < oldLength) {
       const oldValue = values[index];
-      const oldExplicit = this.explicitObservables.has(index);
-      const newExplicit = isObservable(newValue);
-      changed = !isObservable(oldValue) && oldExplicit !== newExplicit || (isObservable(oldValue) ? newValue !== oldValue : targetValue !== oldValue);
+      changed = 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 {
-      this.explicitObservables.delete(index);
-    }
     this.onArrayChanged(lengthChanged, index, 1);
     return true;
   }
@@ -1349,15 +1315,6 @@ class ArrayAdministration extends Administration {
     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);
@@ -1367,13 +1324,10 @@ class ArrayAdministration extends Administration {
   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);
-        }
+        this.trackValue(newItems[i]);
       }
     }
     if (index === void 0) index = 0;
@@ -1386,31 +1340,10 @@ class ArrayAdministration extends Administration {
     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) {
-      const shift2 = (newItems?.length ?? 0) - deleteCount;
-      const reindexing = shift2 !== 0 && index + deleteCount < length;
+      const shift = (newItems?.length ?? 0) - deleteCount;
+      const reindexing = shift !== 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);
     }
@@ -2437,19 +2370,7 @@ function getIdKey(Ctor) {
 function getModelRefSnapshot(modelRef2) {
   const Ctor = Object.getPrototypeOf(modelRef2).constructor;
   const idKey = getIdKey(Ctor);
-  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 };
+  return idKey ? { [idKey]: getIdentifier(modelRef2) } : null;
 }
 function getSnapshotId(snapshot, Ctor) {
   const idKey = getIdKey(Ctor);
@@ -2573,60 +2494,9 @@ 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;
@@ -2662,7 +2532,6 @@ class ModelAdministration extends PreactObjectAdministration {
           value,
           this.proxy
         );
-        this.snapshotAtom.reportChanged();
       });
     }
   }
@@ -2858,9 +2727,7 @@ class ModelAdministration extends PreactObjectAdministration {
     return Object.keys(this.configuration).reduce((json, key) => {
       switch (this.configuration[key].type) {
         case ModelCfgTypes.state: {
-          const value = this.proxy[key];
-          this.observeSnapshotValue(value);
-          json[key] = clone(getSource(value), key);
+          json[key] = clone(this.proxy[key], key);
           break;
         }
         case ModelCfgTypes.id:
@@ -3003,7 +2870,6 @@ 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;

package/dist/r-state-tree.js

@@ -1,4 +1,4 @@
-import { batch, signal as signal$1, Signal, computed as computed$1, untracked, effect } from "@preact/signals-core";
+import { batch, signal as signal$1, Signal, untracked, effect, computed as computed$1 } 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;
@@ -71,14 +71,7 @@ function getPropertyType(key, obj) {
   if (descriptor?.value && typeof descriptor.value === "function") {
     return "action";
   }
-  const isAccessor = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
   if (!hasMetadata) {
-    if (descriptor?.get) {
-      return "computed";
-    }
-    if (isAccessor) {
-      return null;
-    }
     return "observable";
   }
   const metadata = obj.constructor[Symbol.metadata];
@@ -95,7 +88,7 @@ function getPropertyType(key, obj) {
         return "observable";
     }
   }
-  return isAccessor ? null : "observable";
+  return "observable";
 }
 function getPropertyDescriptor$1(obj, key) {
   let node = obj;
@@ -314,9 +307,7 @@ class ObjectAdministration extends Administration {
     return Reflect.get(this.source, key, this.proxy);
   }
   set(key, value) {
-    return batch(() => {
-      return Reflect.set(this.source, key, value, this.proxy);
-    });
+    return batch(() => Reflect.set(this.source, key, value, this.proxy));
   }
   getComputed(key) {
     if (!this.computedMap) this.computedMap = /* @__PURE__ */ new Map();
@@ -359,55 +350,42 @@ class ObjectAdministration extends Administration {
   }
   read(key, receiver = this.proxy) {
     const type = this.getType(key);
-    if (type === null) {
+    if (type === "computed") {
+      if (receiver === this.proxy) {
+        return this.callComputed(key);
+      }
+      this.atom.reportObserved();
       return Reflect.get(this.source, key, receiver);
     }
-    switch (type) {
-      case "observable":
-      case "action": {
-        if (key in this.source) {
-          this.valuesMap.reportObserved(key, this.source[key]);
-        }
-        this.atom.reportObserved();
-        if (this.atom.observing) {
-          this.hasMap.reportObserved(key);
-        }
-        if (type === "observable") {
-          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;
-            }
-          }
+    if (key in this.source) {
+      this.valuesMap.reportObserved(key, this.source[key]);
+    }
+    this.atom.reportObserved();
+    if (this.atom.observing) {
+      this.hasMap.reportObserved(key);
+    }
+    if (type === "observable") {
+      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;
         }
-        return getAction(
-          Reflect.get(this.source, key, receiver)
-        );
-      }
-      case "computed": {
-        if (receiver === this.proxy) {
-          return this.callComputed(key);
+        const existingAdm = getAdministration(value);
+        if (existingAdm) {
+          return existingAdm.proxy;
         }
-        this.atom.reportObserved();
-        return Reflect.get(this.source, key, receiver);
       }
-      default:
-        throw new Error(`unknown type passed to configure`);
+      return value;
     }
+    return getAction(
+      Reflect.get(this.source, key, receiver)
+    );
   }
   explicitObservables = /* @__PURE__ */ new Set();
   write(key, newValue) {
     const type = this.getType(key);
-    if (type === null) {
-      return this.set(key, newValue);
-    }
     if (type === "computed") {
       return batch(() => this.set(key, newValue));
     }
@@ -591,8 +569,24 @@ function createListener(callback) {
   };
   return listener;
 }
+function internalCreateComputed(fn) {
+  const version = signal$1(0);
+  const c = computed$1(
+    () => {
+      version.value;
+      return fn();
+    },
+    {
+      unwatched() {
+        version.value++;
+      }
+    }
+  );
+  return { c, version };
+}
 function createComputed(fn, context = null) {
-  const c = computed$1(context ? fn.bind(context) : fn);
+  const bound = context ? fn.bind(context) : fn;
+  const { c } = internalCreateComputed(bound);
   return {
     node: c,
     get() {
@@ -601,6 +595,7 @@ function createComputed(fn, context = null) {
     clear: () => {
       untracked(() => {
         c._value = void 0;
+        c._globalVersion = -1;
       });
     }
   };
@@ -616,7 +611,7 @@ function computed(value, context) {
     context.metadata[context.name] = { type: "computed" };
     return value;
   }
-  return computed$1(value);
+  return internalCreateComputed(value).c;
 }
 function source(obj) {
   return getSource(obj);
@@ -682,17 +677,7 @@ class CollectionAdministration extends Administration {
         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;
       }
       return val;
     }
@@ -818,9 +803,6 @@ class CollectionAdministration extends Administration {
     const target = getSource(value);
     if (isObservable(value)) {
       this.trackExplicitObservable(target);
-    } else {
-      this.untrackExplicitObservable(target);
-      this.untrackExplicitObservable(value);
     }
     if (!this.hasEntry(value)) {
       this.source.add(target);
@@ -1053,15 +1035,40 @@ function isArrayIndexKey(key) {
   return Number.isInteger(num) && num >= 0 && num < 4294967295 && // 2^32 - 1
   String(num) === keyStr;
 }
+function reportConflict() {
+  if (process.env.NODE_ENV !== "production") {
+    throw new Error(
+      "r-state-tree: Cannot assign the same object as both observable and raw source in the same array. The value will be treated as observable."
+    );
+  }
+}
 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];
+  /**
+   * Parent-based ownership tracking: sources assigned as observable.
+   * Unlike index-based tracking, this doesn't require updates on reorder ops.
+   */
+  observableSources = /* @__PURE__ */ new WeakSet();
+  rawSources = /* @__PURE__ */ new WeakSet();
+  /**
+   * Track a value being assigned to this array.
+   * Detects conflicts if same source is assigned as both observable and raw.
+   */
+  trackValue(value) {
+    if (value && typeof value === "object") {
+      const source2 = getSource(value);
       if (isObservable(value)) {
-        this.explicitObservables.add(i);
+        if (this.rawSources.has(source2)) {
+          reportConflict();
+        }
+        this.observableSources.add(source2);
+      } else {
+        if (this.observableSources.has(source2)) {
+          reportConflict();
+        } else {
+          this.rawSources.add(source2);
+        }
       }
     }
   }
@@ -1118,7 +1125,6 @@ class ArrayAdministration extends Administration {
       if (result && had && isIndex) {
         const index = Number(name);
         adm.onArrayChanged(true, index, 1);
-        adm.explicitObservables.delete(index);
       }
       return result;
     },
@@ -1144,16 +1150,12 @@ class ArrayAdministration extends Administration {
   static methods = {
     fill(value, start, end) {
       const adm = getAdministration(this);
-      const shouldTrack = isObservable(value);
+      adm.trackValue(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);
       }
@@ -1192,41 +1194,24 @@ 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.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 pairs = adm.source.map((stored, i) => ({
+        value: this[i],
+        stored
+      }));
       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;
@@ -1242,17 +1227,7 @@ class ArrayAdministration extends Administration {
     flat: createCopyMethod("flat"),
     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;
     },
@@ -1286,23 +1261,20 @@ class ArrayAdministration extends Administration {
   _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;
+      if (this.observableSources.has(value)) {
+        const adm = getAdministration(value);
+        if (adm.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.`
+              );
             }
+            return value;
           }
-          return existingAdm.proxy;
         }
+        return adm.proxy;
       }
     }
     return value;
@@ -1311,23 +1283,17 @@ class ArrayAdministration extends Administration {
     const values = this.source;
     const targetValue = getSource(newValue);
     const oldLength = values.length;
+    this.trackValue(newValue);
     let changed = true;
     if (index < oldLength) {
       const oldValue = values[index];
-      const oldExplicit = this.explicitObservables.has(index);
-      const newExplicit = isObservable(newValue);
-      changed = !isObservable(oldValue) && oldExplicit !== newExplicit || (isObservable(oldValue) ? newValue !== oldValue : targetValue !== oldValue);
+      changed = 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 {
-      this.explicitObservables.delete(index);
-    }
     this.onArrayChanged(lengthChanged, index, 1);
     return true;
   }
@@ -1348,15 +1314,6 @@ class ArrayAdministration extends Administration {
     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);
@@ -1366,13 +1323,10 @@ class ArrayAdministration extends Administration {
   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);
-        }
+        this.trackValue(newItems[i]);
       }
     }
     if (index === void 0) index = 0;
@@ -1385,31 +1339,10 @@ class ArrayAdministration extends Administration {
     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) {
-      const shift2 = (newItems?.length ?? 0) - deleteCount;
-      const reindexing = shift2 !== 0 && index + deleteCount < length;
+      const shift = (newItems?.length ?? 0) - deleteCount;
+      const reindexing = shift !== 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);
     }
@@ -2436,19 +2369,7 @@ function getIdKey(Ctor) {
 function getModelRefSnapshot(modelRef2) {
   const Ctor = Object.getPrototypeOf(modelRef2).constructor;
   const idKey = getIdKey(Ctor);
-  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 };
+  return idKey ? { [idKey]: getIdentifier(modelRef2) } : null;
 }
 function getSnapshotId(snapshot, Ctor) {
   const idKey = getIdKey(Ctor);
@@ -2572,60 +2493,9 @@ 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;
@@ -2661,7 +2531,6 @@ class ModelAdministration extends PreactObjectAdministration {
           value,
           this.proxy
         );
-        this.snapshotAtom.reportChanged();
       });
     }
   }
@@ -2857,9 +2726,7 @@ class ModelAdministration extends PreactObjectAdministration {
     return Object.keys(this.configuration).reduce((json, key) => {
       switch (this.configuration[key].type) {
         case ModelCfgTypes.state: {
-          const value = this.proxy[key];
-          this.observeSnapshotValue(value);
-          json[key] = clone(getSource(value), key);
+          json[key] = clone(this.proxy[key], key);
           break;
         }
         case ModelCfgTypes.id:
@@ -3002,7 +2869,6 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "r-state-tree",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "reactive state management library",
   "main": "dist/r-state-tree.cjs",
   "module": "dist/r-state-tree.js",

package/dist/computedProxy.d.ts

@@ -1,2 +0,0 @@
-import type { ComputedNode } from "./observables";
-export default function <T extends Record<PropertyKey, any>>(computed: ComputedNode<T>): T;