@jbrowse/mobx-state-tree 6.2.0 → 6.4.0

package/dist/mobx-state-tree.cjs

@@ -272,6 +272,8 @@ function unprotect(target) {
  * Returns true if the object is in protected mode, @see protect
  */
 function isProtected(target) {
+    // check all arguments
+    assertIsStateTreeNode(target, 1);
     return getStateTreeNode(target).isProtected;
 }
 /**
@@ -303,6 +305,27 @@ function getSnapshot(target, applyPostProcess = true) {
     }
     return freeze(node.type.getSnapshot(node, false));
 }
+function findParentAtDepth(node, depth) {
+    let remaining = depth;
+    let parent = node.parent;
+    while (parent) {
+        if (--remaining === 0) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+function findParentOfType(node, type) {
+    let parent = node.parent;
+    while (parent) {
+        if (type.is(parent.storedValue)) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
 /**
  * Given a model instance, returns `true` if the object has a parent, that is, is part of another object, map or array.
  *
@@ -314,14 +337,7 @@ function hasParent(target, depth = 1) {
     // check all arguments
     assertIsStateTreeNode(target, 1);
     assertIsNumber(depth, 2, 0);
-    let parent = getStateTreeNode(target).parent;
-    while (parent) {
-        if (--depth === 0) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
+    return findParentAtDepth(getStateTreeNode(target), depth) !== null;
 }
 /**
  * Returns the immediate parent of this object, or throws.
@@ -340,15 +356,11 @@ function getParent(target, depth = 1) {
     // check all arguments
     assertIsStateTreeNode(target, 1);
     assertIsNumber(depth, 2, 0);
-    let d = depth;
-    let parent = getStateTreeNode(target).parent;
-    while (parent) {
-        if (--d === 0) {
-            return parent.storedValue;
-        }
-        parent = parent.parent;
+    const parent = findParentAtDepth(getStateTreeNode(target), depth);
+    if (!parent) {
+        throw fail(`Failed to find the parent of ${getStateTreeNode(target)} at depth ${depth}`);
     }
-    throw fail(`Failed to find the parent of ${getStateTreeNode(target)} at depth ${depth}`);
+    return parent.storedValue;
 }
 /**
  * Given a model instance, returns `true` if the object has a parent of given type, that is, is part of another object, map or array
@@ -361,14 +373,7 @@ function hasParentOfType(target, type) {
     // check all arguments
     assertIsStateTreeNode(target, 1);
     assertIsType(type, 2);
-    let parent = getStateTreeNode(target).parent;
-    while (parent) {
-        if (type.is(parent.storedValue)) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
+    return findParentOfType(getStateTreeNode(target), type) !== null;
 }
 /**
  * Returns the target's parent of a given type, or throws.
@@ -381,14 +386,11 @@ function getParentOfType(target, type) {
     // check all arguments
     assertIsStateTreeNode(target, 1);
     assertIsType(type, 2);
-    let parent = getStateTreeNode(target).parent;
-    while (parent) {
-        if (type.is(parent.storedValue)) {
-            return parent.storedValue;
-        }
-        parent = parent.parent;
+    const parent = findParentOfType(getStateTreeNode(target), type);
+    if (!parent) {
+        throw fail(`Failed to find the parent of ${getStateTreeNode(target)} of a given type`);
     }
-    throw fail(`Failed to find the parent of ${getStateTreeNode(target)} of a given type`);
+    return parent.storedValue;
 }
 /**
  * Given an object in a model tree, returns the root object of that tree.
@@ -482,30 +484,20 @@ function getIdentifier(target) {
     return getStateTreeNode(target).identifier;
 }
 /**
- * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
- * else it returns undefined.
- *
- * @param getter Function to access the reference.
- * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.
- * @returns
+ * Resolves a reference getter to the referenced node, or `undefined` when the
+ * reference is empty, dangling, or (with `checkIfAlive`) points at a dead node.
+ * Backs both {@link tryReference} and {@link isValidReference}.
  */
-function tryReference(getter, checkIfAlive = true) {
+function resolveReference(getter, checkIfAlive) {
     try {
         const node = getter();
         if (node === undefined || node === null) {
             return undefined;
         }
-        else if (isStateTreeNode(node)) {
-            if (!checkIfAlive) {
-                return node;
-            }
-            else {
-                return isAlive(node) ? node : undefined;
-            }
-        }
-        else {
+        if (!isStateTreeNode(node)) {
             throw fail("The reference to be checked is not one of node, null or undefined");
         }
+        return !checkIfAlive || isAlive(node) ? node : undefined;
     }
     catch (e) {
         if (e instanceof InvalidReferenceError) {
@@ -514,6 +506,17 @@ function tryReference(getter, checkIfAlive = true) {
         throw e;
     }
 }
+/**
+ * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
+ * else it returns undefined.
+ *
+ * @param getter Function to access the reference.
+ * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.
+ * @returns
+ */
+function tryReference(getter, checkIfAlive = true) {
+    return resolveReference(getter, checkIfAlive);
+}
 /**
  * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns if the check passes or not.
  *
@@ -522,24 +525,7 @@ function tryReference(getter, checkIfAlive = true) {
  * @returns
  */
 function isValidReference(getter, checkIfAlive = true) {
-    try {
-        const node = getter();
-        if (node === undefined || node === null) {
-            return false;
-        }
-        else if (isStateTreeNode(node)) {
-            return checkIfAlive ? isAlive(node) : true;
-        }
-        else {
-            throw fail("The reference to be checked is not one of node, null or undefined");
-        }
-    }
-    catch (e) {
-        if (e instanceof InvalidReferenceError) {
-            return false;
-        }
-        throw e;
-    }
+    return resolveReference(getter, checkIfAlive) !== undefined;
 }
 /**
  * Try to resolve a given path relative to a given node.
@@ -1213,11 +1199,11 @@ class ObjectNode extends BaseNode {
             this.identifier = normalizeIdentifier(id);
             this.unnormalizedIdentifier = id;
         }
-        if (!parent) {
-            this.identifierCache.addNodeToCache(this);
-        }
-        else {
-            parent.root.identifierCache.addNodeToCache(this);
+        // 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;
+            cache.addNodeToCache(this);
         }
     }
     createObservableInstanceIfNeeded(fireHooks = true) {
@@ -1365,15 +1351,9 @@ class ObjectNode extends BaseNode {
             typeof this.storedValue === "object" &&
             this.storedValue[name];
         if (typeof fn === "function") {
-            // we check for it to allow old mobx peer dependencies that don't have the method to work (even when still bugged)
-            if (mobx._allowStateChangesInsideComputed) {
-                mobx._allowStateChangesInsideComputed(() => {
-                    fn.apply(this.storedValue);
-                });
-            }
-            else {
+            mobx._allowStateChangesInsideComputed(() => {
                 fn.apply(this.storedValue);
-            }
+            });
         }
     }
     _snapshotUponDeath;
@@ -1753,8 +1733,8 @@ var TypeFlags;
     TypeFlags[TypeFlags["Float"] = 4194304] = "Float";
 })(TypeFlags || (TypeFlags = {}));
 /**
- * @internal
- * @hidden
+ * The value `getSubTypes()` returns when a type cannot report its subtype,
+ * which is distinct from reporting that it has none (`null`).
  */
 const cannotDetermineSubtype = "cannotDetermine";
 /**
@@ -1806,6 +1786,9 @@ class BaseType {
         // istanbul ignore next
         throw fail("unimplemented method");
     }
+    describe() {
+        return this.name;
+    }
     isAssignableFrom(type) {
         return type === this;
     }
@@ -1951,7 +1934,7 @@ class SimpleType extends BaseType {
  * @returns `true` if the value is a type.
  */
 function isType(value) {
-    return typeof value === "object" && value?.isType === true;
+    return (typeof value === "object" && value?.isType === true);
 }
 /**
  * @internal
@@ -1961,7 +1944,6 @@ function assertIsType(type, argNumber) {
     assertArg(type, isType, "mobx-state-tree type", argNumber);
 }
 
-const runningActions = new Map();
 /**
  * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.
  *
@@ -1977,6 +1959,12 @@ const runningActions = new Map();
  * @returns
  */
 function createActionTrackingMiddleware(hooks) {
+    // per middleware, not per module: the entries hold the `context` this
+    // middleware's own onStart returned, so two middlewares on one tree would
+    // otherwise overwrite each other's context and then delete the shared entry —
+    // whichever saw `flow_return` second dereferenced `undefined`.
+    // createActionTrackingMiddleware2 scopes its map the same way.
+    const runningActions = new Map();
     return function actionTrackingMiddleware(call, next, _abort) {
         switch (call.type) {
             case "action": {
@@ -2681,10 +2669,6 @@ function safeStringify(value) {
         return `<Unserializable: ${e}>`;
     }
 }
-/**
- * @internal
- * @hidden
- */
 function prettyPrintValue(value) {
     return typeof value === "function"
         ? `<function${value.name ? ` ${value.name}` : ""}>`
@@ -2699,6 +2683,8 @@ function shortenPrintValue(valueInString) {
 }
 function toErrorString(error) {
     const { value } = error;
+    // every context entry carries a type: they are built by getContextForPath and
+    // by typecheck's initial `[{ path: "", type }]`
     const type = error.context[error.context.length - 1].type;
     const fullPath = error.context
         .map(({ path }) => path)
@@ -2710,14 +2696,17 @@ function toErrorString(error) {
         : isPrimitive(value)
             ? "value"
             : "snapshot";
-    const isSnapshotCompatible = type && isStateTreeNode(value) && type.is(getStateTreeNode(value).snapshot);
-    return `${pathPrefix}${currentTypename} ${shortenPrintValue(prettyPrintValue(value))} is not assignable ${type ? `to type: \`${type.name}\`` : ``}${error.message ? ` (${error.message})` : ""}${type
-        ? isPrimitiveType(type) || isPrimitive(value)
-            ? `.`
-            : `, expected an instance of \`${type.name}\` or a snapshot like \`${shortenPrintValue(type.describe())}\` instead.${isSnapshotCompatible
-                ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
-                : ""}`
-        : `.`}`;
+    let expectation;
+    if (isPrimitiveType(type) || isPrimitive(value)) {
+        expectation = ".";
+    }
+    else {
+        const isSnapshotCompatible = isStateTreeNode(value) && type.is(getStateTreeNode(value).snapshot);
+        expectation = `, expected an instance of \`${type.name}\` or a snapshot like \`${shortenPrintValue(type.describe())}\` instead.${isSnapshotCompatible
+            ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
+            : ""}`;
+    }
+    return `${pathPrefix}${currentTypename} ${shortenPrintValue(prettyPrintValue(value))} is not assignable to type: \`${type.name}\`${error.message ? ` (${error.message})` : ""}${expectation}`;
 }
 /**
  * @internal
@@ -2994,7 +2983,7 @@ function getStateTreeNode(value) {
  * @hidden
  */
 function getStateTreeNodeSafe(value) {
-    return value?.$treenode || null;
+    return value?.["$treenode"] || null;
 }
 /**
  * @internal
@@ -3306,9 +3295,6 @@ class EventHandler {
             this.handlers.splice(index, 1);
         }
     }
-    clear() {
-        this.handlers.length = 0;
-    }
     emit(...args) {
         const handlers = this.handlers;
         // 0 and 1 handlers are by far the common cases (a patch/snapshot listener, a
@@ -3453,21 +3439,6 @@ function assertIsString(value, argNumber, canBeEmpty = true) {
         assertArg(value, s => s !== "", "not empty string", argNumber);
     }
 }
-/**
- * @internal
- * @hidden
- */
-function setImmediateWithFallback(fn) {
-    if (typeof queueMicrotask === "function") {
-        queueMicrotask(fn);
-    }
-    else if (typeof setImmediate === "function") {
-        setImmediate(fn);
-    }
-    else {
-        setTimeout(fn, 1);
-    }
-}
 
 /**
  * See [asynchronous actions](concepts/async-actions.md).
@@ -3538,14 +3509,12 @@ function toGeneratorFunction(p) {
 function* toGenerator(p) {
     return (yield p);
 }
-/**
- * @internal
- * @hidden
- */
 function createFlowSpawner(name, generator) {
     const spawner = function flowSpawner(...flowArgs) {
         // Implementation based on https://github.com/tj/co/blob/master/index.js
         const runId = getNextActionId();
+        // no `!`: the guard below is the point, and asserting non-null first made it
+        // dead to the checker while leaving it live at runtime
         const parentContext = getCurrentActionContext();
         if (!parentContext) {
             throw fail("a mst flow must always have a parent context");
@@ -3597,7 +3566,7 @@ function createFlowSpawner(name, generator) {
                 }
                 catch (e) {
                     // prettier-ignore
-                    setImmediateWithFallback(() => {
+                    queueMicrotask(() => {
                         wrap((_r) => { reject(e); }, "flow_throw", e);
                     });
                     return;
@@ -3613,7 +3582,7 @@ function createFlowSpawner(name, generator) {
                 }
                 catch (e) {
                     // prettier-ignore
-                    setImmediateWithFallback(() => {
+                    queueMicrotask(() => {
                         wrap((_r) => { reject(e); }, "flow_throw", e);
                     });
                     return;
@@ -3623,7 +3592,7 @@ function createFlowSpawner(name, generator) {
             function next(ret) {
                 if (ret.done) {
                     // prettier-ignore
-                    setImmediateWithFallback(() => {
+                    queueMicrotask(() => {
                         wrap((r) => { resolve(r); }, "flow_return", ret.value);
                     });
                     return;
@@ -3651,10 +3620,6 @@ function splitPatch(patch) {
     }
     return [stripPatch(patch), invertPatch(patch)];
 }
-/**
- * @internal
- * @hidden
- */
 function stripPatch(patch) {
     // strips `oldvalue` information from the patch, so that it becomes a patch conform the json-patch spec
     // this removes the ability to undo the patch
@@ -3814,8 +3779,10 @@ class SnapshotProcessor extends BaseType {
         return sn;
     }
     _fixNode(node) {
-        // the node has to use these methods rather than the original type ones
-        proxyNodeTypeMethods(node.type, this, "create");
+        // 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.hasSnapshotPostProcessor = !!this._processors.postProcessor;
         }
@@ -3884,11 +3851,6 @@ class SnapshotProcessor extends BaseType {
         return this._subtype.isMatchingSnapshotId(current, processedSn);
     }
 }
-function proxyNodeTypeMethods(nodeType, snapshotProcessorType, ...methods) {
-    for (const method of methods) {
-        nodeType[method] = snapshotProcessorType[method].bind(snapshotProcessorType);
-    }
-}
 /**
  * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.
  *
@@ -3939,6 +3901,41 @@ function snapshotProcessor(type, processors, name) {
     return new SnapshotProcessor(type, processors, name);
 }
 
+/**
+ * Append `hooks` to a collection type's initializer list. `EMPTY_ARRAY` is the
+ * shared default, so a type that never calls `.hooks()` allocates nothing.
+ *
+ * @internal
+ * @hidden
+ */
+function appendHookInitializer(current, hooks) {
+    return current.length > 0 ? [...current, hooks] : [hooks];
+}
+/**
+ * Install every hook the type's initializers produce onto `instance` as an MST
+ * action, mirroring how a model's `.actions()` members are attached.
+ *
+ * @internal
+ * @hidden
+ */
+function installHookInitializers(hookInitializers, instance) {
+    const addProp = !devMode() ? addHiddenFinalProp : addHiddenWritableProp;
+    for (const initializer of hookInitializers) {
+        const hooks = initializer(instance);
+        for (const name of Object.keys(hooks)) {
+            const hook = hooks[name];
+            addProp(instance, name, createActionInvoker(instance, name, hook));
+        }
+    }
+}
+/**
+ * The empty initializer list every collection type starts with.
+ *
+ * @internal
+ * @hidden
+ */
+const NO_HOOK_INITIALIZERS = EMPTY_ARRAY;
+
 const needsIdentifierError = `Map.put can only be used to store complex values that have an identifier type attribute`;
 function tryCollectModelTypes(type, modelTypes) {
     const subtypes = type.getSubTypes();
@@ -3969,13 +3966,6 @@ var MapIdentifierMode;
     MapIdentifierMode[MapIdentifierMode["NO"] = 2] = "NO";
 })(MapIdentifierMode || (MapIdentifierMode = {}));
 class MSTMap extends mobx.ObservableMap {
-    constructor(initialData, name) {
-        // mobx's default (deep) enhancer. The old `observable.ref.enhancer` arg
-        // read undefined ever since mobx 6 renamed the field to `options_.enhancer`,
-        // so deep has been the effective behavior all along; mobx 7 dropped
-        // `observable.ref` entirely.
-        super(initialData, undefined, name);
-    }
     get(key) {
         // maybe this is over-enthousiastic? normalize numeric keys to strings
         return super.get(`${key}`);
@@ -4035,24 +4025,21 @@ class MSTMap extends mobx.ObservableMap {
  */
 class MapType extends ComplexType {
     _subType;
+    hookInitializers;
     identifierMode = MapIdentifierMode.UNKNOWN;
     mapIdentifierAttribute = undefined;
     flags = TypeFlags.Map;
-    hookInitializers = [];
-    constructor(_subType, hookInitializers = []) {
+    constructor(_subType, hookInitializers = NO_HOOK_INITIALIZERS) {
         super();
         this._subType = _subType;
-        this._determineIdentifierMode();
         this.hookInitializers = hookInitializers;
+        this._determineIdentifierMode();
     }
     computeName() {
         return `Map<string, ${this._subType.name}>`;
     }
     hooks(hooks) {
-        const hookInitializers = this.hookInitializers.length > 0
-            ? this.hookInitializers.concat(hooks)
-            : [hooks];
-        return new MapType(this._subType, hookInitializers);
+        return new MapType(this._subType, appendHookInitializer(this.hookInitializers, hooks));
     }
     instantiate(parent, subpath, environment, initialValue) {
         this._determineIdentifierMode();
@@ -4091,25 +4078,15 @@ class MapType extends ComplexType {
         return result;
     }
     createNewInstance(childNodes) {
-        return new MSTMap(childNodes, this.name);
+        // undefined is mobx's enhancer argument, left at its deep default
+        return new MSTMap(childNodes, undefined, this.name);
     }
     finalizeNewInstance(node, instance) {
         mobx._interceptReads(instance, node.unbox);
-        const type = node.type;
-        type.hookInitializers.forEach(initializer => {
-            const hooks = initializer(instance);
-            Object.keys(hooks).forEach(name => {
-                const hook = hooks[name];
-                const actionInvoker = createActionInvoker(instance, name, hook);
-                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
-            });
-        });
+        installHookInitializers(node.type.hookInitializers, instance);
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
-    describe() {
-        return this.name;
-    }
     getChildren(node) {
         // return (node.storedValue as ObservableMap<any>).values()
         return mobx.values(node.storedValue);
@@ -4286,6 +4263,7 @@ MapType.prototype.applySnapshot = mobx.action(MapType.prototype.applySnapshot);
  * @returns
  */
 function map(subtype) {
+    assertIsType(subtype, 1);
     return new MapType(subtype);
 }
 /**
@@ -4304,9 +4282,9 @@ function isMapType(type) {
  */
 class ArrayType extends ComplexType {
     _subType;
+    hookInitializers;
     flags = TypeFlags.Array;
-    hookInitializers = [];
-    constructor(_subType, hookInitializers = []) {
+    constructor(_subType, hookInitializers = NO_HOOK_INITIALIZERS) {
         super();
         this._subType = _subType;
         this.hookInitializers = hookInitializers;
@@ -4315,10 +4293,7 @@ class ArrayType extends ComplexType {
         return `${this._subType.name}[]`;
     }
     hooks(hooks) {
-        const hookInitializers = this.hookInitializers.length > 0
-            ? this.hookInitializers.concat(hooks)
-            : [hooks];
-        return new ArrayType(this._subType, hookInitializers);
+        return new ArrayType(this._subType, appendHookInitializer(this.hookInitializers, hooks));
     }
     instantiate(parent, subpath, environment, initialValue) {
         return createObjectNode(this, parent, subpath, environment, initialValue);
@@ -4338,21 +4313,10 @@ class ArrayType extends ComplexType {
     }
     finalizeNewInstance(node, instance) {
         mobx._getAdministration(instance).dehancer = node.unbox;
-        const type = node.type;
-        type.hookInitializers.forEach(initializer => {
-            const hooks = initializer(instance);
-            Object.keys(hooks).forEach(name => {
-                const hook = hooks[name];
-                const actionInvoker = createActionInvoker(instance, name, hook);
-                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
-            });
-        });
+        installHookInitializers(node.type.hookInitializers, instance);
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
-    describe() {
-        return this.name;
-    }
     getChildren(node) {
         return node.storedValue.slice();
     }
@@ -4722,11 +4686,10 @@ function getPropObservables(storedValue) {
 function objectTypeToString() {
     return getStateTreeNode(this).toString();
 }
-const defaultObjectOptions = {
-    name: "AnonymousModel"};
+const ANONYMOUS_MODEL_NAME = "AnonymousModel";
 /**
- * A plain loop rather than `forAllProps`, which allocated a closure and made an
- * indirect call per property. This runs once per `types.model()` over every
+ * A plain loop rather than a callback per property, which allocated a closure
+ * and made an indirect call. This runs once per `types.model()` over every
  * declared property, and jbrowse builds a ~40-slot schema per track.
  */
 function findIdentifierAttribute(properties, propertyNames) {
@@ -4809,7 +4772,7 @@ class ModelType extends ComplexType {
         // `??`, not `||`: `types.model("", {})` names the model "". The old
         // `Object.assign(this, defaults, opts)` below overwrote the `||` fallback
         // with opts.name afterwards, so that only worked by accident.
-        super(opts.name ?? defaultObjectOptions.name);
+        super(opts.name ?? ANONYMOUS_MODEL_NAME);
         // Every field is assigned here, unconditionally and in a fixed order,
         // rather than by `Object.assign(this, defaultObjectOptions, opts)`. `opts`
         // carries a different key set at each of the three call sites — `model()`,
@@ -4924,12 +4887,6 @@ class ModelType extends ComplexType {
             (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(self, name, actionInvoker);
         });
     }
-    named = name => {
-        return this.cloneAndEnhance({ name });
-    };
-    props = properties => {
-        return this.cloneAndEnhance({ properties });
-    };
     volatile(fn) {
         if (typeof fn !== "function") {
             throw fail(`You passed an ${typeof fn} to volatile state as an argument, when function is expected`);
@@ -4949,19 +4906,7 @@ class ModelType extends ComplexType {
     }
     extend(fn) {
         const initializer = (self) => {
-            const { actions, views, state, ...rest } = fn(self);
-            for (const key in rest) {
-                throw fail(`The \`extend\` function should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '${key}'`);
-            }
-            if (state) {
-                this.instantiateVolatileState(self, state);
-            }
-            if (views) {
-                this.instantiateViews(self, views);
-            }
-            if (actions) {
-                this.instantiateActions(self, actions);
-            }
+            this.applyExtension(self, fn(self), "The `extend` function");
             return self;
         };
         return this.cloneAndEnhance({ initializers: [initializer] });
@@ -4982,9 +4927,17 @@ class ModelType extends ComplexType {
      * are permitted (see extendInstance, which runs this in an action context).
      */
     applyExtensionToInstance(self, extension) {
+        this.applyExtension(self, extension, "extendInstance");
+    }
+    /**
+     * Materializes an `{ actions, views, state }` bundle onto an instance. Shared
+     * by `.extend()` (at creation time) and `applyExtensionToInstance` (on a live
+     * instance); `subject` only names the caller in the invalid-key error.
+     */
+    applyExtension(self, extension, subject) {
         const { actions, views, state, ...rest } = extension;
         for (const key in rest) {
-            throw fail(`extendInstance should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '${key}'`);
+            throw fail(`${subject} should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '${key}'`);
         }
         if (state) {
             this.instantiateVolatileState(self, state);
@@ -5016,28 +4969,6 @@ class ModelType extends ComplexType {
             }
         });
     }
-    preProcessSnapshot = preProcessor => {
-        const currentPreprocessor = this.preProcessor;
-        if (!currentPreprocessor) {
-            return this.cloneAndEnhance({ preProcessor });
-        }
-        else {
-            return this.cloneAndEnhance({
-                preProcessor: snapshot => currentPreprocessor(preProcessor(snapshot))
-            });
-        }
-    };
-    postProcessSnapshot = postProcessor => {
-        const currentPostprocessor = this.postProcessor;
-        if (!currentPostprocessor) {
-            return this.cloneAndEnhance({ postProcessor });
-        }
-        else {
-            return this.cloneAndEnhance({
-                postProcessor: snapshot => postProcessor(currentPostprocessor(snapshot))
-            });
-        }
-    };
     instantiate(parent, subpath, environment, initialValue) {
         const value = isStateTreeNode(initialValue)
             ? initialValue
@@ -5048,10 +4979,11 @@ class ModelType extends ComplexType {
     }
     initializeChildNodes(objNode, initialSnapshot = {}) {
         const type = objNode.type;
+        const properties = type.properties;
         const result = {};
-        type.forAllProps((name, childType) => {
-            result[name] = childType.instantiate(objNode, name, undefined, initialSnapshot[name]);
-        });
+        for (const name of type.propertyNames) {
+            result[name] = properties[name].instantiate(objNode, name, undefined, initialSnapshot[name]);
+        }
         return result;
     }
     createNewInstance(childNodes) {
@@ -5070,9 +5002,9 @@ class ModelType extends ComplexType {
             }
         }
         else {
-            this.forAllProps(name => {
+            for (const name of this.propertyNames) {
                 mobx._interceptReads(instance, name, node.unbox);
-            });
+            }
         }
         this.initializers.reduce((self, fn) => fn(self), instance);
         // views, actions and volatile share the instance namespace with properties,
@@ -5083,12 +5015,12 @@ class ModelType extends ComplexType {
         // function/value stops being observable at all. The flag is only set on
         // success so a broken type keeps throwing on every create.
         if (!this.duplicateKeysChecked) {
-            this.forAllProps(name => {
+            for (const name of this.propertyNames) {
                 if (mobx.isComputedProp(instance, name) ||
                     !mobx.isObservableProp(instance, name)) {
                     throw fail(`${name} property is declared twice`);
                 }
-            });
+            }
             this.duplicateKeysChecked = true;
         }
         mobx.intercept(instance, this.willChange);
@@ -5141,24 +5073,16 @@ class ModelType extends ComplexType {
         }
         return res;
     }
-    /**
-     * Same as {@link getChildNode} but for a key already known to be a declared
-     * property (callers iterating `propertyNames`), so the membership guard is
-     * skipped.
-     */
-    getPropertyNode(node, key) {
+    getChildNode(node, key) {
+        if (!(key in this.properties)) {
+            throw fail(`Not a value property: ${key}`);
+        }
         const childNode = getPropObservable(node.storedValue, key).raw();
         if (!childNode) {
             throw fail(`Node not available for property ${key}`);
         }
         return childNode;
     }
-    getChildNode(node, key) {
-        if (!(key in this.properties)) {
-            throw fail(`Not a value property: ${key}`);
-        }
-        return this.getPropertyNode(node, key);
-    }
     getSnapshot(node, applyPostProcess = true) {
         const res = {};
         const storedValue = node.storedValue;
@@ -5210,9 +5134,9 @@ class ModelType extends ComplexType {
     applySnapshot(node, snapshot) {
         typecheckInternal(this, snapshot);
         const preProcessedSnapshot = this.applySnapshotPreProcessor(snapshot);
-        this.forAllProps(name => {
+        for (const name of this.propertyNames) {
             node.storedValue[name] = preProcessedSnapshot[name];
-        });
+        }
     }
     applySnapshotPreProcessor(snapshot) {
         const processor = this.preProcessor;
@@ -5245,12 +5169,6 @@ class ModelType extends ComplexType {
         }
         return typeCheckSuccess();
     }
-    forAllProps(fn) {
-        const properties = this.properties;
-        for (const key of this.propertyNames) {
-            fn(key, properties[key]);
-        }
-    }
     describe() {
         // optimization: cache
         return `{ ${this.propertyNames
@@ -5265,6 +5183,38 @@ class ModelType extends ComplexType {
     }
 }
 ModelType.prototype.applySnapshot = mobx.action(ModelType.prototype.applySnapshot);
+// Chain steps shared by every model type; see the field declarations in the
+// class for why they are not own slots.
+Object.assign(ModelType.prototype, {
+    named(name) {
+        return this.cloneAndEnhance({ name });
+    },
+    props(properties) {
+        return this.cloneAndEnhance({ properties });
+    },
+    preProcessSnapshot(preProcessor) {
+        const currentPreprocessor = this.preProcessor;
+        if (!currentPreprocessor) {
+            return this.cloneAndEnhance({ preProcessor });
+        }
+        else {
+            return this.cloneAndEnhance({
+                preProcessor: snapshot => currentPreprocessor(preProcessor(snapshot))
+            });
+        }
+    },
+    postProcessSnapshot(postProcessor) {
+        const currentPostprocessor = this.postProcessor;
+        if (!currentPostprocessor) {
+            return this.cloneAndEnhance({ postProcessor });
+        }
+        else {
+            return this.cloneAndEnhance({
+                postProcessor: snapshot => postProcessor(currentPostprocessor(snapshot))
+            });
+        }
+    }
+});
 /**
  * `types.model` - Creates a new model type by providing a name, properties, volatile state and actions.
  *
@@ -5274,7 +5224,7 @@ function model(...args) {
     if (devMode() && typeof args[0] !== "string" && args[1]) {
         throw fail("Model creation failed. First argument must be a string when two arguments are provided");
     }
-    const name = typeof args[0] === "string" ? args.shift() : "AnonymousModel";
+    const name = typeof args[0] === "string" ? args.shift() : ANONYMOUS_MODEL_NAME;
     const properties = args.shift() || {};
     return new ModelType({ name, properties });
 }
@@ -5288,7 +5238,7 @@ function model(...args) {
 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] : "AnonymousModel";
+    const typeName = hasTypename ? args[0] : ANONYMOUS_MODEL_NAME;
     if (hasTypename) {
         args.shift();
     }
@@ -5375,9 +5325,6 @@ class CoreType extends SimpleType {
         this.checker = checker;
         this.initializer = initializer;
     }
-    describe() {
-        return this.name;
-    }
     instantiate(parent, subpath, environment, initialValue) {
         return createScalarNode(this, parent, subpath, environment, initialValue);
     }
@@ -5514,6 +5461,12 @@ 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.
+ *
  * @param type
  * @returns
  */
@@ -5538,15 +5491,15 @@ class Literal extends SimpleType {
     value;
     flags = TypeFlags.Literal;
     constructor(value) {
-        super(JSON.stringify(value));
+        super();
         this.value = value;
     }
+    computeName() {
+        return JSON.stringify(this.value);
+    }
     instantiate(parent, subpath, environment, initialValue) {
         return createScalarNode(this, parent, subpath, environment, initialValue);
     }
-    describe() {
-        return JSON.stringify(this.value);
-    }
     isValidSnapshot(value, context) {
         if (isPrimitive(value) && value === this.value) {
             return typeCheckSuccess();
@@ -5578,6 +5531,12 @@ 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.
+ *
  * @param type
  * @returns
  */
@@ -5598,9 +5557,6 @@ class Refinement extends BaseType {
         this._predicate = _predicate;
         this._message = _message;
     }
-    describe() {
-        return this.name;
-    }
     instantiate(parent, subpath, environment, initialValue) {
         // create the child type
         return this._subtype.instantiate(parent, subpath, environment, initialValue);
@@ -5657,6 +5613,12 @@ 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.
+ *
  * @param type
  * @returns
  */
@@ -5726,6 +5688,16 @@ function resolveModelType(type) {
     }
     return 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
+// object and a `$treenode` probe per property, per candidate member. A real
+// `Literal` stores its primitive, and its isValidSnapshot is exactly value
+// equality against it, so compare directly. The `instanceof` gate is load
+// bearing: wrappers (optional, refinement, snapshotProcessor, late, union)
+// inherit the Literal flag from what they wrap and must keep the full check.
+function matchesLiteral(type, value) {
+    return type instanceof Literal ? type.value === value : type.is(value);
+}
 /**
  * @internal
  * @hidden
@@ -5843,10 +5815,10 @@ class Union extends BaseType {
             if (!model) {
                 continue;
             }
-            const typeProp = model.properties.type;
+            const typeProp = model.properties["type"];
             if (!typeProp ||
                 !(typeProp.flags & TypeFlags.Literal) ||
-                !typeProp.is(discriminator)) {
+                !matchesLiteral(typeProp, discriminator)) {
                 continue;
             }
             if (found) {
@@ -5866,7 +5838,7 @@ class Union extends BaseType {
             this._allMembersDiscriminated = this._types.every(t => {
                 const model = resolveModelType(t);
                 const typeProp = model &&
-                    model.properties.type;
+                    model.properties["type"];
                 return !!typeProp && (typeProp.flags & TypeFlags.Literal) !== 0;
             });
         }
@@ -5940,7 +5912,7 @@ class Union extends BaseType {
             }
             // for literals, check exact value match
             if (flags & TypeFlags.Literal) {
-                if (type.is(value)) {
+                if (matchesLiteral(type, value)) {
                     return type;
                 }
             }
@@ -5972,7 +5944,7 @@ class Union extends BaseType {
                 // for literal types, verify the value matches exactly
                 // this is critical for discriminated unions
                 if (flags & TypeFlags.Literal) {
-                    if (!propType.is(propValue)) {
+                    if (!matchesLiteral(propType, propValue)) {
                         return false;
                     }
                 }
@@ -5994,7 +5966,8 @@ class Union extends BaseType {
         // - A failure is the definitive, scoped error only when every member is
         //   discriminated; otherwise a catch-all could still accept the value, so
         //   fall through to full validation.
-        if (isPlainObject(value) && !isStateTreeNode(value)) {
+        const isSnapshotObject = isPlainObject(value) && !isStateTreeNode(value);
+        if (isSnapshotObject) {
             const discriminator = value.type;
             if (typeof discriminator === "string") {
                 const candidate = this._findCandidateByTypeDiscriminator(discriminator);
@@ -6010,7 +5983,7 @@ class Union extends BaseType {
         // for plain-object snapshots, prefer union members whose literal-typed
         // discriminator properties match the value (e.g. {type: "MsaView"})
         // so error output is scoped to the intended branch instead of every member
-        const candidates = isPlainObject(value) && !isStateTreeNode(value)
+        const candidates = isSnapshotObject
             ? this._types.filter(t => this.snapshotLooksLikeType(value, t))
             : [];
         const typesToValidate = candidates.length > 0 ? candidates : this._types;
@@ -6047,6 +6020,22 @@ Object.assign(Union.prototype, {
     _discriminatorCache: undefined,
     _allMembersDiscriminated: undefined
 });
+const unionInternRoot = {};
+function internUnion(types) {
+    let node = unionInternRoot;
+    for (const type of types) {
+        const level = (node.next ??= new WeakMap());
+        const existing = level.get(type);
+        if (existing) {
+            node = existing;
+        }
+        else {
+            node = {};
+            level.set(type, node);
+        }
+    }
+    return (node.union ??= new Union(types));
+}
 /**
  * `types.union` - Create a union of multiple types. If the correct type cannot be inferred unambiguously from a snapshot, provide a dispatcher function of the form `(snapshot) => Type`.
  *
@@ -6075,11 +6064,17 @@ function union(...args) {
             assertIsType(type, options ? i + 2 : i + 1);
         });
     }
-    return new Union(types, options);
+    return options === undefined ? internUnion(types) : new Union(types, options);
 }
 /**
  * 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.
+ *
  * @param type
  * @returns
  */
@@ -6258,13 +6253,41 @@ const undefinedAsOptionalValues = [undefined];
 /**
  * Returns if a value represents an optional type.
  *
- * @template IT
+ * 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.
+ *
  * @param type
  * @returns
  */
 function isOptionalType(type) {
     return isType(type) && (type.flags & TypeFlags.Optional) > 0;
 }
+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.
@@ -6343,6 +6366,22 @@ function defaultSnapshotEquals(a, b) {
  * @internal
  */
 class StripDefaultValue extends OptionalValue {
+    equalsDefault(snapshot, defaultSnapshot) {
+        let identifierAttribute = this._identifierAttribute;
+        if (identifierAttribute === undefined) {
+            identifierAttribute = resolveIdentifierAttribute(this.getSubTypes());
+            this._identifierAttribute = identifierAttribute;
+        }
+        // an identified model's snapshot normally has the same shape as the default
+        // and differs only here, so answering from one key beats walking every key
+        // (including nested objects) until the walk reaches it
+        return identifierAttribute !== null &&
+            isRecord(snapshot) &&
+            isRecord(defaultSnapshot) &&
+            snapshot[identifierAttribute] !== defaultSnapshot[identifierAttribute]
+            ? false
+            : defaultSnapshotEquals(snapshot, defaultSnapshot);
+    }
     shouldStripFromSnapshot(snapshot) {
         if (!this._defaultSnapshot) {
             // instantiate the subtype detached with the default and read the node's
@@ -6351,11 +6390,35 @@ class StripDefaultValue extends OptionalValue {
             const node = this.getSubTypes().instantiate(null, "", undefined, this.getDefaultInstanceOrSnapshot());
             this._defaultSnapshot = { value: node.snapshot };
         }
-        return defaultSnapshotEquals(snapshot, this._defaultSnapshot.value);
+        const defaultSnapshot = this._defaultSnapshot.value;
+        let result;
+        if (isRecord(snapshot)) {
+            // a child node's snapshot is a keepAlive computed, so a stable reference
+            // means unchanged content: the same object always gets the same answer
+            let cache = this._equalsDefaultCache;
+            if (!cache) {
+                cache = new WeakMap();
+                this._equalsDefaultCache = cache;
+            }
+            const cached = cache.get(snapshot);
+            if (cached === undefined) {
+                result = this.equalsDefault(snapshot, defaultSnapshot);
+                cache.set(snapshot, result);
+            }
+            else {
+                result = cached;
+            }
+        }
+        else {
+            result = defaultSnapshotEquals(snapshot, defaultSnapshot);
+        }
+        return result;
     }
 }
 Object.assign(StripDefaultValue.prototype, {
-    _defaultSnapshot: undefined
+    _defaultSnapshot: undefined,
+    _identifierAttribute: undefined,
+    _equalsDefaultCache: undefined
 });
 /**
  * Whether `type` is a strip-default optional whose current child `snapshot`
@@ -6504,6 +6567,12 @@ function late(nameOrType, maybeType) {
 /**
  * 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.
+ *
  * @param type
  * @returns
  */
@@ -6672,6 +6741,12 @@ 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.
+ *
  * @param type
  * @returns
  */
@@ -6762,9 +6837,6 @@ class BaseReferenceType extends SimpleType {
     computeName() {
         return `reference(${this.targetType.name})`;
     }
-    describe() {
-        return this.name;
-    }
     isAssignableFrom(type) {
         return this.targetType.isAssignableFrom(type);
     }
@@ -6902,9 +6974,6 @@ class BaseReferenceType extends SimpleType {
  * @hidden
  */
 class IdentifierReferenceType extends BaseReferenceType {
-    constructor(targetType, onInvalidated) {
-        super(targetType, onInvalidated);
-    }
     getValue(storedRefNode) {
         if (!storedRefNode.isAlive) {
             return undefined;
@@ -7020,6 +7089,12 @@ 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.
+ *
  * @param type
  * @returns
  */
@@ -7098,9 +7173,6 @@ class IdentifierType extends BaseIdentifierType {
     constructor() {
         super(`identifier`, "string");
     }
-    describe() {
-        return `identifier`;
-    }
 }
 /**
  * @internal
@@ -7110,12 +7182,6 @@ class IdentifierNumberType extends BaseIdentifierType {
     constructor() {
         super("identifierNumber", "number");
     }
-    getSnapshot(node) {
-        return node.storedValue;
-    }
-    describe() {
-        return `identifierNumber`;
-    }
 }
 /**
  * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.
@@ -7152,6 +7218,12 @@ 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.
+ *
  * @param type
  * @returns
  */
@@ -7240,9 +7312,6 @@ class CustomType extends SimpleType {
         super(options.name);
         this.options = options;
     }
-    describe() {
-        return this.name;
-    }
     isValidSnapshot(value, context) {
         if (this.options.isTargetType(value)) {
             return typeCheckSuccess();
@@ -7451,6 +7520,7 @@ exports.addMiddleware = addMiddleware;
 exports.applyAction = applyAction;
 exports.applyPatch = applyPatch;
 exports.applySnapshot = applySnapshot;
+exports.cannotDetermineSubtype = cannotDetermineSubtype;
 exports.cast = cast;
 exports.castFlowReturn = castFlowReturn;
 exports.castToReferenceSnapshot = castToReferenceSnapshot;