@jbrowse/mobx-state-tree 6.3.0 → 6.5.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.
@@ -1197,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) {
@@ -1349,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;
@@ -1737,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";
 /**
@@ -1790,6 +1786,9 @@ class BaseType {
         // istanbul ignore next
         throw fail("unimplemented method");
     }
+    describe() {
+        return this.name;
+    }
     isAssignableFrom(type) {
         return type === this;
     }
@@ -1935,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
@@ -2670,10 +2669,6 @@ function safeStringify(value) {
         return `<Unserializable: ${e}>`;
     }
 }
-/**
- * @internal
- * @hidden
- */
 function prettyPrintValue(value) {
     return typeof value === "function"
         ? `<function${value.name ? ` ${value.name}` : ""}>`
@@ -2706,12 +2701,8 @@ function toErrorString(error) {
         expectation = ".";
     }
     else {
-        // `isPrimitiveType` is declared `(type: IT) => type is IT`, so its negative
-        // branch narrows to `never` rather than to "some non-primitive type"; the
-        // annotation restores the type it actually has here.
-        const complexType = type;
-        const isSnapshotCompatible = isStateTreeNode(value) && complexType.is(getStateTreeNode(value).snapshot);
-        expectation = `, expected an instance of \`${complexType.name}\` or a snapshot like \`${shortenPrintValue(complexType.describe())}\` instead.${isSnapshotCompatible
+        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)"
             : ""}`;
     }
@@ -2992,7 +2983,7 @@ function getStateTreeNode(value) {
  * @hidden
  */
 function getStateTreeNodeSafe(value) {
-    return value?.$treenode || null;
+    return value?.["$treenode"] || null;
 }
 /**
  * @internal
@@ -3304,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
@@ -3451,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).
@@ -3536,10 +3509,6 @@ 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
@@ -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
@@ -4001,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}`);
@@ -4120,7 +4078,8 @@ 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);
@@ -4128,9 +4087,6 @@ class MapType extends ComplexType {
         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);
@@ -4307,6 +4263,7 @@ MapType.prototype.applySnapshot = mobx.action(MapType.prototype.applySnapshot);
  * @returns
  */
 function map(subtype) {
+    assertIsType(subtype, 1);
     return new MapType(subtype);
 }
 /**
@@ -4360,9 +4317,6 @@ class ArrayType extends ComplexType {
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
-    describe() {
-        return this.name;
-    }
     getChildren(node) {
         return node.storedValue.slice();
     }
@@ -4734,8 +4688,8 @@ function objectTypeToString() {
 }
 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) {
@@ -4933,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`);
@@ -5021,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
@@ -5053,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) {
@@ -5075,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,
@@ -5088,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);
@@ -5146,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;
@@ -5215,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;
@@ -5250,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
@@ -5270,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.
  *
@@ -5380,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);
     }
@@ -5549,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();
@@ -5615,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);
@@ -5749,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
@@ -5776,7 +5725,7 @@ class Union extends BaseType {
             return cached;
         }
         let result = TypeFlags.Union;
-        for (const type of this._types) {
+        for (const type of this.members()) {
             result |= type.flags;
         }
         if (!(result & TypeFlags.Late)) {
@@ -5785,12 +5734,14 @@ class Union extends BaseType {
         return result;
     }
     computeName() {
-        return `(${this._types.map(type => type.name).join(" | ")})`;
+        return `(${this.members()
+            .map(type => type.name)
+            .join(" | ")})`;
     }
     constructor(_types, options) {
         super();
         this._types = _types;
-        // read the two options directly rather than spreading defaults into a fresh
+        // read the options directly rather than spreading defaults into a fresh
         // object: this constructor runs once per config slot in jbrowse, and the
         // merged object was allocated only to be read twice and dropped
         if (options !== undefined) {
@@ -5800,13 +5751,23 @@ class Union extends BaseType {
             if (options.eager === false) {
                 this._eager = false;
             }
+            if (options.name !== undefined) {
+                this.name = options.name;
+            }
         }
     }
+    // The one point membership is read through, so DynamicUnion can substitute
+    // its thunk without duplicating any of the scanning logic below.
+    members() {
+        return this._types;
+    }
     isAssignableFrom(type) {
-        return this._types.some(subType => subType.isAssignableFrom(type));
+        return this.members().some(subType => subType.isAssignableFrom(type));
     }
     describe() {
-        return `(${this._types.map(factory => factory.describe()).join(" | ")})`;
+        return `(${this.members()
+            .map(factory => factory.describe())
+            .join(" | ")})`;
     }
     instantiate(parent, subpath, environment, initialValue) {
         const type = this.determineType(initialValue, undefined);
@@ -5861,15 +5822,15 @@ class Union extends BaseType {
     }
     _scanForTypeDiscriminator(discriminator) {
         let found;
-        for (const t of this._types) {
+        for (const t of this.members()) {
             const model = resolveModelType(t);
             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) {
@@ -5886,15 +5847,18 @@ class Union extends BaseType {
     }
     allMembersDiscriminated() {
         if (this._allMembersDiscriminated === undefined) {
-            this._allMembersDiscriminated = this._types.every(t => {
-                const model = resolveModelType(t);
-                const typeProp = model &&
-                    model.properties.type;
-                return !!typeProp && (typeProp.flags & TypeFlags.Literal) !== 0;
-            });
+            this._allMembersDiscriminated = this.computeAllMembersDiscriminated();
         }
         return this._allMembersDiscriminated;
     }
+    computeAllMembersDiscriminated() {
+        return this.members().every(t => {
+            const model = resolveModelType(t);
+            const typeProp = model &&
+                model.properties["type"];
+            return !!typeProp && (typeProp.flags & TypeFlags.Literal) !== 0;
+        });
+    }
     determineType(value, reconcileCurrentType) {
         // try the dispatcher, if defined
         if (this._dispatcher) {
@@ -5915,9 +5879,9 @@ class Union extends BaseType {
             if (reconcileCurrentType.is(value)) {
                 return reconcileCurrentType;
             }
-            return this._types.find(type => type !== reconcileCurrentType && type.is(value));
+            return this.members().find(type => type !== reconcileCurrentType && type.is(value));
         }
-        return this._types.find(type => type.is(value));
+        return this.members().find(type => type.is(value));
     }
     tryQuickMatch(value, reconcileCurrentType) {
         // state tree nodes need full type compatibility checking
@@ -5937,7 +5901,7 @@ class Union extends BaseType {
             this.snapshotLooksLikeType(value, reconcileCurrentType)) {
             return reconcileCurrentType;
         }
-        for (const type of this._types) {
+        for (const type of this.members()) {
             if (type !== reconcileCurrentType &&
                 this.snapshotLooksLikeType(value, type)) {
                 return type;
@@ -5947,7 +5911,7 @@ class Union extends BaseType {
     }
     tryMatchPrimitive(value) {
         const valueType = typeof value;
-        for (const type of this._types) {
+        for (const type of this.members()) {
             const flags = type.flags;
             if ((valueType === "string" && flags & TypeFlags.String) ||
                 (valueType === "number" &&
@@ -5963,7 +5927,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;
                 }
             }
@@ -5995,7 +5959,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;
                     }
                 }
@@ -6034,10 +5998,11 @@ 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 members = this.members();
         const candidates = isSnapshotObject
-            ? this._types.filter(t => this.snapshotLooksLikeType(value, t))
+            ? members.filter(t => this.snapshotLooksLikeType(value, t))
             : [];
-        const typesToValidate = candidates.length > 0 ? candidates : this._types;
+        const typesToValidate = candidates.length > 0 ? candidates : members;
         const allErrors = [];
         let applicableTypes = 0;
         for (const type of typesToValidate) {
@@ -6060,7 +6025,7 @@ class Union extends BaseType {
         return typeCheckFailure(context, value, "No type is applicable for the union").concat(allErrors.flat());
     }
     getSubTypes() {
-        return this._types;
+        return this.members();
     }
 }
 // Defaults shared by every union; see the field declarations at the top of the
@@ -6071,9 +6036,82 @@ Object.assign(Union.prototype, {
     _discriminatorCache: undefined,
     _allMembersDiscriminated: undefined
 });
+/**
+ * @internal
+ * @hidden
+ *
+ * A union whose membership is read fresh from a thunk on every operation, so
+ * members that come into existence after the union was built — a registry of
+ * pluggable types whose modules load on demand — still dispatch, validate, and
+ * satisfy references. That last one is the reason this exists: reference
+ * resolution asks the target type `isAssignableFrom(node.type)` through the
+ * identifier cache, and a membership list frozen at construction would reject
+ * every late-loaded member's instances.
+ *
+ * Every membership-derived cache the base class keeps is bypassed here: flags
+ * and the folded name are recomputed per read, and the discriminator scan is
+ * uncached so a miss stays retryable once the missing member registers. A hit
+ * for a given discriminator is assumed stable — registering two members with
+ * the same `type` literal at different times can leave a stale unambiguous
+ * answer where the base class would have reported ambiguity.
+ */
+class DynamicUnion extends Union {
+    _members;
+    constructor(members, options) {
+        super([], options);
+        this._members = members;
+    }
+    members() {
+        return this._members();
+    }
+    get flags() {
+        let result = TypeFlags.Union;
+        for (const type of this.members()) {
+            result |= type.flags;
+        }
+        return result;
+    }
+    get name() {
+        return this._explicitName !== undefined
+            ? this._explicitName
+            : this.computeName();
+    }
+    set name(value) {
+        this._explicitName = value;
+    }
+    _findCandidateByTypeDiscriminator(discriminator) {
+        return this._scanForTypeDiscriminator(discriminator);
+    }
+    allMembersDiscriminated() {
+        return this.computeAllMembersDiscriminated();
+    }
+}
+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`.
  *
+ * Passing `members: () => Type[]` in the options (with no positional member
+ * types) creates a union whose membership is re-read from the thunk on every
+ * operation, so types registered after construction — e.g. from a lazily
+ * loaded module — participate in dispatch, validation and reference
+ * resolution. Pair it with a `dispatcher` for snapshot dispatch and a `name`
+ * for stable error messages.
+ *
  * @param optionsOrType
  * @param otherTypes
  * @returns
@@ -6093,13 +6131,19 @@ function union(...args) {
     // check all options
     if (devMode()) {
         if (options) {
-            assertArg(options, o => isPlainObject(o), "object { eager?: boolean, dispatcher?: Function }", 1);
+            assertArg(options, o => isPlainObject(o), "object { eager?: boolean, dispatcher?: Function, members?: Function, name?: string }", 1);
         }
         types.forEach((type, i) => {
             assertIsType(type, options ? i + 2 : i + 1);
         });
     }
-    return new Union(types, options);
+    if (options?.members !== undefined) {
+        if (types.length > 0) {
+            throw fail("union(): the members option cannot be combined with positional member types");
+        }
+        return new DynamicUnion(options.members, options);
+    }
+    return options === undefined ? internUnion(types) : new Union(types, options);
 }
 /**
  * Returns if a given value represents a union type.
@@ -6294,13 +6338,35 @@ const undefinedAsOptionalValues = [undefined];
  * to compile. Guards with a distinct narrowing target (`isArrayType`,
  * `isMapType`, `isModelType`) keep their predicate.
  *
- * @template IT
  * @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.
@@ -6379,6 +6445,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
@@ -6387,11 +6469,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`
@@ -6621,6 +6727,13 @@ class Lazy extends SimpleType {
     }
     reconcile(current, value, parent, subpath) {
         if (this.loadedType) {
+            // a node created after load carries the loaded type: let it reconcile so
+            // the instance survives applySnapshot instead of dying on every write
+            const loaded = this.loadedType;
+            const currentType = current.type;
+            if (currentType === loaded) {
+                return this.loadedType.reconcile(current, value, parent, subpath);
+            }
             current.die();
             return this.loadedType.instantiate(parent, subpath, parent.environment, value);
         }
@@ -6810,9 +6923,6 @@ class BaseReferenceType extends SimpleType {
     computeName() {
         return `reference(${this.targetType.name})`;
     }
-    describe() {
-        return this.name;
-    }
     isAssignableFrom(type) {
         return this.targetType.isAssignableFrom(type);
     }
@@ -7149,9 +7259,6 @@ class IdentifierType extends BaseIdentifierType {
     constructor() {
         super(`identifier`, "string");
     }
-    describe() {
-        return `identifier`;
-    }
 }
 /**
  * @internal
@@ -7161,12 +7268,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.
@@ -7297,9 +7398,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();
@@ -7508,6 +7606,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;