@jbrowse/mobx-state-tree 6.6.0 → 6.7.0

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [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
+
+- Reconcile children in linear time ([530e27f](https://github.com/GMOD/mobx-state-tree/commit/530e27f20046ba449d45c2724106fcb5b4133e06))
+
+### Tests
+
+- Typecheck the reconcile tests; add pnpm typecheck to the verification norm ([a23e4f3](https://github.com/GMOD/mobx-state-tree/commit/a23e4f34f718dfd398b696ca5e36be88bbe52454))
+
 ## [6.6.0](https://github.com/GMOD/mobx-state-tree/compare/v6.5.2...v6.6.0) (2026-09-24)
 
 ### Bug Fixes

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;
         }
@@ -4469,98 +4512,174 @@ function array(subtype) {
  */
 function reconcileArrayChildren(parent, childType, oldNodes, newValues, firstNewPath) {
     let nothingChanged = true;
-    // When the element type is a plain model with an identifier, index the old
-    // nodes by id so a moved / replaced child is matched in O(1) instead of the
-    // linear scan in the reorder branch below. This turns a full array
-    // replacement (the common "load new data" case) from O(n^2) into O(n). Types
-    // whose id extraction needs type-specific preprocessing (union,
-    // snapshotProcessor, late, ...) are intentionally excluded: areSame must run
-    // `is()` before their id check, so they stay on the scan path.
-    // With at most one old node the scan below is already O(1), so building the
-    // index would only add a Map allocation to every single-element write.
-    let idIndex;
-    if (oldNodes.length > 1 &&
-        childType instanceof ModelType &&
-        childType.identifierAttribute) {
-        const byId = new Map();
-        for (const n of oldNodes) {
-            if (n instanceof ObjectNode && n.identifier !== null) {
-                byId.set(n.identifier, n);
-            }
-        }
-        idIndex = { attr: childType.identifierAttribute, byId };
-    }
-    for (let i = 0;; i++) {
-        const hasNewNode = i <= newValues.length - 1;
-        const oldNode = oldNodes[i];
-        let newValue = hasNewNode ? newValues[i] : undefined;
+    const result = [];
+    // every old node before `next` is claimed
+    const claimed = new Uint8Array(oldNodes.length);
+    let next = 0;
+    let finder;
+    for (let i = 0; i < newValues.length; i++) {
+        while (claimed[next]) {
+            next++;
+        }
+        const oldNode = oldNodes[next];
+        let newValue = newValues[i];
         const newPath = `${firstNewPath + i}`;
         // for some reason, instead of newValue we got a node, fallback to the storedValue
         // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
         if (isNode(newValue)) {
             newValue = newValue.storedValue;
         }
-        if (!oldNode && !hasNewNode) {
-            // both are empty, end
-            break;
+        if (!oldNode) {
+            if (isStateTreeNode(newValue) &&
+                getStateTreeNode(newValue).parent === parent) {
+                // this node is owned by this parent, but not in the reconcilable set, so it must be double
+                throw fail(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent.path}/${newPath}', but it lives already at '${getStateTreeNode(newValue).path}'`);
+            }
+            nothingChanged = false;
+            result.push(valueAsNode(childType, parent, newPath, newValue));
+        }
+        else if (areSame(oldNode, newValue)) {
+            claimed[next] = 1;
+            result.push(valueAsNode(childType, parent, newPath, newValue, oldNode));
         }
-        else if (oldNode && !hasNewNode) {
-            // new one does not exists
+        else {
             nothingChanged = false;
-            oldNodes.splice(i, 1);
+            // a single-element write scans one node, cheaper than building an index
+            const j = oldNodes.length > 1
+                ? (finder ??= new ReuseFinder(childType, oldNodes, claimed)).find(newValue, next)
+                : scanForSame(oldNodes, claimed, next, newValue);
+            let oldMatch;
+            if (j >= 0) {
+                claimed[j] = 1;
+                oldMatch = oldNodes[j];
+            }
+            result.push(valueAsNode(childType, parent, newPath, newValue, oldMatch));
+        }
+    }
+    for (let j = next; j < oldNodes.length; j++) {
+        if (!claimed[j]) {
+            nothingChanged = false;
+            const oldNode = oldNodes[j];
             if (oldNode instanceof ObjectNode) {
                 // since it is going to be returned by pop/splice/shift better create it before killing it
                 // so it doesn't end up in an undead state
                 oldNode.createObservableInstanceIfNeeded();
             }
             oldNode.die();
-            i--;
         }
-        else if (!oldNode) {
-            // there is no old node, create it
-            // check if already belongs to the same parent. if so, avoid pushing item in. only swapping can occur.
-            if (isStateTreeNode(newValue) &&
-                getStateTreeNode(newValue).parent === parent) {
-                // this node is owned by this parent, but not in the reconcilable set, so it must be double
-                throw fail(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent.path}/${newPath}', but it lives already at '${getStateTreeNode(newValue).path}'`);
-            }
-            nothingChanged = false;
-            const newNode = valueAsNode(childType, parent, newPath, newValue);
-            oldNodes.splice(i, 0, newNode);
+    }
+    return nothingChanged ? null : result;
+}
+function scanForSame(oldNodes, claimed, from, value) {
+    for (let j = from; j < oldNodes.length; j++) {
+        if (!claimed[j] && areSame(oldNodes[j], value)) {
+            return j;
         }
-        else if (areSame(oldNode, newValue)) {
-            // both are the same, reconcile
-            oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
+    }
+    return -1;
+}
+/**
+ * Picks the old node the reorder branch reuses: the first unclaimed one
+ * `areSame` holds for. `areSame` reduces to an equality — node identity for a
+ * live node, the old node's snapshot for anything else — except where the
+ * value is a plain object and the old node carries an identifier, where it
+ * runs `is()` before matching ids. So only that case scans, and an identified
+ * plain model looks its id up instead, as ADR 0001 records.
+ */
+class ReuseFinder {
+    oldNodes;
+    claimed;
+    idAttribute;
+    byId;
+    byNode;
+    bySnapshot;
+    anyIdentified;
+    constructor(childType, oldNodes, claimed) {
+        this.oldNodes = oldNodes;
+        this.claimed = claimed;
+        this.idAttribute =
+            childType instanceof ModelType ? childType.identifierAttribute : undefined;
+    }
+    find(value, next) {
+        let j;
+        if (this.idAttribute && isPlainObject(value)) {
+            j =
+                this.idIndex(next).get(normalizeIdentifier(value[this.idAttribute])) ??
+                    -1;
+        }
+        else if (isStateTreeNode(value)) {
+            j = this.nodeIndex(next).get(getStateTreeNode(value)) ?? -1;
+        }
+        else if (!isPlainObject(value) || !this.hasIdentifiedNode(next)) {
+            j = this.firstWithSnapshot(value, next);
         }
         else {
-            // nothing to do, try to reorder: find a candidate old node to reuse
-            let oldMatch = undefined;
-            if (idIndex && isPlainObject(newValue)) {
-                // for an identified element type a plain-object snapshot can only match
-                // by id (it is never a live node, and snapshot-reference equality still
-                // implies the same id), so a miss means "nothing to reuse" without
-                // scanning. areSame still verifies the single candidate.
-                const candidate = idIndex.byId.get(normalizeIdentifier(newValue[idIndex.attr]));
-                const j = candidate ? oldNodes.indexOf(candidate, i) : -1;
-                if (j >= i && areSame(oldNodes[j], newValue)) {
-                    oldMatch = oldNodes.splice(j, 1)[0];
+            return scanForSame(this.oldNodes, this.claimed, next, value);
+        }
+        return j >= 0 && !this.claimed[j] && areSame(this.oldNodes[j], value)
+            ? j
+            : -1;
+    }
+    // last one wins on a duplicate id, even when it is already claimed
+    idIndex(next) {
+        if (!this.byId) {
+            this.byId = new Map();
+            for (let j = next; j < this.oldNodes.length; j++) {
+                const node = this.oldNodes[j];
+                if (node instanceof ObjectNode && node.identifier !== null) {
+                    this.byId.set(node.identifier, j);
                 }
             }
-            else {
-                // find a possible candidate to reuse
-                for (let j = i; j < oldNodes.length; j++) {
-                    if (areSame(oldNodes[j], newValue)) {
-                        oldMatch = oldNodes.splice(j, 1)[0];
-                        break;
-                    }
+        }
+        return this.byId;
+    }
+    nodeIndex(next) {
+        if (!this.byNode) {
+            this.byNode = new Map();
+            for (let j = next; j < this.oldNodes.length; j++) {
+                this.byNode.set(this.oldNodes[j], j);
+            }
+        }
+        return this.byNode;
+    }
+    hasIdentifiedNode(next) {
+        if (this.anyIdentified === undefined) {
+            this.anyIdentified = this.oldNodes
+                .slice(next)
+                .some(node => node instanceof ObjectNode &&
+                node.identifier !== null &&
+                !!node.identifierAttribute);
+        }
+        return this.anyIdentified;
+    }
+    firstWithSnapshot(value, next) {
+        if (!this.bySnapshot) {
+            const first = new Map();
+            const nextSame = new Int32Array(this.oldNodes.length);
+            for (let j = this.oldNodes.length - 1; j >= next; j--) {
+                const node = this.oldNodes[j];
+                if (!this.claimed[j] && node.isAlive) {
+                    const snapshot = node.snapshot;
+                    nextSame[j] = first.get(snapshot) ?? -1;
+                    first.set(snapshot, j);
                 }
             }
-            nothingChanged = false;
-            const newNode = valueAsNode(childType, parent, newPath, newValue, oldMatch);
-            oldNodes.splice(i, 0, newNode);
+            this.bySnapshot = { first, nextSame };
+        }
+        const { first, nextSame } = this.bySnapshot;
+        const head = first.get(value);
+        if (head === undefined) {
+            return -1;
+        }
+        let j = head;
+        while (j >= 0 && (this.claimed[j] || !this.oldNodes[j].isAlive)) {
+            j = nextSame[j];
+        }
+        if (j !== head) {
+            first.set(value, j);
         }
+        return j;
     }
-    return nothingChanged ? null : oldNodes;
 }
 /**
  * Convert a value to a node at given parent and subpath. Attempts to reuse old node if possible and given.