@jbrowse/mobx-state-tree 6.5.2 → 6.6.1

package/dist/mobx-state-tree.cjs

@@ -567,7 +567,9 @@ function getRelativePath(base, target) {
 }
 /**
  * Returns a deep copy of the given state tree node as new tree.
- * Shorthand for `snapshot(x) = getType(x).create(getSnapshot(x))`
+ * Like `getType(x).create(getSnapshot(x))`, except that a node wrapped in a
+ * `types.snapshotProcessor` is recreated through the processor, which
+ * `getType(x)` (the wrapped type) would skip.
  *
  * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc. during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
  *
@@ -579,11 +581,11 @@ function clone(source, keepEnvironment = true) {
     // check all arguments
     assertIsStateTreeNode(source, 1);
     const node = getStateTreeNode(source);
-    return node.type.create(node.snapshot, keepEnvironment === true
+    return (node.snapshotProcessorType ?? node.type).create(node.snapshot, keepEnvironment === true
         ? node.root.environment
         : keepEnvironment === false
             ? undefined
-            : keepEnvironment); // it's an object or something else
+            : keepEnvironment);
 }
 /**
  * Removes a model element from the state tree, and let it live on as a new state tree
@@ -702,17 +704,15 @@ function walk(target, processor) {
  * @returns
  */
 function getPropertyMembers(typeOrNode) {
-    let type;
-    if (isStateTreeNode(typeOrNode)) {
-        type = getType(typeOrNode);
-    }
-    else {
-        type = typeOrNode;
-    }
-    assertArg(type, t => isModelType(t), "model type or model instance", 1);
+    const type = isStateTreeNode(typeOrNode)
+        ? getType(typeOrNode)
+        : typeOrNode;
+    assertArg(type, isModelType, "model type or model instance", 1);
+    // a wrapped model reports the model's properties; a union of models has no
+    // single set and reports none
     return {
         name: type.name,
-        properties: { ...type.properties }
+        properties: { ...asModelType(type)?.properties }
     };
 }
 /**
@@ -914,16 +914,28 @@ class BaseNode {
         }
     }
     _hookSubscribers;
-    fireInternalHook(name) {
-        if (this._hookSubscribers) {
-            this._hookSubscribers.emit(name, this, name);
+    fireInternalHook(name, subject = this) {
+        this._hookSubscribers?.emit(name, subject, name);
+    }
+    /**
+     * Detaching a node takes its whole subtree out of the tree, but only the
+     * detached node's parent changes, so only it fires `beforeDetach` for real.
+     * Internal subscribers below it (reference watchers on a target) still need
+     * to know their node is leaving.
+     */
+    notifyDetachOf(subject) {
+        this.fireInternalHook(Hook.beforeDetach, subject);
+    }
+    isWithin(ancestor) {
+        for (let node = this.parent; node; node = node.parent) {
+            if (node === ancestor) {
+                return true;
+            }
         }
+        return false;
     }
     registerHook(hook, hookHandler) {
-        if (!this._hookSubscribers) {
-            this._hookSubscribers = new EventHandlers();
-        }
-        return this._hookSubscribers.register(hook, hookHandler);
+        return (this._hookSubscribers ??= new EventHandlers()).register(hook, hookHandler);
     }
     _parent;
     get parent() {
@@ -984,6 +996,13 @@ class BaseNode {
         this.aliveAtom.reportObserved();
         return this.isAlive;
     }
+    die() {
+        if (!this.isAlive || this.isDetaching) {
+            return;
+        }
+        this.aboutToDie();
+        this.finalizeDeath();
+    }
     baseFinalizeCreation(whenFinalized) {
         if (devMode()) {
             if (!this.isAlive) {
@@ -1019,6 +1038,7 @@ class BaseNode {
         this.fireHook(Hook.beforeDestroy);
     }
 }
+BaseNode.prototype.die = mobx.action(BaseNode.prototype.die);
 
 /**
  * @internal
@@ -1036,9 +1056,6 @@ class ScalarNode extends BaseNode {
             throw e;
         }
         this.state = NodeLifeCycle.CREATED;
-        // for scalar nodes there's no point in firing this event since it would fire on the constructor, before
-        // anybody can actually register for/listen to it
-        // this.fireHook(Hook.AfterCreate)
         this.finalizeCreation();
     }
     get root() {
@@ -1081,13 +1098,6 @@ class ScalarNode extends BaseNode {
         const path = (this.isAlive ? this.path : this.pathUponDeath) || "<root>";
         return `${this.type.name}@${path}${this.isAlive ? "" : " [dead]"}`;
     }
-    die() {
-        if (!this.isAlive || this.state === NodeLifeCycle.DETACHING) {
-            return;
-        }
-        this.aboutToDie();
-        this.finalizeDeath();
-    }
     finalizeCreation() {
         this.baseFinalizeCreation();
     }
@@ -1101,7 +1111,6 @@ class ScalarNode extends BaseNode {
         this.fireInternalHook(name);
     }
 }
-ScalarNode.prototype.die = mobx.action(ScalarNode.prototype.die);
 
 let nextNodeId = 1;
 var ObservableInstanceLifecycle;
@@ -1289,8 +1298,8 @@ class ObjectNode extends BaseNode {
         if (!this.parent) {
             return;
         }
-        // detach if attached
         this.fireHook(Hook.beforeDetach);
+        this.notifyChildrenOfDetach(this);
         const previousState = this.state;
         this.state = NodeLifeCycle.DETACHING;
         const root = this.root;
@@ -1306,6 +1315,21 @@ class ObjectNode extends BaseNode {
             this.state = previousState;
         }
     }
+    notifyDetachOf(subject) {
+        super.notifyDetachOf(subject);
+        this.notifyChildrenOfDetach(subject);
+    }
+    notifyChildrenOfDetach(subject) {
+        // a handler notified earlier in the walk may have destroyed this node.
+        // A node never read still has to be walked: an instance created elsewhere
+        // can have been moved under it, subscribers and all.
+        if (!this.isAlive) {
+            return;
+        }
+        for (const child of this.getChildren()) {
+            child.notifyDetachOf(subject);
+        }
+    }
     setParent(newParent, subpath) {
         const parentChanged = newParent !== this.parent;
         const subpathChanged = subpath !== this.subpath;
@@ -1510,37 +1534,27 @@ class ObjectNode extends BaseNode {
         this.clearParent();
     }
     preboot() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
         this._applyPatches = createActionInvoker(this.storedValue, "@APPLY_PATCHES", (patches) => {
             patches.forEach(patch => {
                 if (!patch.path) {
-                    self.type.applySnapshot(self, patch.value);
+                    this.type.applySnapshot(this, patch.value);
                     return;
                 }
                 const parts = splitJsonPath(patch.path);
-                const node = resolveNodeByPathParts(self, parts.slice(0, -1));
+                const node = resolveNodeByPathParts(this, parts.slice(0, -1));
                 node.applyPatchLocally(parts[parts.length - 1], patch);
             });
         });
         this._applySnapshot = createActionInvoker(this.storedValue, "@APPLY_SNAPSHOT", (snapshot) => {
-            // if the snapshot is the same as the current one, avoid performing a reconcile
-            if (snapshot === self.snapshot) {
+            // the current snapshot needs no reconcile
+            if (snapshot === this.snapshot) {
                 return;
             }
-            // else, apply it by calling the type logic
-            return self.type.applySnapshot(self, snapshot);
+            this.type.applySnapshot(this, snapshot);
         });
         addHiddenFinalProp(this.storedValue, "$treenode", this);
         addHiddenFinalProp(this.storedValue, "toJSON", toJSON);
     }
-    die() {
-        if (!this.isAlive || this.state === NodeLifeCycle.DETACHING) {
-            return;
-        }
-        this.aboutToDie();
-        this.finalizeDeath();
-    }
     aboutToDie() {
         if (this._observableInstanceState ===
             ObservableInstanceLifecycle.UNINITIALIZED) {
@@ -1552,8 +1566,8 @@ class ObjectNode extends BaseNode {
         // 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();
-        this._internalEventsEmit(InternalEvents.Dispose);
-        this._internalEventsClear(InternalEvents.Dispose);
+        this._internalEvents?.emit(InternalEvents.Dispose);
+        this._internalEvents?.clear(InternalEvents.Dispose);
     }
     finalizeDeath() {
         // invariant: not called directly but from "die"
@@ -1564,57 +1578,57 @@ class ObjectNode extends BaseNode {
         // "kill" the computed prop and just store the last snapshot
         const snapshot = this.snapshot;
         this._snapshotUponDeath = snapshot;
-        this._internalEventsClearAll();
+        this._internalEvents?.clearAll();
         this.baseFinalizeDeath();
     }
     onSnapshot(onChange) {
         this._addSnapshotReaction();
-        const unregister = this._internalEventsRegister(InternalEvents.Snapshot, onChange);
+        const unregister = this.internalEvents().register(InternalEvents.Snapshot, onChange);
         return () => {
             unregister();
             // The reaction re-serializes the whole subtree on every change, so leaving
             // it running once the last listener is gone would keep charging the node
             // for a snapshot nobody receives. Referential stability of getSnapshot()
             // does not depend on it — that comes from keepAlive on _snapshotComputed.
-            if (!this._internalEventsHasSubscribers(InternalEvents.Snapshot)) {
+            if (!this._internalEvents?.hasSubscribers(InternalEvents.Snapshot)) {
                 this._removeSnapshotReaction();
             }
         };
     }
     emitSnapshot(snapshot) {
-        this._internalEventsEmit(InternalEvents.Snapshot, snapshot);
+        this._internalEvents?.emit(InternalEvents.Snapshot, snapshot);
     }
     onPatch(handler) {
-        return this._internalEventsRegister(InternalEvents.Patch, handler);
+        return this.internalEvents().register(InternalEvents.Patch, handler);
     }
     emitPatch(basePatch, source) {
-        if (this._internalEventsHasSubscribers(InternalEvents.Patch)) {
+        if (this._internalEvents?.hasSubscribers(InternalEvents.Patch)) {
             const localizedPatch = {
                 ...basePatch,
                 path: `${source.path.slice(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
             };
             const [patch, reversePatch] = splitPatch(localizedPatch);
-            this._internalEventsEmit(InternalEvents.Patch, patch, reversePatch);
+            this._internalEvents?.emit(InternalEvents.Patch, patch, reversePatch);
         }
         if (this.parent) {
             this.parent.emitPatch(basePatch, source);
         }
     }
     hasDisposer(disposer) {
-        return this._internalEventsHas(InternalEvents.Dispose, disposer);
+        return !!this._internalEvents?.has(InternalEvents.Dispose, disposer);
     }
     addDisposer(disposer) {
         if (!this.hasDisposer(disposer)) {
-            this._internalEventsRegister(InternalEvents.Dispose, disposer, true);
+            this.internalEvents().register(InternalEvents.Dispose, disposer, true);
             return;
         }
         throw fail("cannot add a disposer when it is already registered for execution");
     }
     removeDisposer(disposer) {
-        if (!this._internalEventsHas(InternalEvents.Dispose, disposer)) {
+        if (!this._internalEvents?.has(InternalEvents.Dispose, disposer)) {
             throw fail("cannot remove a disposer which was never registered for execution");
         }
-        this._internalEventsUnregister(InternalEvents.Dispose, disposer);
+        this._internalEvents?.unregister(InternalEvents.Dispose, disposer);
     }
     removeMiddleware(middleware) {
         if (this.middlewares) {
@@ -1659,48 +1673,17 @@ class ObjectNode extends BaseNode {
         // not removeDisposer(), which throws when the registration is already gone —
         // the last listener can be disposed from within a disposer, i.e. after
         // aboutToDie has cleared them
-        this._internalEventsUnregister(InternalEvents.Dispose, disposer);
+        this._internalEvents?.unregister(InternalEvents.Dispose, disposer);
         disposer();
     }
-    // #region internal event handling
+    // created on first registration: most nodes never get a listener
     _internalEvents;
-    // we proxy the methods to avoid creating an EventHandlers instance when it is not needed
-    _internalEventsHasSubscribers(event) {
-        return !!this._internalEvents && this._internalEvents.hasSubscribers(event);
-    }
-    _internalEventsRegister(event, eventHandler, atTheBeginning = false) {
-        if (!this._internalEvents) {
-            this._internalEvents = new EventHandlers();
-        }
-        return this._internalEvents.register(event, eventHandler, atTheBeginning);
-    }
-    _internalEventsHas(event, eventHandler) {
-        return (!!this._internalEvents && this._internalEvents.has(event, eventHandler));
-    }
-    _internalEventsUnregister(event, eventHandler) {
-        if (this._internalEvents) {
-            this._internalEvents.unregister(event, eventHandler);
-        }
-    }
-    _internalEventsEmit(event, ...args) {
-        if (this._internalEvents) {
-            this._internalEvents.emit(event, ...args);
-        }
-    }
-    _internalEventsClear(event) {
-        if (this._internalEvents) {
-            this._internalEvents.clear(event);
-        }
-    }
-    _internalEventsClearAll() {
-        if (this._internalEvents) {
-            this._internalEvents.clearAll();
-        }
+    internalEvents() {
+        return (this._internalEvents ??= new EventHandlers());
     }
 }
 ObjectNode.prototype.createObservableInstance = mobx.action(ObjectNode.prototype.createObservableInstance);
 ObjectNode.prototype.detach = mobx.action(ObjectNode.prototype.detach);
-ObjectNode.prototype.die = mobx.action(ObjectNode.prototype.die);
 
 /**
  * @internal
@@ -1892,7 +1875,6 @@ class ComplexType extends BaseType {
         return null;
     }
 }
-ComplexType.prototype.create = mobx.action(ComplexType.prototype.create);
 /**
  * @internal
  * @hidden
@@ -1902,11 +1884,6 @@ class SimpleType extends BaseType {
         return snapshot;
     }
     getValue(node) {
-        // if we ever find a case where scalar nodes can be accessed without iterating through its parent
-        // uncomment this to make sure the parent chain is created when this is accessed
-        // if (node.parent) {
-        //     node.parent.createObservableInstanceIfNeeded()
-        // }
         return node.storedValue;
     }
     getSnapshot(node) {
@@ -1936,6 +1913,30 @@ class SimpleType extends BaseType {
 function isType(value) {
     return (typeof value === "object" && value?.isType === true);
 }
+/**
+ * The one type a wrapper hands everything to: what an `optional`,
+ * `stripDefault`, `refinement`, `snapshotProcessor` or (resolved) `late`
+ * wraps. `undefined` for any other type, including a union or a `resilient`,
+ * which pick a type per value.
+ *
+ * Resolves a `late` type's definition if it has not been read yet.
+ */
+function getWrappedType(type) {
+    const subtype = type.getSubTypes();
+    return isType(subtype) ? subtype : undefined;
+}
+/**
+ * Strips every wrapper {@link getWrappedType} sees through, down to the type
+ * that actually builds the value: for a complex type `T`,
+ * `getType(T.create(snapshot)) === unwrapType(T)`.
+ *
+ * `types.model({ xs: types.array(X) }).properties.xs`, for instance, is an
+ * `optional` whose unwrapped type is the array type.
+ */
+function unwrapType(type) {
+    const wrapped = getWrappedType(type);
+    return wrapped ? unwrapType(wrapped) : type;
+}
 /**
  * @internal
  * @hidden
@@ -2934,7 +2935,7 @@ function createScalarNode(type, parent, subpath, environment, initialValue) {
  * @hidden
  */
 function isNode(value) {
-    return value instanceof ScalarNode || value instanceof ObjectNode;
+    return value instanceof BaseNode;
 }
 
 /**
@@ -3113,25 +3114,6 @@ function fail(message = "Illegal state") {
 function identity(_) {
     return _;
 }
-/**
- * @internal
- * @hidden
- */
-const isInteger = Number.isInteger;
-/**
- * @internal
- * @hidden
- */
-function isFloat(val) {
-    return Number(val) === val && val % 1 !== 0;
-}
-/**
- * @internal
- * @hidden
- */
-function isFinite(val) {
-    return Number.isFinite(val);
-}
 /**
  * @internal
  * @hidden
@@ -3779,11 +3761,8 @@ class SnapshotProcessor extends BaseType {
         return sn;
     }
     _fixNode(node) {
-        // the node's type is the *inner* type, so `getType(instance).create(...)`
-        // would bypass the processors — point it at ours instead
-        const nodeType = node.type;
-        nodeType.create = this.create.bind(this);
         if (node instanceof ObjectNode) {
+            node.snapshotProcessorType = this;
             node.hasSnapshotPostProcessor = !!this._processors.postProcessor;
         }
         const oldGetSnapshot = node.getSnapshot;
@@ -4267,14 +4246,20 @@ function map(subtype) {
     return new MapType(subtype);
 }
 /**
- * Returns if a given value represents a map type.
- *
- * @param type
- * @returns `true` if it is a map type.
+ * Returns if a type is a map type, or wraps or unions one. For the map type
+ * itself, use {@link asMapType}.
  */
 function isMapType(type) {
     return isType(type) && (type.flags & TypeFlags.Map) > 0;
 }
+/**
+ * The map type `type` builds its values with, seeing through the wrappers
+ * {@link unwrapType} does, or `undefined` if that is not a map type.
+ */
+function asMapType(type) {
+    const unwrapped = unwrapType(type);
+    return unwrapped instanceof MapType ? unwrapped : undefined;
+}
 
 /**
  * @internal
@@ -4484,98 +4469,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.
@@ -4644,14 +4705,20 @@ function areSame(oldNode, newValue) {
         oldNodeType.isMatchingSnapshotId(oldNode, newValue));
 }
 /**
- * Returns if a given value represents an array type.
- *
- * @param type
- * @returns `true` if the type is an array type.
+ * Returns if a type is an array type, or wraps or unions one. For the array
+ * type itself, use {@link asArrayType}.
  */
 function isArrayType(type) {
     return isType(type) && (type.flags & TypeFlags.Array) > 0;
 }
+/**
+ * The array type `type` builds its values with, seeing through the wrappers
+ * {@link unwrapType} does, or `undefined` if that is not an array type.
+ */
+function asArrayType(type) {
+    const unwrapped = unwrapType(type);
+    return unwrapped instanceof ArrayType ? unwrapped : undefined;
+}
 
 const PRE_PROCESS_SNAPSHOT = "preProcessSnapshot";
 const POST_PROCESS_SNAPSHOT = "postProcessSnapshot";
@@ -4686,6 +4753,12 @@ function getPropObservables(storedValue) {
 function objectTypeToString() {
     return getStateTreeNode(this).toString();
 }
+/** `second` applied to `first`'s result, allocating only when both exist */
+function chainProcessors(first, second) {
+    return first && second
+        ? snapshot => second(first(snapshot))
+        : (first ?? second);
+}
 const ANONYMOUS_MODEL_NAME = "AnonymousModel";
 /**
  * A plain loop rather than a callback per property, which allocated a closure
@@ -4974,8 +5047,6 @@ class ModelType extends ComplexType {
             ? initialValue
             : this.applySnapshotPreProcessor(initialValue);
         return createObjectNode(this, parent, subpath, environment, value);
-        // Optimization: record all prop- view- and action names after first construction, and generate an optimal base class
-        // that pre-reserves all these fields for fast object-member lookups
     }
     initializeChildNodes(objNode, initialSnapshot = {}) {
         const type = objNode.type;
@@ -5139,15 +5210,12 @@ class ModelType extends ComplexType {
         }
     }
     applySnapshotPreProcessor(snapshot) {
-        const processor = this.preProcessor;
-        return processor ? processor.call(null, snapshot) : snapshot;
+        const preProcessor = this.preProcessor;
+        return preProcessor ? preProcessor(snapshot) : snapshot;
     }
     applySnapshotPostProcessor(snapshot) {
         const postProcessor = this.postProcessor;
-        if (postProcessor) {
-            return postProcessor.call(null, snapshot);
-        }
-        return snapshot;
+        return postProcessor ? postProcessor(snapshot) : snapshot;
     }
     getChildType(propertyName) {
         assertIsString(propertyName, 1);
@@ -5170,7 +5238,6 @@ class ModelType extends ComplexType {
         return typeCheckSuccess();
     }
     describe() {
-        // optimization: cache
         return `{ ${this.propertyNames
             .map(key => `${key}: ${this.properties[key].describe()}`)
             .join("; ")} }`;
@@ -5192,27 +5259,17 @@ Object.assign(ModelType.prototype, {
     props(properties) {
         return this.cloneAndEnhance({ properties });
     },
+    // a newly added pre-processor sees the raw snapshot first; a newly added
+    // post-processor sees what the existing one produced
     preProcessSnapshot(preProcessor) {
-        const currentPreprocessor = this.preProcessor;
-        if (!currentPreprocessor) {
-            return this.cloneAndEnhance({ preProcessor });
-        }
-        else {
-            return this.cloneAndEnhance({
-                preProcessor: snapshot => currentPreprocessor(preProcessor(snapshot))
-            });
-        }
+        return this.cloneAndEnhance({
+            preProcessor: chainProcessors(preProcessor, this.preProcessor)
+        });
     },
     postProcessSnapshot(postProcessor) {
-        const currentPostprocessor = this.postProcessor;
-        if (!currentPostprocessor) {
-            return this.cloneAndEnhance({ postProcessor });
-        }
-        else {
-            return this.cloneAndEnhance({
-                postProcessor: snapshot => postProcessor(currentPostprocessor(snapshot))
-            });
-        }
+        return this.cloneAndEnhance({
+            postProcessor: chainProcessors(this.postProcessor, postProcessor)
+        });
     }
 });
 /**
@@ -5236,39 +5293,44 @@ function model(...args) {
  * the types are composed into a new Type with the given name
  */
 function compose(...args) {
-    // TODO: just join the base type names if no name is provided
     const hasTypename = typeof args[0] === "string";
     const typeName = hasTypename ? args[0] : ANONYMOUS_MODEL_NAME;
     if (hasTypename) {
         args.shift();
     }
-    // check all parameters
+    // exactly a model type: each part's own properties and initializers are
+    // read below, and a wrapper around a model has neither
     if (devMode()) {
         args.forEach((type, i) => {
-            assertArg(type, isModelType, "mobx-state-tree model type", hasTypename ? i + 2 : i + 1);
+            assertArg(type, t => t instanceof ModelType, "mobx-state-tree model type", hasTypename ? i + 2 : i + 1);
         });
     }
     return args
         .reduce((prev, cur) => prev.cloneAndEnhance({
-        name: `${prev.name}_${cur.name}`,
         properties: cur.properties,
         // cur.properties is another ModelType's already-converted+frozen bag
         propertiesAreConverted: true,
         initializers: cur.initializers,
-        preProcessor: (snapshot) => cur.applySnapshotPreProcessor(prev.applySnapshotPreProcessor(snapshot)),
-        postProcessor: (snapshot) => cur.applySnapshotPostProcessor(prev.applySnapshotPostProcessor(snapshot))
+        preProcessor: chainProcessors(prev.preProcessor, cur.preProcessor),
+        postProcessor: chainProcessors(prev.postProcessor, cur.postProcessor)
     }))
         .named(typeName);
 }
 /**
- * Returns if a given value represents a model type.
- *
- * @param type
- * @returns
+ * Returns if a type is a model type, or wraps or unions one. For the model
+ * type itself, use {@link asModelType}.
  */
 function isModelType(type) {
     return isType(type) && (type.flags & TypeFlags.Object) > 0;
 }
+/**
+ * The model type `type` builds its values with, seeing through the wrappers
+ * {@link unwrapType} does, or `undefined` if that is not a model type.
+ */
+function asModelType(type) {
+    const unwrapped = unwrapType(type);
+    return unwrapped instanceof ModelType ? unwrapped : undefined;
+}
 /**
  * `extendInstance` - attaches additional actions, views and volatile state to an
  * already-created model instance, using the same instantiation machinery as
@@ -5294,7 +5356,7 @@ function extendInstance(instance, fn) {
         throw fail("extendInstance expects a mobx-state-tree node");
     }
     const type = getStateTreeNode(instance).type;
-    if (!isModelType(type)) {
+    if (!(type instanceof ModelType)) {
         throw fail("extendInstance can only be used on model instances");
     }
     // Views/actions/volatile are installed via defineProperty + makeObservable — the
@@ -5302,9 +5364,8 @@ function extendInstance(instance, fn) {
     // write-protection interceptor is attached (see finalizeNewInstance). On a live
     // instance that interceptor is already active, so run the attach inside an action
     // context: isRunningAction() then short-circuits assertWritable.
-    const modelType = type;
     const attach = createActionInvoker(instance, "@@extendInstance", (() => {
-        modelType.applyExtensionToInstance(instance, fn(instance));
+        type.applyExtensionToInstance(instance, fn(instance));
     }));
     attach();
     return instance;
@@ -5376,7 +5437,7 @@ const number = new CoreType("number", TypeFlags.Number, v => typeof v === "numbe
  * })
  * ```
  */
-const integer = new CoreType("integer", TypeFlags.Integer, v => isInteger(v));
+const integer = new CoreType("integer", TypeFlags.Integer, Number.isInteger);
 /**
  * `types.float` - Creates a type that can only contain an float value.
  *
@@ -5388,7 +5449,7 @@ const integer = new CoreType("integer", TypeFlags.Integer, v => isInteger(v));
  * })
  * ```
  */
-const float = new CoreType("float", TypeFlags.Float, v => isFloat(v));
+const float = new CoreType("float", TypeFlags.Float, v => Number(v) === v && v % 1 !== 0);
 /**
  * `types.finite` - Creates a type that can only contain an finite value.
  *
@@ -5400,7 +5461,7 @@ const float = new CoreType("float", TypeFlags.Float, v => isFloat(v));
  * })
  * ```
  */
-const finite = new CoreType("finite", TypeFlags.Finite, v => isFinite(v));
+const finite = new CoreType("finite", TypeFlags.Finite, Number.isFinite);
 /**
  * `types.boolean` - Creates a type that can only contain a boolean value.
  * This type is used for boolean values by default
@@ -5461,11 +5522,9 @@ function getPrimitiveFactoryFromValue(value) {
 /**
  * Returns if a given value represents a primitive type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -5531,11 +5590,9 @@ function literal(value) {
 /**
  * Returns if a given value represents a literal type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -5613,11 +5670,9 @@ function refinement(...args) {
 /**
  * Returns if a given value is a refinement type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -5630,6 +5685,10 @@ function isRefinementType(type) {
  * `types.enumeration` - Can be used to create an string based enumeration.
  * (note: this methods is just sugar for a union of string literals)
  *
+ * The member type is inferred from the options, so a literal array, an
+ * `as const` array and `Object.values(SomeStringEnum)` all produce the exact
+ * union; only an array already typed `string[]` falls back to `string`.
+ *
  * Example:
  * ```ts
  * const TrafficLight = types.model({
@@ -5641,52 +5700,47 @@ function isRefinementType(type) {
  * @param options possible values this enumeration can have
  * @returns
  */
-function enumeration(name, options) {
-    const realOptions = typeof name === "string" ? options : name;
-    // check all options
+function enumeration(nameOrOptions, maybeOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : undefined;
+    const options = typeof nameOrOptions === "string" ? maybeOptions : nameOrOptions;
     if (devMode()) {
-        realOptions.forEach((option, i) => {
+        options.forEach((option, i) => {
             assertIsString(option, i + 1);
         });
     }
-    const type = union(...realOptions.map(option => literal(`${option}`)));
-    if (typeof name === "string") {
-        type.name = name;
-    }
-    return type;
+    // built directly rather than through union(): its members are fresh
+    // literals, so interning could never share it, and the name belongs to this
+    // union alone
+    return new Union(options.map(option => literal(`${option}`)), name === undefined ? undefined : { name });
 }
 
-// Drill through single-subtype wrappers — optional(), refinement(),
-// snapshotProcessor(), late() — to the underlying ModelType. Discriminated-
-// union scoping keys on a member's literal `type` property, but real-world
-// members are rarely bare models (jbrowse config schemas, for instance, are
-// always optional(model) or optional(snapshotProcessor(model))). Without this
-// the scoping never engages and every failure prints every member's full
-// structure. Wrappers expose their child as `_subtype` (optional/refinement/
-// snapshotProcessor) or via `getSubType()` (late); bounded to avoid cycles.
-// Only *successful* resolutions are cached. A wrapper chain's shape is fixed at
-// construction, so once a member resolves to a ModelType it always will; but a
-// `late` member reports no subtype until its definition evaluates, and that
-// miss must stay retryable.
-const resolvedModelTypes = new WeakMap();
+// The model a member is meant for: the one under its wrappers, and for a
+// `resilient` member the one it tries first. Matching a snapshot to a member
+// (quick-match dispatch, discriminator scoping) keys on that model's props,
+// and real-world members are rarely bare models (jbrowse config schemas are
+// always optional(model) or optional(snapshotProcessor(model))).
+// Misses are cached too, unless the member holds a `late` type: that has no
+// subtype until its definition evaluates, so its miss must stay retryable.
+const intendedModelTypes = new WeakMap();
 function resolveModelType(type) {
-    if (!type) {
-        return undefined;
+    const cached = intendedModelTypes.get(type);
+    if (cached !== undefined) {
+        return cached ?? undefined;
     }
-    const cached = resolvedModelTypes.get(type);
-    if (cached) {
-        return cached;
+    const model = findIntendedModelType(type);
+    if (model || !(type.flags & TypeFlags.Late)) {
+        intendedModelTypes.set(type, model ?? null);
     }
-    let current = type;
-    for (let depth = 0; current && depth < 20; depth++) {
-        if (current instanceof ModelType) {
-            resolvedModelTypes.set(type, current);
-            return current;
-        }
-        const wrapper = current;
-        current = wrapper._subtype ?? wrapper.getSubType?.(false);
+    return model;
+}
+function findIntendedModelType(type) {
+    const unwrapped = unwrapType(type);
+    if (unwrapped instanceof ModelType) {
+        return unwrapped;
     }
-    return undefined;
+    return unwrapped instanceof Resilient
+        ? findIntendedModelType(unwrapped.primaryType)
+        : undefined;
 }
 // The quick-match paths below already know a type carries TypeFlags.Literal,
 // but `is()` still routes through BaseType.validate — a context array, an entry
@@ -5724,13 +5778,17 @@ class Union extends BaseType {
         if (cached !== undefined) {
             return cached;
         }
+        const result = this.foldFlags();
+        if (!(result & TypeFlags.Late)) {
+            this._flags = result;
+        }
+        return result;
+    }
+    foldFlags() {
         let result = TypeFlags.Union;
         for (const type of this.members()) {
             result |= type.flags;
         }
-        if (!(result & TypeFlags.Late)) {
-            this._flags = result;
-        }
         return result;
     }
     computeName() {
@@ -6065,11 +6123,7 @@ class DynamicUnion extends Union {
         return this._members();
     }
     get flags() {
-        let result = TypeFlags.Union;
-        for (const type of this.members()) {
-            result |= type.flags;
-        }
-        return result;
+        return this.foldFlags();
     }
     get name() {
         return this._explicitName !== undefined
@@ -6148,11 +6202,9 @@ function union(...args) {
 /**
  * Returns if a given value represents a union type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -6161,13 +6213,9 @@ function isUnionType(type) {
     return isType(type) && (type.flags & TypeFlags.Union) > 0;
 }
 /**
- * Returns the member types of a union.
- *
- * Wrapper types (`optional`, `refinement`, `late`) inherit the union flag from
- * the type they wrap, so `isUnionType` is true for e.g. an optional-of-union,
- * but their `getSubTypes()` reports the single wrapped type rather than the
- * union's members. This drills through those wrappers until the union's member
- * array surfaces.
+ * Returns the member types of a union, seeing through the wrappers
+ * {@link unwrapType} does: `isUnionType` is also true for e.g. an
+ * optional-of-union.
  *
  * @param type a type for which `isUnionType` is true
  * @returns the array of member types of the underlying union
@@ -6176,16 +6224,11 @@ function getUnionSubtypes(type) {
     if (!isUnionType(type)) {
         throw fail("expected a union type");
     }
-    let subtypes = type.getSubTypes();
-    while (typeof subtypes === "object" &&
-        subtypes !== null &&
-        !Array.isArray(subtypes)) {
-        subtypes = subtypes.getSubTypes();
-    }
-    if (!Array.isArray(subtypes)) {
+    const union = unwrapType(type);
+    if (!(union instanceof Union)) {
         throw fail("could not extract subtypes from union type");
     }
-    return subtypes;
+    return union.getSubTypes();
 }
 
 /**
@@ -6332,11 +6375,9 @@ const undefinedAsOptionalValues = [undefined];
 /**
  * Returns if a value represents an optional type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -6347,26 +6388,6 @@ function isOptionalType(type) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
-/**
- * The identifier attribute of the model a stripDefault ultimately wraps, or
- * `null` when there is none. Drills through the single-subtype wrappers the way
- * `resolveModelType` in union.ts does — that one is module-private there, and
- * this file may not reach into it.
- *
- * `null` is also the answer for an unresolved `types.late`, which only costs the
- * short-circuit, never correctness: the full structural walk still runs.
- */
-function resolveIdentifierAttribute(type) {
-    let current = type;
-    for (let depth = 0; current && depth < 20; depth++) {
-        if (current instanceof ModelType) {
-            return current.identifierAttribute ? current.identifierAttribute : null;
-        }
-        const wrapper = current;
-        current = wrapper._subtype ?? wrapper.getSubType?.(false);
-    }
-    return null;
-}
 /**
  * Compare a child snapshot to a stripped-default's reference snapshot: identity
  * for primitives, structural for objects/arrays.
@@ -6448,7 +6469,10 @@ class StripDefaultValue extends OptionalValue {
     equalsDefault(snapshot, defaultSnapshot) {
         let identifierAttribute = this._identifierAttribute;
         if (identifierAttribute === undefined) {
-            identifierAttribute = resolveIdentifierAttribute(this.getSubTypes());
+            // null when not wrapping an identified model; an unresolved late member
+            // also lands here, which only costs the short-circuit below
+            identifierAttribute =
+                asModelType(this.getSubTypes())?.identifierAttribute ?? null;
             this._identifierAttribute = identifierAttribute;
         }
         // an identified model's snapshot normally has the same shape as the default
@@ -6558,16 +6582,14 @@ class Late extends BaseType {
     }
     getSubType(mustSucceed) {
         if (!this._subType) {
-            let t = undefined;
+            let t;
             try {
                 t = this._definition();
             }
             catch (e) {
-                if (e instanceof ReferenceError) // can happen in strict ES5 code when a definition is self refering
-                 {
-                    t = undefined;
-                }
-                else {
+                // a self-referencing definition can read its binding before it is
+                // initialized; that is "not defined yet", like returning undefined
+                if (!(e instanceof ReferenceError)) {
                     throw e;
                 }
             }
@@ -6583,10 +6605,15 @@ class Late extends BaseType {
         }
         return this._subType;
     }
-    constructor(name, _definition) {
+    constructor(_definition, name) {
         super(name);
         this._definition = _definition;
     }
+    // the unnamed form is named after the definition's source text, which is
+    // only worth building if something reads it
+    computeName() {
+        return `late(${this._definition.toString()})`;
+    }
     instantiate(parent, subpath, environment, initialValue) {
         return this.getSubType(true).instantiate(parent, subpath, environment, initialValue);
     }
@@ -6595,7 +6622,7 @@ class Late extends BaseType {
     }
     describe() {
         const t = this.getSubType(false);
-        return t ? t.name : "<uknown late type>";
+        return t ? t.name : "<unknown late type>";
     }
     isValidSnapshot(value, context) {
         const t = this.getSubType(false);
@@ -6610,8 +6637,7 @@ class Late extends BaseType {
         return t ? t.isAssignableFrom(type) : false;
     }
     getSubTypes() {
-        const subtype = this.getSubType(false);
-        return subtype ? subtype : cannotDetermineSubtype;
+        return this.getSubType(false) ?? cannotDetermineSubtype;
     }
 }
 /**
@@ -6631,26 +6657,21 @@ class Late extends BaseType {
  * @returns
  */
 function late(nameOrType, maybeType) {
-    const name = typeof nameOrType === "string"
-        ? nameOrType
-        : `late(${nameOrType.toString()})`;
+    const name = typeof nameOrType === "string" ? nameOrType : undefined;
     const type = typeof nameOrType === "string" ? maybeType : nameOrType;
-    // checks that the type is actually a late type
     if (devMode()) {
         if (!(typeof type === "function" && type.length === 0)) {
             throw fail(`Invalid late type, expected a function with zero arguments that returns a type, got: ${type}`);
         }
     }
-    return new Late(name, type);
+    return new Late(type, name);
 }
 /**
  * Returns if a given value represents a late type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -6660,7 +6681,8 @@ function isLateType(type) {
 }
 
 function lazy(name, options) {
-    // TODO: fix this unknown casting to be stricter
+    // a lazy type stands in for the type it loads, down to that type's own
+    // methods (a model's `.props`, say), which the placeholder does not have
     return new Lazy(name, options);
 }
 /**
@@ -6827,11 +6849,9 @@ function frozen(arg) {
 /**
  * Returns if a given value represents a frozen type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -6975,9 +6995,10 @@ class BaseReferenceType extends SimpleType {
             return undefined;
         }
         const refTargetNode = getStateTreeNode(refTargetValue);
-        const hookHandler = (_, refTargetNodeHook) => {
+        const hookHandler = (subject, refTargetNodeHook) => {
             const cause = getInvalidationCause(refTargetNodeHook);
-            if (!cause) {
+            // a reference detached along with its target still resolves it
+            if (!cause || (cause === "detach" && storedRefNode.isWithin(subject))) {
                 return;
             }
             this.fireInvalidated(cause, storedRefNode, referenceId, refTargetNode);
@@ -7175,11 +7196,9 @@ function reference(subType, options) {
 /**
  * Returns if a given value represents a reference type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -7304,11 +7323,9 @@ const identifierNumber = new IdentifierNumberType();
 /**
  * Returns if a given value represents an identifier type.
  *
- * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
- * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
- * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
- * to compile. Guards with a distinct narrowing target (`isArrayType`,
- * `isMapType`, `isModelType`) keep their predicate.
+ * Like every `isXType` guard it reads the type's flags, which wrappers and
+ * unions inherit from what they hold, so it is also true for a type that wraps
+ * or unions one. Use {@link unwrapType} to get at the type itself.
  *
  * @param type
  * @returns
@@ -7439,6 +7456,10 @@ class CustomType extends SimpleType {
     }
 }
 
+/**
+ * @internal
+ * @hidden
+ */
 class Resilient extends BaseType {
     _subtype;
     _fallbackType;
@@ -7446,6 +7467,10 @@ class Resilient extends BaseType {
     get flags() {
         return this._subtype.flags;
     }
+    /** the type tried first; the fallback takes over only when it fails */
+    get primaryType() {
+        return this._subtype;
+    }
     constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
         super();
         this._subtype = _subtype;
@@ -7606,6 +7631,9 @@ exports.addMiddleware = addMiddleware;
 exports.applyAction = applyAction;
 exports.applyPatch = applyPatch;
 exports.applySnapshot = applySnapshot;
+exports.asArrayType = asArrayType;
+exports.asMapType = asMapType;
+exports.asModelType = asModelType;
 exports.cannotDetermineSubtype = cannotDetermineSubtype;
 exports.cast = cast;
 exports.castFlowReturn = castFlowReturn;
@@ -7637,6 +7665,7 @@ exports.getRunningActionContext = getRunningActionContext;
 exports.getSnapshot = getSnapshot;
 exports.getType = getType;
 exports.getUnionSubtypes = getUnionSubtypes;
+exports.getWrappedType = getWrappedType;
 exports.hasParent = hasParent;
 exports.hasParentOfType = hasParentOfType;
 exports.isActionContextChildOf = isActionContextChildOf;
@@ -7682,5 +7711,6 @@ exports.typecheck = typecheck;
 exports.types = types;
 exports.unescapeJsonPath = unescapeJsonPath;
 exports.unprotect = unprotect;
+exports.unwrapType = unwrapType;
 exports.walk = walk;
 //# sourceMappingURL=mobx-state-tree.cjs.map