@jbrowse/mobx-state-tree 6.1.0 → 6.2.0

package/dist/mobx-state-tree.mjs

@@ -1165,7 +1165,7 @@ class ObjectNode extends BaseNode {
     }
     _autoUnbox = true; // unboxing is disabled when reading child nodes
     _isRunningAction = false; // only relevant for root
-    _hasSnapshotReaction = false;
+    _snapshotReactionDisposer;
     _observableInstanceState = ObservableInstanceLifecycle.UNINITIALIZED;
     _childNodes;
     _initialSnapshot;
@@ -1587,7 +1587,17 @@ class ObjectNode extends BaseNode {
     }
     onSnapshot(onChange) {
         this._addSnapshotReaction();
-        return this._internalEventsRegister(InternalEvents.Snapshot, onChange);
+        const unregister = this._internalEventsRegister(InternalEvents.Snapshot, onChange);
+        return () => {
+            unregister();
+            // The reaction re-serializes the whole subtree on every change, so leaving
+            // it running once the last listener is gone would keep charging the node
+            // for a snapshot nobody receives. Referential stability of getSnapshot()
+            // does not depend on it — that comes from keepAlive on _snapshotComputed.
+            if (!this._internalEventsHasSubscribers(InternalEvents.Snapshot)) {
+                this._removeSnapshotReaction();
+            }
+        };
     }
     emitSnapshot(snapshot) {
         this._internalEventsEmit(InternalEvents.Snapshot, snapshot);
@@ -1652,11 +1662,23 @@ class ObjectNode extends BaseNode {
         this.type.applyPatchLocally(this, subpath, patch);
     }
     _addSnapshotReaction() {
-        if (!this._hasSnapshotReaction) {
+        if (!this._snapshotReactionDisposer) {
             const snapshotDisposer = reaction(() => this.snapshot, snapshot => this.emitSnapshot(snapshot), snapshotReactionOptions);
             this.addDisposer(snapshotDisposer);
-            this._hasSnapshotReaction = true;
+            this._snapshotReactionDisposer = snapshotDisposer;
+        }
+    }
+    _removeSnapshotReaction() {
+        const disposer = this._snapshotReactionDisposer;
+        if (!disposer) {
+            return;
         }
+        this._snapshotReactionDisposer = undefined;
+        // not removeDisposer(), which throws when the registration is already gone —
+        // the last listener can be disposed from within a disposer, i.e. after
+        // aboutToDie has cleared them
+        this._internalEventsUnregister(InternalEvents.Dispose, disposer);
+        disposer();
     }
     // #region internal event handling
     _internalEvents;
@@ -1733,8 +1755,6 @@ var TypeFlags;
  * @hidden
  */
 const cannotDetermineSubtype = "cannotDetermine";
-/** @hidden */
-const $type = Symbol("$type");
 /**
  * A base type produces a MST node (Node in the state tree)
  *
@@ -1742,16 +1762,39 @@ const $type = Symbol("$type");
  * @hidden
  */
 class BaseType {
-    [$type];
-    // these are just to make inner types avaialable to inherited classes
-    C;
-    S;
-    T;
-    N;
-    isType = true;
-    name;
+    /**
+     * Builds the name of a type that does not get one handed to it. Composite
+     * types (`union`, `array`, `map`, `reference`, ...) override this to fold
+     * their members' names; see {@link name}. It runs after construction, so
+     * unlike a `super(...)` argument it can read the subclass's own fields.
+     */
+    computeName() {
+        // istanbul ignore next
+        throw fail(`${this.constructor.name} has neither a name nor a computeName`);
+    }
+    /**
+     * Friendly type name.
+     *
+     * A composite type folds its members' names, which for a union is a map +
+     * join over every member — and the result is read only by error messages and
+     * `describe()`. So those types leave it unset and it is built on first read
+     * and cached: a union that never fails a typecheck never builds one, and
+     * jbrowse builds a union per config slot, tens of thousands per session load.
+     *
+     * Deliberately not a lambda passed to the constructor: that allocated a
+     * closure per type (the very cost being avoided) and made two separately
+     * built but equivalent types compare unequal, since the closures differ.
+     */
+    get name() {
+        return (this._name ??= this.computeName());
+    }
+    set name(value) {
+        this._name = value;
+    }
     constructor(name) {
-        this.name = name;
+        if (name !== undefined) {
+            this._name = name;
+        }
     }
     create(snapshot, environment) {
         typecheckInternal(this, snapshot);
@@ -1796,6 +1839,9 @@ class BaseType {
     }
 }
 BaseType.prototype.create = action(BaseType.prototype.create);
+// Defaults that every type shares, kept off the individual type objects. See
+// `isType` and `_name` in the class body.
+Object.assign(BaseType.prototype, { isType: true, _name: undefined });
 /**
  * A complex type produces a MST node (Node in the state tree)
  *
@@ -2121,7 +2167,7 @@ function createActionTrackingMiddleware2(middlewareHooks) {
     };
 }
 
-function serializeArgument(node, actionName, index, arg) {
+function serializeArgument(arg) {
     if (arg instanceof Date) {
         return { $MST_DATE: arg.getTime() };
     }
@@ -2149,7 +2195,7 @@ function serializeArgument(node, actionName, index, arg) {
         return serializeTheUnserializable(`${e}`);
     }
 }
-function deserializeArgument(adm, value) {
+function deserializeArgument(value) {
     if (value && typeof value === "object" && "$MST_DATE" in value) {
         return new Date(value["$MST_DATE"]);
     }
@@ -2193,7 +2239,7 @@ function baseApplyAction(target, action) {
     if (!(typeof resolvedTarget[action.name] === "function")) {
         throw fail(`Action '${action.name}' does not exist in '${node.path}'`);
     }
-    return resolvedTarget[action.name](...(action.args ? action.args.map(v => deserializeArgument(node, v)) : []));
+    return resolvedTarget[action.name](...(action.args ? action.args.map(deserializeArgument) : []));
 }
 /**
  * Small abstraction around `onAction` and `applyAction`, attaches an action listener to a tree and records all the actions emitted.
@@ -2310,7 +2356,7 @@ function onAction(target, listener, attachAfter = false) {
             const info = {
                 name: rawCall.name,
                 path: getRelativePathBetweenNodes(getStateTreeNode(target), sourceNode),
-                args: rawCall.args.map((arg, index) => serializeArgument(sourceNode, rawCall.name, index, arg))
+                args: rawCall.args.map(serializeArgument)
             };
             if (attachAfter) {
                 const res = next(rawCall);
@@ -2778,10 +2824,13 @@ class IdentifierCache {
     addNodeToCache(node, lastCacheUpdate = true) {
         if (node.identifierAttribute) {
             const identifier = node.identifier;
-            if (!this.cache.has(identifier)) {
-                this.cache.set(identifier, observable.array([], mobxShallow));
+            // one observable-map read, not a has() plus a get(): this runs for every
+            // identified node created
+            let set = this.cache.get(identifier);
+            if (!set) {
+                set = observable.array([], mobxShallow);
+                this.cache.set(identifier, set);
             }
-            const set = this.cache.get(identifier);
             if (set.includes(node)) {
                 throw fail(`Already registered`);
             }
@@ -3121,7 +3170,11 @@ function isPlainObject(value) {
         return false;
     }
     const proto = Object.getPrototypeOf(value);
-    if (proto == null) {
+    // Fast path for an object literal from this realm — nearly every snapshot MST
+    // inspects. The fallback compares the constructor's *source text* so that an
+    // `Object` from another realm (iframe, vm context) still counts as plain; it
+    // is ~6x slower, so only cross-realm and null-prototype values pay for it.
+    if (proto === Object.prototype || proto == null) {
         return true;
     }
     return proto.constructor?.toString() === plainObjectString;
@@ -3711,14 +3764,30 @@ const $preProcessorFailed = Symbol("$preProcessorFailed");
 class SnapshotProcessor extends BaseType {
     _subtype;
     _processors;
+    _flags;
+    // memoized once stable; see the guard on Union.flags
     get flags() {
-        return this._subtype.flags | TypeFlags.SnapshotProcessor;
+        const cached = this._flags;
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = this._subtype.flags | TypeFlags.SnapshotProcessor;
+        if (!(result & TypeFlags.Late)) {
+            this._flags = result;
+        }
+        return result;
     }
     constructor(_subtype, _processors, name) {
-        super(name || _subtype.name);
+        // `|| undefined`, so an empty name still falls through to the subtype's, as
+        // it did when this read `name || _subtype.name`. Passing `""` straight to
+        // `super` would keep it: `_name ??= computeName()` only fills a nullish one.
+        super(name || undefined);
         this._subtype = _subtype;
         this._processors = _processors;
     }
+    computeName() {
+        return this._subtype.name;
+    }
     describe() {
         return `snapshotProcessor(${this._subtype.describe()})`;
     }
@@ -3968,17 +4037,20 @@ class MapType extends ComplexType {
     mapIdentifierAttribute = undefined;
     flags = TypeFlags.Map;
     hookInitializers = [];
-    constructor(name, _subType, hookInitializers = []) {
-        super(name);
+    constructor(_subType, hookInitializers = []) {
+        super();
         this._subType = _subType;
         this._determineIdentifierMode();
         this.hookInitializers = hookInitializers;
     }
+    computeName() {
+        return `Map<string, ${this._subType.name}>`;
+    }
     hooks(hooks) {
         const hookInitializers = this.hookInitializers.length > 0
             ? this.hookInitializers.concat(hooks)
             : [hooks];
-        return new MapType(this.name, this._subType, hookInitializers);
+        return new MapType(this._subType, hookInitializers);
     }
     instantiate(parent, subpath, environment, initialValue) {
         this._determineIdentifierMode();
@@ -4212,7 +4284,7 @@ MapType.prototype.applySnapshot = action(MapType.prototype.applySnapshot);
  * @returns
  */
 function map(subtype) {
-    return new MapType(`Map<string, ${subtype.name}>`, subtype);
+    return new MapType(subtype);
 }
 /**
  * Returns if a given value represents a map type.
@@ -4232,16 +4304,19 @@ class ArrayType extends ComplexType {
     _subType;
     flags = TypeFlags.Array;
     hookInitializers = [];
-    constructor(name, _subType, hookInitializers = []) {
-        super(name);
+    constructor(_subType, hookInitializers = []) {
+        super();
         this._subType = _subType;
         this.hookInitializers = hookInitializers;
     }
+    computeName() {
+        return `${this._subType.name}[]`;
+    }
     hooks(hooks) {
         const hookInitializers = this.hookInitializers.length > 0
             ? this.hookInitializers.concat(hooks)
             : [hooks];
-        return new ArrayType(this.name, this._subType, hookInitializers);
+        return new ArrayType(this._subType, hookInitializers);
     }
     instantiate(parent, subpath, environment, initialValue) {
         return createObjectNode(this, parent, subpath, environment, initialValue);
@@ -4290,14 +4365,17 @@ class ArrayType extends ComplexType {
         const node = getStateTreeNode(change.object);
         node.assertWritable({ subpath: `${change.index}` });
         const subType = node.type._subType;
-        const childNodes = node.getChildren();
         switch (change.type) {
             case "update":
                 {
                     if (change.newValue === change.object[change.index]) {
                         return null;
                     }
-                    const updatedNodes = reconcileArrayChildren(node, subType, [childNodes[change.index]], [change.newValue], change.index);
+                    const updatedNodes = reconcileArrayChildren(node, subType, 
+                    // only the replaced child is reconciled, so read that one node
+                    // directly — `node.getChildren()` copies the whole backing array,
+                    // which made a single-element assignment cost O(array length)
+                    [node.getChildNode(`${change.index}`)], [change.newValue], change.index);
                     if (!updatedNodes) {
                         return null;
                     }
@@ -4307,6 +4385,7 @@ class ArrayType extends ComplexType {
             case "splice":
                 {
                     const { index, removedCount, added } = change;
+                    const childNodes = node.getChildren();
                     const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, index);
                     if (!addedNodes) {
                         return null;
@@ -4431,7 +4510,7 @@ ArrayType.prototype.applySnapshot = action(ArrayType.prototype.applySnapshot);
  */
 function array(subtype) {
     assertIsType(subtype, 1);
-    return new ArrayType(`${subtype.name}[]`, subtype);
+    return new ArrayType(subtype);
 }
 /**
  * @param firstNewPath index the reconciled slice starts at; both call sites
@@ -4446,8 +4525,12 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, firstNew
     // whose id extraction needs type-specific preprocessing (union,
     // snapshotProcessor, late, ...) are intentionally excluded: areSame must run
     // `is()` before their id check, so they stay on the scan path.
+    // With at most one old node the scan below is already O(1), so building the
+    // index would only add a Map allocation to every single-element write.
     let idIndex;
-    if (childType instanceof ModelType && childType.identifierAttribute) {
+    if (oldNodes.length > 1 &&
+        childType instanceof ModelType &&
+        childType.identifierAttribute) {
         const byId = new Map();
         for (const n of oldNodes) {
             if (n instanceof ObjectNode && n.identifier !== null) {
@@ -4609,14 +4692,53 @@ const POST_PROCESS_SNAPSHOT = "postProcessSnapshot";
 function getPropObservable(storedValue, key) {
     return getAtom(storedValue, key);
 }
+/**
+ * All of an instance's per-property `ObservableValue`s in one map, or
+ * `undefined` if this mobx does not expose them.
+ *
+ * `observable.object` returns a **Proxy**, and `getAtom(storedValue, key)`
+ * probes it with four `isObservableArray/Set/Map/Object` guards plus a `$mobx`
+ * read — each one a marker-property read that goes through the proxy's `get`
+ * trap. Paying that per property made the trap machinery the bulk of a wide
+ * model's `getSnapshot`; resolving the administration once and reading its
+ * property map directly reduces the per-property cost to a `Map.get`.
+ *
+ * `values_` is mobx-internal, hence the undefined result: every caller keeps a
+ * path built on supported API, so a mobx that drops it degrades to the old
+ * speed rather than breaking.
+ *
+ * The map is complete for our instances. `getAtom` falls back to
+ * `materializeLazy{Computed,Observable}_` because mobx defers constructing an
+ * `ObservableValue` for *decorator* annotations; `createNewInstance` builds
+ * these through `observable.object`, which populates `values_` eagerly for
+ * every declared property.
+ */
+function getPropObservables(storedValue) {
+    const adm = _getAdministration(storedValue);
+    return adm.values_;
+}
 function objectTypeToString() {
     return getStateTreeNode(this).toString();
 }
 const defaultObjectOptions = {
-    name: "AnonymousModel",
-    properties: {},
-    initializers: EMPTY_ARRAY
-};
+    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
+ * declared property, and jbrowse builds a ~40-slot schema per track.
+ */
+function findIdentifierAttribute(properties, propertyNames) {
+    let identifierAttribute = undefined;
+    for (const propName of propertyNames) {
+        if (properties[propName].flags & TypeFlags.Identifier) {
+            if (identifierAttribute) {
+                throw fail(`Cannot define property '${propName}' as object identifier, property '${identifierAttribute}' is already defined as identifier property`);
+            }
+            identifierAttribute = propName;
+        }
+    }
+    return identifierAttribute;
+}
 function toPropertiesObject(declaredProps) {
     // loop through properties and ensures that all items are types
     return Object.keys(declaredProps).reduce((props, key) => {
@@ -4682,14 +4804,29 @@ class ModelType extends ComplexType {
     // to check the first instance we finalize (see finalizeNewInstance)
     duplicateKeysChecked = false;
     constructor(opts) {
-        super(opts.name || defaultObjectOptions.name);
-        Object.assign(this, defaultObjectOptions, opts);
+        // `??`, 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);
+        // 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()`,
+        // and cloneAndEnhance's preprocessed / converted paths — so copying it
+        // wholesale gave ModelType three hidden classes, making every later read of
+        // `type.properties` / `type.propertyNames` (getSnapshot's inner loop, among
+        // others) polymorphic. It also left the internal `propertiesArePreProcessed`
+        // / `propertiesAreConverted` plumbing on the type for its whole lifetime.
+        this.initializers = opts.initializers ?? EMPTY_ARRAY;
+        this.preProcessor = opts.preProcessor;
+        this.postProcessor = opts.postProcessor;
+        const declaredProperties = (opts.properties ?? EMPTY_OBJECT);
         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.properties = declaredProperties;
             this.propertyNames = opts.propertyNames;
             this.identifierAttribute = opts.identifierAttribute;
         }
@@ -4698,26 +4835,16 @@ class ModelType extends ComplexType {
             // 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();
+            const properties = (opts.propertiesAreConverted
+                ? declaredProperties
+                : toPropertiesObject(declaredProperties));
+            this.properties = properties;
+            freeze(properties); // make sure nobody messes with it
+            const propertyNames = Object.keys(properties);
+            this.propertyNames = propertyNames;
+            this.identifierAttribute = findIdentifierAttribute(properties, propertyNames);
         }
     }
-    _getIdentifierAttribute() {
-        let identifierAttribute = undefined;
-        this.forAllProps((propName, propType) => {
-            if (propType.flags & TypeFlags.Identifier) {
-                if (identifierAttribute) {
-                    throw fail(`Cannot define property '${propName}' as object identifier, property '${identifierAttribute}' is already defined as identifier property`);
-                }
-                identifierAttribute = propName;
-            }
-        });
-        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 +
@@ -4931,9 +5058,20 @@ class ModelType extends ComplexType {
     }
     finalizeNewInstance(node, instance) {
         addHiddenFinalProp(instance, "toString", objectTypeToString);
-        this.forAllProps(name => {
-            _interceptReads(instance, name, node.unbox);
-        });
+        // `_interceptReads(instance, name, ...)` assigns exactly this `dehancer`,
+        // but reaches the ObservableValue via getAtom — several proxy-trap reads
+        // per property (see getPropObservables). Resolve the map once instead.
+        const observables = getPropObservables(instance);
+        if (observables) {
+            for (const name of this.propertyNames) {
+                observables.get(name).dehancer = node.unbox;
+            }
+        }
+        else {
+            this.forAllProps(name => {
+                _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
@@ -4986,9 +5124,18 @@ class ModelType extends ComplexType {
     }
     getChildren(node) {
         const names = this.propertyNames;
+        const storedValue = node.storedValue;
+        const observables = getPropObservables(storedValue);
         const res = new Array(names.length);
         for (let i = 0; i < names.length; i++) {
-            res[i] = this.getPropertyNode(node, names[i]);
+            const name = names[i];
+            const childNode = (observables
+                ? observables.get(name)
+                : getPropObservable(storedValue, name))?.raw();
+            if (!childNode) {
+                throw fail(`Node not available for property ${name}`);
+            }
+            res[i] = childNode;
         }
         return res;
     }
@@ -5014,14 +5161,17 @@ class ModelType extends ComplexType {
         const res = {};
         const storedValue = node.storedValue;
         const properties = this.properties;
+        const observables = getPropObservables(storedValue);
         for (const name of this.propertyNames) {
             // One mobx lookup serves both purposes: reportObserved so the snapshot
             // computed recomputes when the child is reassigned (raw() below does not
             // track), and raw() to read the child node. Going through getChildNode
             // would repeat the same lookup for every property.
-            const observable = getPropObservable(storedValue, name);
-            observable.reportObserved();
-            const childNode = observable.raw();
+            const observable = observables
+                ? observables.get(name)
+                : getPropObservable(storedValue, name);
+            observable?.reportObserved();
+            const childNode = observable?.raw();
             if (!childNode) {
                 throw fail(`Node not available for property ${name}`);
             }
@@ -5371,6 +5521,8 @@ function isPrimitiveType(type) {
             (TypeFlags.String |
                 TypeFlags.Number |
                 TypeFlags.Integer |
+                TypeFlags.Float |
+                TypeFlags.Finite |
                 TypeFlags.Boolean |
                 TypeFlags.Date)) >
             0);
@@ -5507,7 +5659,7 @@ function refinement(...args) {
  * @returns
  */
 function isRefinementType(type) {
-    return (type.flags & TypeFlags.Refinement) > 0;
+    return isType(type) && (type.flags & TypeFlags.Refinement) > 0;
 }
 
 /**
@@ -5548,10 +5700,23 @@ function enumeration(name, options) {
 // the scoping never engages and every failure prints every member's full
 // structure. Wrappers expose their child as `_subtype` (optional/refinement/
 // snapshotProcessor) or via `getSubType()` (late); bounded to avoid cycles.
+// Only *successful* resolutions are cached. A wrapper chain's shape is fixed at
+// construction, so once a member resolves to a ModelType it always will; but a
+// `late` member reports no subtype until its definition evaluates, and that
+// miss must stay retryable.
+const resolvedModelTypes = new WeakMap();
 function resolveModelType(type) {
+    if (!type) {
+        return undefined;
+    }
+    const cached = resolvedModelTypes.get(type);
+    if (cached) {
+        return cached;
+    }
     let current = type;
     for (let depth = 0; current && depth < 20; depth++) {
         if (current instanceof ModelType) {
+            resolvedModelTypes.set(type, current);
             return current;
         }
         const wrapper = current;
@@ -5565,31 +5730,51 @@ function resolveModelType(type) {
  */
 class Union extends BaseType {
     _types;
-    _dispatcher;
-    _eager = true;
-    // Deliberately recomputed rather than memoized: a `types.late` member reports
-    // 0 for its subtype until the definition resolves, so the fold is not stable
-    // over the type's lifetime and a memo would need a carve-out for exactly the
-    // case that motivates it. Measured at ~4% of union creation, which is not
-    // worth another cache.
+    _flags;
+    // Memoized, but only once the fold is known to be stable. A `types.late`
+    // member reports 0 for its subtype until its definition resolves, so a union
+    // containing one must keep recomputing — and every wrapper ORs its subtype's
+    // flags upward, so `Late` in the *result* is an exact test for "some member
+    // may still change" however deeply it is nested. A resolved late still
+    // reports Late, so such a union simply never caches; that is conservative in
+    // the safe direction and no real-world union is built out of late members.
+    //
+    // This reverses an earlier decision to leave it uncached, which was sized at
+    // ~4% "on union creation alone". That understated it: the reads are what
+    // cost, not the creation. `ModelType._getIdentifierAttribute` folds every
+    // property's flags on each `types.model()`, and jbrowse's config slots are
+    // unions under a stripDefault, so building one schema re-folded every slot's
+    // union. See agent-docs/adr/0003.
     get flags() {
+        const cached = this._flags;
+        if (cached !== undefined) {
+            return cached;
+        }
         let result = TypeFlags.Union;
         for (const type of this._types) {
             result |= type.flags;
         }
+        if (!(result & TypeFlags.Late)) {
+            this._flags = result;
+        }
         return result;
     }
-    constructor(name, _types, options) {
-        super(name);
+    computeName() {
+        return `(${this._types.map(type => type.name).join(" | ")})`;
+    }
+    constructor(_types, options) {
+        super();
         this._types = _types;
-        options = {
-            eager: true,
-            dispatcher: undefined,
-            ...options
-        };
-        this._dispatcher = options.dispatcher;
-        if (!options.eager) {
-            this._eager = false;
+        // read the two 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) {
+            if (options.dispatcher !== undefined) {
+                this._dispatcher = options.dispatcher;
+            }
+            if (options.eager === false) {
+                this._eager = false;
+            }
         }
     }
     isAssignableFrom(type) {
@@ -5640,14 +5825,6 @@ 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)) {
@@ -5682,11 +5859,6 @@ class Union extends BaseType {
         }
         return found;
     }
-    // True when every member resolves to a model carrying a literal `type`
-    // discriminator — i.e. a fully discriminated union, where a snapshot's `type`
-    // uniquely identifies the intended member and no untagged catch-all member
-    // could also accept it. Cached: membership is fixed at construction.
-    _allMembersDiscriminated;
     allMembersDiscriminated() {
         if (this._allMembersDiscriminated === undefined) {
             this._allMembersDiscriminated = this._types.every(t => {
@@ -5784,18 +5956,20 @@ class Union extends BaseType {
             // use cached propertyNames from ModelType instead of Object.keys()
             for (const key of model.propertyNames) {
                 const propType = props[key];
-                const isOptional = propType.flags & TypeFlags.Optional;
+                // `flags` is a recomputed getter on the wrapper types (optional,
+                // snapshotProcessor, late, union), so read it once per property
+                const flags = propType.flags;
                 const propValue = value[key];
                 // check required properties exist and are not undefined
                 // (unless the type accepts undefined, which Optional types do)
-                if (!isOptional) {
+                if (!(flags & TypeFlags.Optional)) {
                     if (!(key in value) || propValue === undefined) {
                         return false;
                     }
                 }
                 // for literal types, verify the value matches exactly
                 // this is critical for discriminated unions
-                if (propType.flags & TypeFlags.Literal) {
+                if (flags & TypeFlags.Literal) {
                     if (!propType.is(propValue)) {
                         return false;
                     }
@@ -5863,6 +6037,14 @@ class Union extends BaseType {
         return this._types;
     }
 }
+// Defaults shared by every union; see the field declarations at the top of the
+// class for why they are not own slots.
+Object.assign(Union.prototype, {
+    _dispatcher: undefined,
+    _eager: true,
+    _discriminatorCache: undefined,
+    _allMembersDiscriminated: undefined
+});
 /**
  * `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`.
  *
@@ -5870,12 +6052,18 @@ class Union extends BaseType {
  * @param otherTypes
  * @returns
  */
-function union(optionsOrType, ...otherTypes) {
-    const options = isType(optionsOrType) ? undefined : optionsOrType;
-    const types = isType(optionsOrType)
-        ? [optionsOrType, ...otherTypes]
-        : otherTypes;
-    const name = `(${types.map(type => type.name).join(" | ")})`;
+function union(...args) {
+    // One rest array, handed straight to the Union in the common case. Splitting
+    // the leading argument out — whether by a `(first, ...rest)` signature that
+    // rebuilds `[first, ...rest]`, or by `rest.unshift(first)` — allocates a
+    // second array per union, and jbrowse builds one union per config slot. (The
+    // `unshift` form is worse still: V8 inlines the spread and calls out to the
+    // builtin, so it measured 3x the spread on a two-member union.) Only the
+    // options overload, which nothing hot uses, pays for a copy.
+    const firstIsType = isType(args[0]);
+    const options = firstIsType ? undefined : args[0];
+    const types = (firstIsType ? args : args.slice(1));
+    // the name is folded from the members on demand — see Union.computeName
     // check all options
     if (devMode()) {
         if (options) {
@@ -5885,7 +6073,7 @@ function union(optionsOrType, ...otherTypes) {
             assertIsType(type, options ? i + 2 : i + 1);
         });
     }
-    return new Union(name, types, options);
+    return new Union(types, options);
 }
 /**
  * Returns if a given value represents a union type.
@@ -5894,7 +6082,7 @@ function union(optionsOrType, ...otherTypes) {
  * @returns
  */
 function isUnionType(type) {
-    return (type.flags & TypeFlags.Union) > 0;
+    return isType(type) && (type.flags & TypeFlags.Union) > 0;
 }
 /**
  * Returns the member types of a union.
@@ -5932,15 +6120,31 @@ class OptionalValue extends BaseType {
     _subtype;
     _defaultValue;
     optionalValues;
+    _flags;
+    // memoized once stable; see the same guard on Union.flags for why `Late` in
+    // the folded result is the exact test for "may still change"
     get flags() {
-        return this._subtype.flags | TypeFlags.Optional;
+        const cached = this._flags;
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = this._subtype.flags | TypeFlags.Optional;
+        if (!(result & TypeFlags.Late)) {
+            this._flags = result;
+        }
+        return result;
     }
     constructor(_subtype, _defaultValue, optionalValues) {
-        super(_subtype.name);
+        // no name argument: reading `_subtype.name` here would force the name of
+        // whatever is wrapped, and jbrowse wraps a union per config slot
+        super();
         this._subtype = _subtype;
         this._defaultValue = _defaultValue;
         this.optionalValues = optionalValues;
     }
+    computeName() {
+        return this._subtype.name;
+    }
     describe() {
         return `${this._subtype.describe()}?`;
     }
@@ -5983,8 +6187,11 @@ class OptionalValue extends BaseType {
     }
 }
 function checkOptionalPreconditions(type, defaultValueOrFunction) {
-    // make sure we never pass direct instances
-    if (typeof defaultValueOrFunction !== "function" &&
+    // make sure we never pass direct instances. A node is always an object, so
+    // the typeof narrows first: most defaults are primitives, and reading
+    // `$treenode` off a string or a number is a megamorphic miss that this runs
+    // once per config slot.
+    if (typeof defaultValueOrFunction === "object" &&
         isStateTreeNode(defaultValueOrFunction)) {
         throw fail("default value cannot be an instance, pass a snapshot or a function that creates an instance/snapshot instead");
     }
@@ -6134,7 +6341,6 @@ function defaultSnapshotEquals(a, b) {
  * @internal
  */
 class StripDefaultValue extends OptionalValue {
-    _defaultSnapshot;
     shouldStripFromSnapshot(snapshot) {
         if (!this._defaultSnapshot) {
             // instantiate the subtype detached with the default and read the node's
@@ -6146,6 +6352,9 @@ class StripDefaultValue extends OptionalValue {
         return defaultSnapshotEquals(snapshot, this._defaultSnapshot.value);
     }
 }
+Object.assign(StripDefaultValue.prototype, {
+    _defaultSnapshot: undefined
+});
 /**
  * Whether `type` is a strip-default optional whose current child `snapshot`
  * equals its default and should therefore be omitted from the parent model's
@@ -6348,7 +6557,13 @@ class Lazy extends SimpleType {
         }
         const node = createScalarNode(this, parent, subpath, environment, deepFreeze(value));
         this.pendingNodeList.push(node);
-        when(() => !node.isAlive, () => this.pendingNodeList.splice(this.pendingNodeList.indexOf(node), 1));
+        when(() => !node.isAlive, () => {
+            // guard the index: splice(-1, 1) would drop an unrelated pending node
+            const index = this.pendingNodeList.indexOf(node);
+            if (index >= 0) {
+                this.pendingNodeList.splice(index, 1);
+            }
+        });
         return node;
     }
     isValidSnapshot(value, context) {
@@ -6377,9 +6592,12 @@ class Frozen extends SimpleType {
     subType;
     flags = TypeFlags.Frozen;
     constructor(subType) {
-        super(subType ? `frozen(${subType.name})` : "frozen");
+        super(subType ? undefined : "frozen");
         this.subType = subType;
     }
+    computeName() {
+        return `frozen(${this.subType.name})`;
+    }
     describe() {
         return "<any immutable value>";
     }
@@ -6535,10 +6753,13 @@ class BaseReferenceType extends SimpleType {
     onInvalidated;
     flags = TypeFlags.Reference;
     constructor(targetType, onInvalidated) {
-        super(`reference(${targetType.name})`);
+        super();
         this.targetType = targetType;
         this.onInvalidated = onInvalidated;
     }
+    computeName() {
+        return `reference(${this.targetType.name})`;
+    }
     describe() {
         return this.name;
     }
@@ -6801,7 +7022,7 @@ function reference(subType, options) {
  * @returns
  */
 function isReferenceType(type) {
-    return (type.flags & TypeFlags.Reference) > 0;
+    return isType(type) && (type.flags & TypeFlags.Reference) > 0;
 }
 /**
  * `types.safeReference` - A safe reference is like a standard reference, except that it accepts the undefined value by default
@@ -6872,7 +7093,6 @@ class BaseIdentifierType extends SimpleType {
  * @hidden
  */
 class IdentifierType extends BaseIdentifierType {
-    flags = TypeFlags.Identifier;
     constructor() {
         super(`identifier`, "string");
     }
@@ -7070,11 +7290,14 @@ class Resilient extends BaseType {
         return this._subtype.flags;
     }
     constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
-        super(`resilient(${_subtype.name})`);
+        super();
         this._subtype = _subtype;
         this._fallbackType = _fallbackType;
         this._createFallbackSnapshot = _createFallbackSnapshot;
     }
+    computeName() {
+        return `resilient(${this._subtype.name})`;
+    }
     describe() {
         return `resilient(${this._subtype.describe()})`;
     }
@@ -7109,12 +7332,20 @@ class Resilient extends BaseType {
             return this._subtype.reconcile(current, newValue, parent, subpath);
         }
         if (this._fallbackType.isAssignableFrom(current.type)) {
+            // `current` holds the fallback. Try the real type again, but keep the
+            // fallback node around while doing so — it is what the catch reconciles.
+            let recovered;
             try {
-                return this._subtype.instantiate(parent, subpath, undefined, newValue);
+                recovered = this._subtype.instantiate(parent, subpath, undefined, newValue);
             }
             catch (e) {
                 return this._fallbackType.reconcile(current, this._createFallbackSnapshot(e, newValue), parent, subpath);
             }
+            // the fallback node has been replaced, so it has to die: otherwise it
+            // stays alive in the tree and its identifier stays in the root's cache,
+            // where it collides with the recovered node's
+            current.die();
+            return recovered;
         }
         try {
             return this._subtype.reconcile(current, newValue, parent, subpath);