@jbrowse/mobx-state-tree 6.6.1 → 6.7.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [6.7.0](https://github.com/GMOD/mobx-state-tree/compare/v6.6.1...v6.7.0) (2026-09-30)
+
+### Bug Fixes
+
+- A dead node's never-read child reads as a dead instance ([a6c430e](https://github.com/GMOD/mobx-state-tree/commit/a6c430e926ec31fe226a10cafff6e2ea0add4012))
+- Exempt only never-created dead nodes; ADR 0008 ([d15fb5b](https://github.com/GMOD/mobx-state-tree/commit/d15fb5b99399d7844af910db689cbb5c403ddbc3))
+- A never-read node dies as if it had been read ([3ffffae](https://github.com/GMOD/mobx-state-tree/commit/3ffffae9f5f44e7c5ea1573364da2ce6224ff288))
+- Fail clearly, before damaging the tree, on impossible attaches ([25e0dff](https://github.com/GMOD/mobx-state-tree/commit/25e0dffd31b02c57ec31195685e3551de7167bb0))
+- Destroy children that hooks add while a node is built at death ([743f887](https://github.com/GMOD/mobx-state-tree/commit/743f887f0a749f5dff727c86429c5ffb7ce4b726))
+
+### Styling
+
+- Format ADR 0008 ([4290662](https://github.com/GMOD/mobx-state-tree/commit/42906620c1c6fc58526251310468d0012f446159))
+
 ## [6.6.1](https://github.com/GMOD/mobx-state-tree/compare/v6.6.0...v6.6.1) (2026-09-25)
 
 ### Performance Improvements

package/dist/index.d.ts

@@ -624,6 +624,13 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     clearParent(): void;
     notifyDetachOf(subject: AnyObjectNode): void;
     private notifyChildrenOfDetach;
+    /**
+     * @internal
+     * @hidden
+     * A node that died inside a tree is its own root and has no identifier
+     * cache, so attaching it, or attaching anything to it, cannot work.
+     */
+    assertAttachable(): IdentifierCache;
     setParent(newParent: AnyObjectNode, subpath: string): void;
     protected fireHook(name: Hook): void;
     private _snapshotUponDeath?;

package/dist/mobx-state-tree.cjs

@@ -468,7 +468,7 @@ function resolveIdentifier(type, target, identifier) {
     assertIsType(type, 1);
     assertIsStateTreeNode(target, 2);
     assertIsValidIdentifier(identifier, 3);
-    const node = getStateTreeNode(target).root.identifierCache.resolve(type, normalizeIdentifier(identifier));
+    const node = getStateTreeNode(target).root.identifierCache?.resolve(type, normalizeIdentifier(identifier));
     return node?.value;
 }
 /**
@@ -1211,7 +1211,7 @@ class ObjectNode extends BaseNode {
         // addNodeToCache no-ops without an identifier attribute, and reaching the
         // root to ask it is a walk up the whole parent chain
         if (this.identifierAttribute) {
-            const cache = parent ? parent.root.identifierCache : this.identifierCache;
+            const cache = parent ? parent.assertAttachable() : this.identifierCache;
             cache.addNodeToCache(this);
         }
     }
@@ -1222,8 +1222,11 @@ class ObjectNode extends BaseNode {
         }
     }
     createObservableInstance(fireHooks = true) {
+        const diedUncreated = this.state === NodeLifeCycle.DEAD &&
+            this._observableInstanceState ===
+                ObservableInstanceLifecycle.UNINITIALIZED;
         if (devMode()) {
-            if (this.state !== NodeLifeCycle.INITIALIZING) {
+            if (!diedUncreated && this.state !== NodeLifeCycle.INITIALIZING) {
                 // istanbul ignore next
                 throw fail("assertion failed: the creation of the observable instance must be done on the initializing phase");
             }
@@ -1276,6 +1279,9 @@ class ObjectNode extends BaseNode {
         // subscribes to never pays for a full-tree snapshot at creation. keepAlive
         // on _snapshotComputed preserves snapshot referential stability without it.
         this._childNodes = EMPTY_OBJECT;
+        if (diedUncreated) {
+            return;
+        }
         this.state = NodeLifeCycle.CREATED;
         if (fireHooks) {
             this.fireHook(Hook.afterCreate);
@@ -1330,6 +1336,19 @@ class ObjectNode extends BaseNode {
             child.notifyDetachOf(subject);
         }
     }
+    /**
+     * @internal
+     * @hidden
+     * A node that died inside a tree is its own root and has no identifier
+     * cache, so attaching it, or attaching anything to it, cannot work.
+     */
+    assertAttachable() {
+        const cache = this.root.identifierCache;
+        if (!cache) {
+            throw fail(`'${this}' is no longer part of a state tree, so it cannot be attached to one or have nodes attached to it.`);
+        }
+        return cache;
+    }
     setParent(newParent, subpath) {
         const parentChanged = newParent !== this.parent;
         const subpathChanged = subpath !== this.subpath;
@@ -1358,9 +1377,9 @@ class ObjectNode extends BaseNode {
             }
         }
         if (parentChanged) {
-            // attach to new parent
+            this.assertAttachable();
             this.environment = undefined; // will use root's
-            newParent.root.identifierCache.mergeCache(this);
+            newParent.assertAttachable().mergeCache(this);
             this.baseSetParent(newParent, subpath);
             this.fireHook(Hook.afterAttach);
         }
@@ -1556,13 +1575,33 @@ class ObjectNode extends BaseNode {
         addHiddenFinalProp(this.storedValue, "toJSON", toJSON);
     }
     aboutToDie() {
+        const wasUninitialized = this._observableInstanceState ===
+            ObservableInstanceLifecycle.UNINITIALIZED;
+        const children = this.getChildren();
+        if (wasUninitialized &&
+            (this.hasSnapshotPostProcessor ||
+                children.some(child => child instanceof ObjectNode &&
+                    child._observableInstanceState !==
+                        ObservableInstanceLifecycle.UNINITIALIZED))) {
+            this.createObservableInstanceIfNeeded();
+        }
+        for (const node of children) {
+            if (node.isAlive) {
+                node.aboutToDie();
+            }
+        }
         if (this._observableInstanceState ===
             ObservableInstanceLifecycle.UNINITIALIZED) {
             return;
         }
-        this.getChildren().forEach(node => {
-            node.aboutToDie();
-        });
+        if (wasUninitialized) {
+            const walked = new Set(children);
+            for (const node of this.getChildren()) {
+                if (node.isAlive && !walked.has(node)) {
+                    node.aboutToDie();
+                }
+            }
+        }
         // beforeDestroy should run before the disposers since else we could end up in a situation where
         // a disposer added with addDisposer at this stage (beforeDestroy) is actually never released
         this.baseAboutToDie();
@@ -1859,12 +1898,16 @@ class ComplexType extends BaseType {
             current.setParent(parent, subpath);
             return current;
         }
+        const newNode = getStateTreeNodeSafe(newValue);
+        if (newNode) {
+            newNode.assertAttachable();
+            if (!current.isDetaching && newNode.isWithin(current)) {
+                throw fail(`Cannot assign ${newNode} to '${parent.path}/${subpath}': it is part of ${current}, which it would replace.`);
+            }
+        }
         // current node cannot be recycled in any way
         current.die(); // noop if detaching
-        // attempt to reuse the new one
-        if (isStateTreeNode(newValue) && this.isAssignableFrom(getType(newValue))) {
-            // newValue is a Node as well, move it here..
-            const newNode = getStateTreeNode(newValue);
+        if (newNode && this.isAssignableFrom(newNode.type)) {
             newNode.setParent(parent, subpath);
             return newNode;
         }