@jbrowse/mobx-state-tree 5.11.2 → 5.13.0

package/dist/index.d.ts

@@ -347,7 +347,7 @@ declare function getRelativePath(base: IAnyStateTreeNode, target: IAnyStateTreeN
  * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.
  * @returns
  */
-declare function clone<T extends IAnyStateTreeNode>(source: T, keepEnvironment?: boolean | any): T;
+declare function clone<T extends IAnyStateTreeNode>(source: T, keepEnvironment?: boolean | object): T;
 /**
  * Removes a model element from the state tree, and let it live on as a new state tree
  */
@@ -611,6 +611,7 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     private _cachedInitialSnapshot?;
     private _cachedInitialSnapshotCreated;
     private _snapshotComputed;
+    private _snapshotComputedEvaluated;
     constructor(complexType: ComplexType<C, S, T>, parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C);
     createObservableInstanceIfNeeded(fireHooks?: boolean): void;
     createObservableInstance(fireHooks?: boolean): void;
@@ -620,6 +621,17 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     protected fireHook(name: Hook): void;
     private _snapshotUponDeath?;
     get snapshot(): S;
+    /**
+     * @internal
+     * @hidden
+     * Recompute+retrack the keepAlive snapshot computed if it has already run.
+     * Needed whenever something changes what the snapshot would produce without
+     * an observable mobx would track: flipping the (non-observable) observable-
+     * instance state, or SnapshotProcessor rewriting getSnapshot after
+     * construction (see snapshotProcessor._fixNode). If it never ran, there is
+     * nothing cached to go stale, so this is a no-op.
+     */
+    refreshMemoizedSnapshot(): void;
     getSnapshot(): S;
     private _getActualSnapshot;
     private _getCachedInitialSnapshot;
@@ -1725,6 +1737,31 @@ declare function compose<PA extends ModelProperties, OA, FCA, FSA, PB extends Mo
  * @returns
  */
 declare function isModelType<IT extends IAnyModelType = IAnyModelType>(type: IAnyType): type is IT;
+/**
+ * `extendInstance` - attaches additional actions, views and volatile state to an
+ * already-created model instance, using the same instantiation machinery as
+ * `.extend()`. This enables lazily loading a model's views/actions chain: create
+ * the model with only its base props (plus any critical-path members), then attach
+ * the rest at runtime — e.g. from a dynamically imported module — without rebuilding
+ * the type or re-hydrating the tree.
+ *
+ * The extension is applied inside an action context, so it works on protected trees.
+ * Attached views are computeds (reactive, memoized) and attached actions get a full
+ * MST action context, exactly like members declared in the original chain.
+ *
+ * Note: the attached members are NOT part of the instance's *static* type. If you
+ * need them typed, declare the augmented shape separately (an `import type` of the
+ * chain's return type is erased at build time, so it costs nothing in the bundle).
+ *
+ * @param instance a live model instance
+ * @param fn receives the instance and returns `{ actions?, views?, state? }`
+ * @returns the same instance
+ */
+declare function extendInstance<T extends IAnyStateTreeNode>(instance: T, fn: (self: T) => {
+    actions?: ModelActions;
+    views?: object;
+    state?: object;
+}): T;
 
 /**
  * `types.Date` - Creates a type that can only contain a javascript Date value.
@@ -2139,5 +2176,5 @@ declare const types: {
     resilient: typeof resilient;
 };
 
-export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
+export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, extendInstance, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
 export type { $EmptyObjectBrand, CustomTypeOptions, IActionContext, IActionRecorder, IActionTrackingMiddleware2Call, IActionTrackingMiddleware2Hooks, IActionTrackingMiddlewareHooks, IAnyComplexType, IAnyModelType, IAnyStateTreeNode, IAnyType, IArrayType, IComplexType, IDisposer, IJsonPatch, IMSTArray, IMSTMap, IMapType, IMaybe, IMaybeIType, IMaybeNull, IMiddlewareEvent, IMiddlewareEventType, IMiddlewareHandler, IModelReflectionData, IModelReflectionPropertiesData, IModelType, IOptionalIType, IPatchRecorder, IReferenceType, IReversibleJsonPatch, ISerializedActionCall, ISimpleType, ISnapshotProcessor, ISnapshotProcessors, IStateTreeNode, IType, ITypeUnion, Instance, LivelinessMode, LivelynessMode, ModelActions, ModelCreationType, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPrimitive, ModelProperties, ModelPropertiesDeclaration, ModelPropertiesDeclarationToProperties, ModelSnapshotType, ModelSnapshotType2, OnReferenceInvalidated, OnReferenceInvalidatedEvent, OptionalDefaultValueOrFunction, ReferenceIdentifier, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, SnapshotIn, SnapshotOrInstance, SnapshotOut, TypeOfValue, TypeOrStateTreeNodeToStateTreeNode, UnionOptions, UnionStringArray, ValidOptionalValue, ValidOptionalValues, _CustomCSProcessor, _CustomJoin, _CustomOrOther, _NotCustomized };

package/dist/mobx-state-tree.cjs

@@ -766,10 +766,11 @@ function getMembers(target) {
             }
             return;
         }
-        if (descriptor.value._isFlowAction === true) {
+        const value = descriptor.value;
+        if (value?._isFlowAction === true) {
             reflected.flowActions.push(key);
         }
-        if (descriptor.value._isMSTAction === true) {
+        if (value?._isMSTAction === true) {
             reflected.actions.push(key);
         }
         else if (mobx.isObservableProp(target, key)) {
@@ -1138,6 +1139,10 @@ const snapshotReactionOptions = {
         throw e;
     }
 };
+// keepAlive lets the snapshot computed memoize its value even with no observer,
+// so getSnapshot() stays referentially stable without an eager snapshot
+// reaction serializing the whole tree at create time. Shared: mobx only reads it.
+const snapshotComputedOptions = { keepAlive: true };
 /**
  * @internal
  * @hidden
@@ -1170,9 +1175,18 @@ class ObjectNode extends BaseNode {
     _cachedInitialSnapshot;
     _cachedInitialSnapshotCreated = false;
     _snapshotComputed;
+    // whether _snapshotComputed has ever run — see createObservableInstance
+    _snapshotComputedEvaluated = false;
     constructor(complexType, parent, subpath, environment, initialValue) {
         super(complexType, parent, subpath, environment);
-        this._snapshotComputed = mobx.computed(() => freeze(this.getSnapshot()));
+        // keepAlive: memoize the snapshot after the first read even with no
+        // observer, so getSnapshot() is referentially stable (and reconcile-by-
+        // snapshot works) without eagerly serializing the whole tree at create
+        // time — the previous cost, driven by the eager root reaction below.
+        this._snapshotComputed = mobx.computed(() => {
+            this._snapshotComputedEvaluated = true;
+            return freeze(this.getSnapshot());
+        }, snapshotComputedOptions);
         this.unbox = this.unbox.bind(this);
         this._initialSnapshot = freeze(initialValue);
         this.identifierAttribute = complexType.identifierAttribute;
@@ -1256,10 +1270,17 @@ class ObjectNode extends BaseNode {
             this._isRunningAction = false;
         }
         this._observableInstanceState = ObservableInstanceLifecycle.CREATED;
-        this._snapshotComputed.trackAndCompute();
-        if (this.isRoot) {
-            this._addSnapshotReaction();
-        }
+        // The snapshot computed branches on the non-observable
+        // "_observableInstanceState" flag we just flipped, so a value already
+        // memoized from the initial snapshot is now stale (mobx can't see the
+        // change) — refresh it. When it was never read there is nothing to refresh,
+        // and forcing it here would serialize the whole subtree (the dominant cost
+        // of creating a root) for a value nobody has asked for yet, so we skip it.
+        this.refreshMemoizedSnapshot();
+        // The root's snapshot reaction only drives onSnapshot; set it up lazily
+        // (onSnapshot already does) rather than eagerly here, so a root nobody
+        // subscribes to never pays for a full-tree snapshot at creation. keepAlive
+        // on _snapshotComputed preserves snapshot referential stability without it.
         this._childNodes = EMPTY_OBJECT;
         this.state = NodeLifeCycle.CREATED;
         if (fireHooks) {
@@ -1364,6 +1385,21 @@ class ObjectNode extends BaseNode {
         }
         return this._snapshotComputed.get();
     }
+    /**
+     * @internal
+     * @hidden
+     * Recompute+retrack the keepAlive snapshot computed if it has already run.
+     * Needed whenever something changes what the snapshot would produce without
+     * an observable mobx would track: flipping the (non-observable) observable-
+     * instance state, or SnapshotProcessor rewriting getSnapshot after
+     * construction (see snapshotProcessor._fixNode). If it never ran, there is
+     * nothing cached to go stale, so this is a no-op.
+     */
+    refreshMemoizedSnapshot() {
+        if (this._snapshotComputedEvaluated) {
+            this._snapshotComputed.trackAndCompute();
+        }
+    }
     // NOTE: we use this method to get snapshot without creating @computed overhead
     getSnapshot() {
         if (!this.isAlive) {
@@ -1668,9 +1704,6 @@ ObjectNode.prototype.createObservableInstance = mobx.action(ObjectNode.prototype
 ObjectNode.prototype.detach = mobx.action(ObjectNode.prototype.detach);
 ObjectNode.prototype.die = mobx.action(ObjectNode.prototype.die);
 
-// Cache for validation results to avoid re-validating the same object against the same type
-// Uses WeakMap so cached objects can be garbage collected
-const validationCache = new WeakMap();
 /**
  * @internal
  * @hidden
@@ -1746,27 +1779,7 @@ class BaseType {
                 : typeCheckFailure(context, value);
             // it is tempting to compare snapshots, but in that case we should always clone on assignments...
         }
-        // check cache for object values (only at root level to avoid context mismatches)
-        if (typeof value === "object" && value !== null && context.length === 1) {
-            const typeCache = validationCache.get(value);
-            if (typeCache) {
-                const cached = typeCache.get(this);
-                if (cached !== undefined) {
-                    return cached;
-                }
-            }
-        }
-        const result = this.isValidSnapshot(value, context);
-        // cache result for object values (only at root level)
-        if (typeof value === "object" && value !== null && context.length === 1) {
-            let typeCache = validationCache.get(value);
-            if (!typeCache) {
-                typeCache = new WeakMap();
-                validationCache.set(value, typeCache);
-            }
-            typeCache.set(this, result);
-        }
-        return result;
+        return this.isValidSnapshot(value, context);
     }
     is(thing) {
         return this.validate(thing, [{ path: "", type: this }]).length === 0;
@@ -3241,8 +3254,6 @@ function addHiddenWritableProp(object, propName, value) {
  */
 class EventHandler {
     handlers = [];
-    emitting = false;
-    pendingUnregisters = null;
     get hasSubscribers() {
         return this.handlers.length > 0;
     }
@@ -3261,14 +3272,6 @@ class EventHandler {
         return this.handlers.includes(fn);
     }
     unregister(fn) {
-        if (this.emitting) {
-            // defer unregistration until emit is done
-            if (!this.pendingUnregisters) {
-                this.pendingUnregisters = [];
-            }
-            this.pendingUnregisters.push(fn);
-            return;
-        }
         const index = this.handlers.indexOf(fn);
         if (index >= 0) {
             this.handlers.splice(index, 1);
@@ -3278,26 +3281,10 @@ class EventHandler {
         this.handlers.length = 0;
     }
     emit(...args) {
-        // use emitting flag to defer unregistrations instead of copying array
-        this.emitting = true;
-        try {
-            for (const f of this.handlers) {
-                f(...args);
-            }
-        }
-        finally {
-            this.emitting = false;
-            // process any deferred unregistrations
-            if (this.pendingUnregisters) {
-                for (const fn of this.pendingUnregisters) {
-                    const index = this.handlers.indexOf(fn);
-                    if (index >= 0) {
-                        this.handlers.splice(index, 1);
-                    }
-                }
-                this.pendingUnregisters = null;
-            }
-        }
+        // iterate a copy so (un)registrations during emit don't disturb this pass
+        // and reentrant emits stay correct
+        const handlers = this.handlers.slice();
+        handlers.forEach(f => f(...args));
     }
 }
 /**
@@ -3360,6 +3347,11 @@ let _typeChecking;
 function setTypeChecking(enabled) {
     _typeChecking = enabled;
 }
+// the ENABLE_TYPE_CHECK env var is fixed at process start, so read it once:
+// process.env access is a comparatively expensive lookup and isTypeCheckingEnabled
+// runs on every create() / typed write. The setTypeChecking() override and
+// dev-mode default stay live below.
+const _envTypeCheck = typeof process !== "undefined" && process.env?.ENABLE_TYPE_CHECK === "true";
 /**
  * @internal
  * @hidden
@@ -3367,10 +3359,7 @@ function setTypeChecking(enabled) {
 function isTypeCheckingEnabled() {
     // an explicit setTypeChecking() override (incl. `false`) wins over the
     // dev-mode / env-var default, hence ?? rather than ||
-    return (_typeChecking ??
-        (devMode() ||
-            (typeof process !== "undefined" &&
-                process.env?.ENABLE_TYPE_CHECK === "true")));
+    return _typeChecking ?? (devMode() || _envTypeCheck);
 }
 let _devMode = process.env.NODE_ENV !== "production";
 /**
@@ -3773,6 +3762,11 @@ class SnapshotProcessor extends BaseType {
         }
         const oldGetSnapshot = node.getSnapshot;
         node.getSnapshot = () => this.postProcessSnapshot(oldGetSnapshot.call(node), node);
+        // getSnapshot was just rewritten; refresh any snapshot already memoized for
+        // this node (e.g. it was serialized before being moved under this processor)
+        if (node instanceof ObjectNode) {
+            node.refreshMemoizedSnapshot();
+        }
         if (!isUnionType(this._subtype)) {
             node.getReconciliationType = () => {
                 return this;
@@ -4450,6 +4444,23 @@ function array(subtype) {
 }
 function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
     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.
+    let idIndex;
+    if (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];
@@ -4493,13 +4504,26 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
             oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
         }
         else {
-            // nothing to do, try to reorder
+            // nothing to do, try to reorder: find a candidate old node to reuse
             let oldMatch = undefined;
-            // find a possible candidate to reuse
-            for (let j = i; j < oldNodes.length; j++) {
-                if (areSame(oldNodes[j], newValue)) {
+            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];
-                    break;
+                }
+            }
+            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;
+                    }
                 }
             }
             nothingChanged = false;
@@ -4659,14 +4683,33 @@ class ModelType extends ComplexType {
     preProcessor;
     postProcessor;
     propertyNames;
+    // member/property name collisions are a property of the type, so we only need
+    // to check the first instance we finalize (see finalizeNewInstance)
+    duplicateKeysChecked = false;
     constructor(opts) {
         super(opts.name || defaultObjectOptions.name);
         Object.assign(this, defaultObjectOptions, opts);
-        // ensures that any default value gets converted to its related type
-        this.properties = toPropertiesObject(this.properties);
-        freeze(this.properties); // make sure nobody messes with it
-        this.propertyNames = Object.keys(this.properties);
-        this.identifierAttribute = this._getIdentifierAttribute();
+        if (opts.propertiesArePreProcessed) {
+            // `properties` is a parent type's already-converted + frozen output
+            // (chain step with no new props), so its derived propertyNames and
+            // identifierAttribute are identical to the parent's — reuse them verbatim
+            // (cloneAndEnhance passed them in) instead of re-running Object.keys and
+            // the per-prop identifier scan, both O(props), on every step.
+            this.propertyNames = opts.propertyNames;
+            this.identifierAttribute = opts.identifierAttribute;
+        }
+        else {
+            // `propertiesAreConverted` (set by cloneAndEnhance when props are added)
+            // means every value is already a type — the parent's converted bag merged
+            // with a freshly converted delta — so skip re-converting. Only raw entry
+            // points (`model()`) still need the full toPropertiesObject pass.
+            if (!opts.propertiesAreConverted) {
+                this.properties = toPropertiesObject(this.properties);
+            }
+            freeze(this.properties); // make sure nobody messes with it
+            this.propertyNames = Object.keys(this.properties);
+            this.identifierAttribute = this._getIdentifierAttribute();
+        }
     }
     _getIdentifierAttribute() {
         let identifierAttribute = undefined;
@@ -4681,9 +4724,35 @@ class ModelType extends ComplexType {
         return identifierAttribute;
     }
     cloneAndEnhance(opts) {
+        // Fast path: a chain step that adds no new properties (.actions/.views/
+        // .volatile/.named/pre-postProcessor) reuses this type's already-converted +
+        // frozen properties (and their derived names/identifier) verbatim.
+        const hasNewProps = opts.properties !== undefined && Object.keys(opts.properties).length > 0;
+        if (!hasNewProps) {
+            return new ModelType({
+                name: opts.name || this.name,
+                properties: this.properties,
+                propertiesArePreProcessed: true,
+                // safe to share: propertyNames is never mutated after construction
+                propertyNames: this.propertyNames,
+                identifierAttribute: this.identifierAttribute,
+                initializers: this.initializers.concat(opts.initializers || []),
+                preProcessor: opts.preProcessor || this.preProcessor,
+                postProcessor: opts.postProcessor || this.postProcessor
+            });
+        }
+        // Adding props: this type's `properties` is already converted+frozen, so only
+        // the delta needs conversion. compose passes already-converted props
+        // (cur.properties) and flags them; `.props()` passes a raw declaration. Either
+        // way the merged bag is fully converted, so the constructor skips re-converting
+        // the (potentially large) inherited set — the previous hot spot in compose.
+        const convertedNewProps = opts.propertiesAreConverted
+            ? opts.properties
+            : toPropertiesObject(opts.properties);
         return new ModelType({
             name: opts.name || this.name,
-            properties: Object.assign({}, this.properties, opts.properties),
+            properties: Object.assign({}, this.properties, convertedNewProps),
+            propertiesAreConverted: true,
             initializers: this.initializers.concat(opts.initializers || []),
             preProcessor: opts.preProcessor || this.preProcessor,
             postProcessor: opts.postProcessor || this.postProcessor
@@ -4780,6 +4849,29 @@ class ModelType extends ComplexType {
         };
         return this.cloneAndEnhance({ initializers: [viewInitializer] });
     }
+    /**
+     * @internal
+     * @hidden
+     * Materializes an additional actions/views/state extension onto an
+     * already-created instance, using the same machinery as `.extend()` runs at
+     * creation time. Powers {@link extendInstance}; callers must ensure the writes
+     * are permitted (see extendInstance, which runs this in an action context).
+     */
+    applyExtensionToInstance(self, extension) {
+        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}'`);
+        }
+        if (state) {
+            this.instantiateVolatileState(self, state);
+        }
+        if (views) {
+            this.instantiateViews(self, views);
+        }
+        if (actions) {
+            this.instantiateActions(self, actions);
+        }
+    }
     instantiateViews(self, views) {
         // check views return
         if (!isPlainObject(views)) {
@@ -4848,6 +4940,21 @@ class ModelType extends ComplexType {
             mobx._interceptReads(instance, name, node.unbox);
         });
         this.initializers.reduce((self, fn) => fn(self), instance);
+        // views, actions and volatile share the instance namespace with properties,
+        // so a view/action reusing a property name silently clobbers that property's
+        // observable value. It's a type-level mistake (identical for every instance),
+        // so we check just the first one we finalize: a healthy property stays a
+        // plain observable, a shadowing getter becomes a computed, and a shadowing
+        // 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 => {
+                if (mobx.isComputedProp(instance, name) || !mobx.isObservableProp(instance, name)) {
+                    throw fail(`${name} property is declared twice`);
+                }
+            });
+            this.duplicateKeysChecked = true;
+        }
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
@@ -4902,14 +5009,7 @@ class ModelType extends ComplexType {
     getSnapshot(node, applyPostProcess = true) {
         const res = {};
         this.forAllProps((name, type) => {
-            try {
-                // TODO: FIXME, make sure the observable ref is used!
-                const atom = mobx.getAtom(node.storedValue, name);
-                atom.reportObserved();
-            }
-            catch (_e) {
-                throw fail(`${name} property is declared twice`);
-            }
+            mobx.getAtom(node.storedValue, name).reportObserved();
             const snapshot = this.getChildNode(node, name).snapshot;
             // strip-default optionals omit their key when equal to the default
             if (!shouldStripChildFromSnapshot(type, snapshot)) {
@@ -5032,6 +5132,8 @@ function compose(...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))
@@ -5047,6 +5149,46 @@ function compose(...args) {
 function isModelType(type) {
     return isType(type) && (type.flags & TypeFlags.Object) > 0;
 }
+/**
+ * `extendInstance` - attaches additional actions, views and volatile state to an
+ * already-created model instance, using the same instantiation machinery as
+ * `.extend()`. This enables lazily loading a model's views/actions chain: create
+ * the model with only its base props (plus any critical-path members), then attach
+ * the rest at runtime — e.g. from a dynamically imported module — without rebuilding
+ * the type or re-hydrating the tree.
+ *
+ * The extension is applied inside an action context, so it works on protected trees.
+ * Attached views are computeds (reactive, memoized) and attached actions get a full
+ * MST action context, exactly like members declared in the original chain.
+ *
+ * Note: the attached members are NOT part of the instance's *static* type. If you
+ * need them typed, declare the augmented shape separately (an `import type` of the
+ * chain's return type is erased at build time, so it costs nothing in the bundle).
+ *
+ * @param instance a live model instance
+ * @param fn receives the instance and returns `{ actions?, views?, state? }`
+ * @returns the same instance
+ */
+function extendInstance(instance, fn) {
+    if (!isStateTreeNode(instance)) {
+        throw fail("extendInstance expects a mobx-state-tree node");
+    }
+    const type = getStateTreeNode(instance).type;
+    if (!isModelType(type)) {
+        throw fail("extendInstance can only be used on model instances");
+    }
+    // Views/actions/volatile are installed via defineProperty + makeObservable — the
+    // same "add" operations the initializers perform at creation, before the
+    // 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));
+    }));
+    attach();
+    return instance;
+}
 
 // TODO: implement CoreType using types.custom ?
 /**
@@ -5475,7 +5617,24 @@ class Union extends BaseType {
         }
         return `${baseWithDiscriminator}:\n    ${formatValidationErrorLines(errors).join("\n    ")}`;
     }
+    // Memoizes the discriminator -> member scan below. Union membership is fixed
+    // at construction, so the result for a given `type` string never changes.
+    // Without this, validating a config with many elements drawn from a wide
+    // pluggable union (e.g. jbrowse's 30+ track/adapter types) re-scans every
+    // member — and calls resolveModelType + literal.is() on each — once per
+    // element. With it, each distinct discriminator scans once; the rest are
+    // O(1) map hits. `undefined` (no match OR ambiguous) is cached too.
+    _discriminatorCache;
     _findCandidateByTypeDiscriminator(discriminator) {
+        const cache = (this._discriminatorCache ??= new Map());
+        if (cache.has(discriminator)) {
+            return cache.get(discriminator);
+        }
+        const found = this._scanForTypeDiscriminator(discriminator);
+        cache.set(discriminator, found);
+        return found;
+    }
+    _scanForTypeDiscriminator(discriminator) {
         let found;
         for (const t of this._types) {
             const model = resolveModelType(t);
@@ -5521,22 +5680,14 @@ class Union extends BaseType {
         if (this._dispatcher) {
             return this._dispatcher(value);
         }
-        // fast path: when type checking is disabled, try quick structural matching first
+        // fast path: when type checking is disabled, try quick structural matching
+        // first. This skips full recursive validation of every property value, a
+        // meaningful win for wide model members (e.g. jbrowse config schemas).
         if (!isTypeCheckingEnabled()) {
             const quickMatch = this.tryQuickMatch(value, reconcileCurrentType);
             if (quickMatch) {
                 return quickMatch;
             }
-            // for plain object snapshots that didn't match via quick path, try all types
-            // with quick matching before falling back to full validation
-            // (state tree nodes must go through full validation for type identity checks)
-            if (isPlainObject(value) && !isStateTreeNode(value)) {
-                for (const type of this._types) {
-                    if (this.snapshotLooksLikeType(value, type)) {
-                        return type;
-                    }
-                }
-            }
         }
         // find the most accomodating type
         // if we are using reconciliation try the current node type first (fix for #1045)
@@ -7020,6 +7171,7 @@ exports.decorate = decorate;
 exports.destroy = destroy;
 exports.detach = detach;
 exports.escapeJsonPath = escapeJsonPath;
+exports.extendInstance = extendInstance;
 exports.flow = flow;
 exports.getChildType = getChildType;
 exports.getEnv = getEnv;