@jbrowse/mobx-state-tree 6.0.0 → 6.2.0

package/dist/mobx-state-tree.mjs

@@ -944,7 +944,6 @@ class BaseNode {
     constructor(type, parent, subpath, environment) {
         this.type = type;
         this.environment = environment;
-        this.environment = environment;
         this.baseSetParent(parent, subpath);
     }
     getReconciliationType() {
@@ -1166,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;
@@ -1412,10 +1411,7 @@ class ObjectNode extends BaseNode {
     }
     _getCachedInitialSnapshot() {
         if (!this._cachedInitialSnapshotCreated) {
-            const type = this.type;
-            const childNodes = this._childNodes;
-            const snapshot = this._initialSnapshot;
-            this._cachedInitialSnapshot = type.processInitialSnapshot(childNodes, snapshot);
+            this._cachedInitialSnapshot = this.type.processInitialSnapshot(this._childNodes);
             this._cachedInitialSnapshotCreated = true;
         }
         return this._cachedInitialSnapshot;
@@ -1591,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);
@@ -1656,12 +1662,24 @@ 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;
     // we proxy the methods to avoid creating an EventHandlers instance when it is not needed
@@ -1737,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)
  *
@@ -1746,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);
@@ -1800,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)
  *
@@ -1808,9 +1850,6 @@ BaseType.prototype.create = action(BaseType.prototype.create);
  */
 class ComplexType extends BaseType {
     identifierAttribute;
-    constructor(name) {
-        super(name);
-    }
     create(snapshot = this.getDefaultSnapshot(), environment) {
         return super.create(snapshot, environment);
     }
@@ -2128,7 +2167,7 @@ function createActionTrackingMiddleware2(middlewareHooks) {
     };
 }
 
-function serializeArgument(node, actionName, index, arg) {
+function serializeArgument(arg) {
     if (arg instanceof Date) {
         return { $MST_DATE: arg.getTime() };
     }
@@ -2156,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"]);
     }
@@ -2200,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.
@@ -2317,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);
@@ -2712,13 +2751,6 @@ function typeCheckFailure(context, value, message) {
     // Clone context since it may be mutated after this error is created
     return [{ context: context.slice(), value, message }];
 }
-/**
- * @internal
- * @hidden
- */
-function flattenTypeErrors(errors) {
-    return errors.flat();
-}
 // TODO; doublecheck: typecheck should only needed to be invoked from: type.create and array / map / value.property will change
 /**
  * @internal
@@ -2780,7 +2812,6 @@ class IdentifierCache {
     // last time the cache (array) for a given time changed
     // n.b. it is not really the time, but just an integer that gets increased after each modification to the array
     lastCacheModificationPerId = observable.map();
-    constructor() { }
     updateLastCacheModificationPerId(identifier) {
         const lcm = this.lastCacheModificationPerId.get(identifier);
         // we start at 1 since 0 means no update since cache creation
@@ -2793,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`);
             }
@@ -2821,7 +2855,7 @@ class IdentifierCache {
                 if (!set.length) {
                     this.cache.delete(id);
                 }
-                this.updateLastCacheModificationPerId(node.identifier);
+                this.updateLastCacheModificationPerId(id);
             }
         }
     }
@@ -3053,15 +3087,8 @@ function convertChildNodesToArray(childNodes) {
     if (!childNodes) {
         return EMPTY_ARRAY;
     }
-    const keys = Object.keys(childNodes);
-    if (!keys.length) {
-        return EMPTY_ARRAY;
-    }
-    const result = new Array(keys.length);
-    keys.forEach((key, index) => {
-        result[index] = childNodes[key];
-    });
-    return result;
+    const result = Object.values(childNodes);
+    return result.length ? result : EMPTY_ARRAY;
 }
 
 const plainObjectString = Object.toString();
@@ -3143,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;
@@ -3277,10 +3308,19 @@ class EventHandler {
         this.handlers.length = 0;
     }
     emit(...args) {
-        // 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));
+        const handlers = this.handlers;
+        // 0 and 1 handlers are by far the common cases (a patch/snapshot listener, a
+        // disposer) and need no copy: with a single handler, calling the value we
+        // already read is exactly what iterating a copy of it would do.
+        if (handlers.length <= 1) {
+            handlers[0]?.(...args);
+            return;
+        }
+        // otherwise iterate a copy so (un)registrations during emit don't disturb
+        // this pass and reentrant emits stay correct
+        for (const f of handlers.slice()) {
+            f(...args);
+        }
     }
 }
 /**
@@ -3661,6 +3701,11 @@ function escapeJsonPath(path) {
  * Unescape slashes and backslashes.
  */
 function unescapeJsonPath(path) {
+    // every escape sequence starts with `~`, so bail before the two regex passes
+    // for the overwhelmingly common unescaped part (mirrors escapeJsonPath above)
+    if (!path.includes("~")) {
+        return path;
+    }
     return path.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 /**
@@ -3719,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()})`;
     }
@@ -3976,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();
@@ -4151,22 +4215,21 @@ class MapType extends ComplexType {
     applySnapshot(node, snapshot) {
         typecheckInternal(this, snapshot);
         const target = node.storedValue;
-        const currentKeys = {};
-        Array.from(target.keys()).forEach(key => {
-            currentKeys[key] = false;
-        });
+        // keys present before the apply, minus the ones the snapshot (re)sets — what
+        // remains has to be deleted. A Set rather than a plain object: it needs no
+        // sentinel values, no second pass to find the survivors, and it can hold keys
+        // like "__proto__", which an object literal silently swallows.
+        const staleKeys = new Set(target.keys());
         if (snapshot) {
             // Don't use target.replace, as it will throw away all existing items first
             for (const key in snapshot) {
                 target.set(key, snapshot[key]);
-                currentKeys[`${key}`] = true;
+                staleKeys.delete(key);
             }
         }
-        Object.keys(currentKeys).forEach(key => {
-            if (currentKeys[key] === false) {
-                target.delete(key);
-            }
-        });
+        for (const key of staleKeys) {
+            target.delete(key);
+        }
     }
     getChildType() {
         return this._subType;
@@ -4221,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.
@@ -4241,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);
@@ -4299,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;
                     }
@@ -4316,7 +4385,8 @@ class ArrayType extends ComplexType {
             case "splice":
                 {
                     const { index, removedCount, added } = change;
-                    const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, added.map((_, i) => index + i));
+                    const childNodes = node.getChildren();
+                    const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, index);
                     if (!addedNodes) {
                         return null;
                     }
@@ -4440,9 +4510,13 @@ ArrayType.prototype.applySnapshot = action(ArrayType.prototype.applySnapshot);
  */
 function array(subtype) {
     assertIsType(subtype, 1);
-    return new ArrayType(`${subtype.name}[]`, subtype);
+    return new ArrayType(subtype);
 }
-function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
+/**
+ * @param firstNewPath index the reconciled slice starts at; both call sites
+ * hand over a contiguous run, so subpath `i` is simply `firstNewPath + i`
+ */
+function reconcileArrayChildren(parent, childType, oldNodes, newValues, firstNewPath) {
     let nothingChanged = true;
     // When the element type is a plain model with an identifier, index the old
     // nodes by id so a moved / replaced child is matched in O(1) instead of the
@@ -4451,8 +4525,12 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
     // 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) {
@@ -4465,7 +4543,7 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
         const hasNewNode = i <= newValues.length - 1;
         const oldNode = oldNodes[i];
         let newValue = hasNewNode ? newValues[i] : undefined;
-        const newPath = `${newPaths[i]}`;
+        const newPath = `${firstNewPath + i}`;
         // for some reason, instead of newValue we got a node, fallback to the storedValue
         // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
         if (isNode(newValue)) {
@@ -4589,12 +4667,14 @@ function areSame(oldNode, newValue) {
     if (!(oldNode instanceof ObjectNode)) {
         return false;
     }
+    if (oldNode.identifier === null ||
+        !oldNode.identifierAttribute ||
+        !isPlainObject(newValue)) {
+        return false;
+    }
     const oldNodeType = oldNode.getReconciliationType();
     // new value is a snapshot with the correct identifier
-    return (oldNode.identifier !== null &&
-        oldNode.identifierAttribute &&
-        isPlainObject(newValue) &&
-        oldNodeType.is(newValue) &&
+    return (oldNodeType.is(newValue) &&
         oldNodeType.isMatchingSnapshotId(oldNode, newValue));
 }
 /**
@@ -4609,25 +4689,59 @@ function isArrayType(type) {
 
 const PRE_PROCESS_SNAPSHOT = "preProcessSnapshot";
 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
-};
-function toPropertiesObject(declaredProps) {
-    const keysList = Object.keys(declaredProps);
-    const alreadySeenKeys = new Set();
-    keysList.forEach(key => {
-        if (alreadySeenKeys.has(key)) {
-            throw fail(`${key} is declared twice in the model. Model should not contain the same keys`);
+    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;
         }
-        alreadySeenKeys.add(key);
-    });
+    }
+    return identifierAttribute;
+}
+function toPropertiesObject(declaredProps) {
     // loop through properties and ensures that all items are types
-    return keysList.reduce((props, key) => {
+    return Object.keys(declaredProps).reduce((props, key) => {
         // warn if user intended a HOOK
         if (key in Hook) {
             throw fail(`Hook '${key}' was defined as property. Hooks should be defined as part of the actions`);
@@ -4667,7 +4781,10 @@ function toPropertiesObject(declaredProps) {
             throw fail(`Invalid type definition for property '${key}', cannot infer a type from a value like '${value}' (${typeof value})`);
         }
         return props;
-    }, { ...declaredProps });
+    }, 
+    // seeded with the raw declaration; every key is either replaced by its
+    // converted type below, left alone because it already is one, or throws
+    { ...declaredProps });
 }
 /**
  * @internal
@@ -4687,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;
         }
@@ -4703,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 +
@@ -4936,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
@@ -4949,7 +5082,8 @@ class ModelType extends ComplexType {
         // success so a broken type keeps throwing on every create.
         if (!this.duplicateKeysChecked) {
             this.forAllProps(name => {
-                if (isComputedProp(instance, name) || !isObservableProp(instance, name)) {
+                if (isComputedProp(instance, name) ||
+                    !isObservableProp(instance, name)) {
                     throw fail(`${name} property is declared twice`);
                 }
             });
@@ -4989,33 +5123,64 @@ class ModelType extends ComplexType {
         }
     }
     getChildren(node) {
-        const res = [];
-        this.forAllProps(name => {
-            res.push(this.getChildNode(node, name));
-        });
+        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++) {
+            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;
     }
-    getChildNode(node, key) {
-        if (!(key in this.properties)) {
-            throw fail(`Not a value property: ${key}`);
-        }
-        const adm = _getAdministration(node.storedValue, key);
-        const childNode = adm.raw?.();
+    /**
+     * 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) {
+        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 = {};
-        this.forAllProps((name, type) => {
-            getAtom(node.storedValue, name).reportObserved();
-            const snapshot = this.getChildNode(node, name).snapshot;
+        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 = observables
+                ? observables.get(name)
+                : getPropObservable(storedValue, name);
+            observable?.reportObserved();
+            const childNode = observable?.raw();
+            if (!childNode) {
+                throw fail(`Node not available for property ${name}`);
+            }
+            const snapshot = childNode.snapshot;
             // strip-default optionals omit their key when equal to the default
-            if (!shouldStripChildFromSnapshot(type, snapshot)) {
+            if (!shouldStripChildFromSnapshot(properties[name], snapshot)) {
                 res[name] = snapshot;
             }
-        });
+        }
         if (applyPostProcess) {
             return this.applySnapshotPostProcessor(res);
         }
@@ -5079,7 +5244,10 @@ class ModelType extends ComplexType {
         return typeCheckSuccess();
     }
     forAllProps(fn) {
-        this.propertyNames.forEach(key => fn(key, this.properties[key]));
+        const properties = this.properties;
+        for (const key of this.propertyNames) {
+            fn(key, properties[key]);
+        }
     }
     describe() {
         // optimization: cache
@@ -5353,6 +5521,8 @@ function isPrimitiveType(type) {
             (TypeFlags.String |
                 TypeFlags.Number |
                 TypeFlags.Integer |
+                TypeFlags.Float |
+                TypeFlags.Finite |
                 TypeFlags.Boolean |
                 TypeFlags.Date)) >
             0);
@@ -5489,7 +5659,7 @@ function refinement(...args) {
  * @returns
  */
 function isRefinementType(type) {
-    return (type.flags & TypeFlags.Refinement) > 0;
+    return isType(type) && (type.flags & TypeFlags.Refinement) > 0;
 }
 
 /**
@@ -5530,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;
@@ -5547,26 +5730,51 @@ function resolveModelType(type) {
  */
 class Union extends BaseType {
     _types;
-    _dispatcher;
-    _eager = true;
+    _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;
-        this._types.forEach(type => {
+        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) {
@@ -5617,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)) {
@@ -5659,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 => {
@@ -5695,13 +5890,9 @@ class Union extends BaseType {
             if (reconcileCurrentType.is(value)) {
                 return reconcileCurrentType;
             }
-            return this._types
-                .filter(t => t !== reconcileCurrentType)
-                .find(type => type.is(value));
-        }
-        else {
-            return this._types.find(type => type.is(value));
+            return this._types.find(type => type !== reconcileCurrentType && type.is(value));
         }
+        return this._types.find(type => type.is(value));
     }
     tryQuickMatch(value, reconcileCurrentType) {
         // state tree nodes need full type compatibility checking
@@ -5713,15 +5904,17 @@ class Union extends BaseType {
         if (!isPlainObject(value)) {
             return this.tryMatchPrimitive(value);
         }
-        // for objects, try structural matching against model types
-        const typesToCheck = reconcileCurrentType
-            ? [
-                reconcileCurrentType,
-                ...this._types.filter(t => t !== reconcileCurrentType)
-            ]
-            : this._types;
-        for (const type of typesToCheck) {
-            if (this.snapshotLooksLikeType(value, type)) {
+        // for objects, try structural matching against model types, preferring the
+        // reconciliation type (checked first, then skipped in the main pass) so a
+        // reconcile keeps its current member when it still fits — without building
+        // the reordered candidate list this used to allocate on every call
+        if (reconcileCurrentType &&
+            this.snapshotLooksLikeType(value, reconcileCurrentType)) {
+            return reconcileCurrentType;
+        }
+        for (const type of this._types) {
+            if (type !== reconcileCurrentType &&
+                this.snapshotLooksLikeType(value, type)) {
                 return type;
             }
         }
@@ -5763,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;
                     }
@@ -5836,12 +6031,20 @@ class Union extends BaseType {
         if (applicableTypes === 1) {
             return typeCheckSuccess();
         }
-        return typeCheckFailure(context, value, "No type is applicable for the union").concat(flattenTypeErrors(allErrors));
+        return typeCheckFailure(context, value, "No type is applicable for the union").concat(allErrors.flat());
     }
     getSubTypes() {
         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`.
  *
@@ -5849,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) {
@@ -5864,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.
@@ -5873,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.
@@ -5911,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()}?`;
     }
@@ -5936,15 +6161,15 @@ class OptionalValue extends BaseType {
             : this.getDefaultInstanceOrSnapshot(), parent, subpath);
     }
     getDefaultInstanceOrSnapshot() {
-        const defaultInstanceOrSnapshot = typeof this._defaultValue === "function"
-            ? this._defaultValue()
-            : this._defaultValue;
-        // while static values are already snapshots and checked on types.optional
-        // generator functions must always be rechecked just in case
-        if (typeof this._defaultValue === "function") {
-            typecheckInternal(this, defaultInstanceOrSnapshot);
+        const defaultValue = this._defaultValue;
+        if (typeof defaultValue !== "function") {
+            // static values are already snapshots, checked once by types.optional
+            return defaultValue;
         }
-        return defaultInstanceOrSnapshot;
+        const generated = defaultValue();
+        // generator functions must always be rechecked just in case
+        typecheckInternal(this, generated);
+        return generated;
     }
     isValidSnapshot(value, context) {
         // defaulted values can be skipped
@@ -5962,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");
     }
@@ -6036,33 +6264,70 @@ function isOptionalType(type) {
     return isType(type) && (type.flags & TypeFlags.Optional) > 0;
 }
 /**
- * Compare a child snapshot to a stripped-default's reference snapshot. Mirrors
- * the legacy hand-rolled comparison: identity for primitives, structural for
- * objects/arrays.
+ * Compare a child snapshot to a stripped-default's reference snapshot: identity
+ * for primitives, structural for objects/arrays.
+ *
+ * Walks the two snapshots in parallel and bails at the first difference. The
+ * previous implementation compared `JSON.stringify(a) === JSON.stringify(b)`
+ * behind a size guard, which is O(whole snapshot) on both sides — plus two
+ * string allocations — even when the very first key differs. That is the normal
+ * case for an identified sub-model: its snapshot has exactly the same shape as
+ * the default and differs only in the identifier, so the size guard never fires
+ * and every `getSnapshot` of the parent serialized both trees just to answer
+ * "no".
+ *
+ * Snapshots are frozen, acyclic, JSON-ish plain data, so a plain recursive walk
+ * is safe. Key order is compared too, matching what stringify comparison did:
+ * the point is to answer "is this still the default", and the only unsafe answer
+ * is a false positive (a key gets dropped from the snapshot that shouldn't be),
+ * so where this can't reproduce stringify exactly — `{a: undefined}` vs
+ * `{b: undefined}`, or `NaN` nested in a frozen value, both of which stringify
+ * flattened into equal text — it errs toward "not equal" and simply keeps the
+ * key. Neither shape is reachable from a model snapshot, whose key set and order
+ * are fixed by its type.
  */
 function defaultSnapshotEquals(a, b) {
     if (a === b) {
         return true;
     }
-    if (typeof a === "object" &&
-        a !== null &&
-        typeof b === "object" &&
-        b !== null) {
-        // Cheap structural short-circuit before the full stringify compare: a
-        // value of a different size can't equal the default, so the common strip
-        // case (non-empty value vs an empty `[]`/`{}` default) avoids stringifying
-        // a potentially large snapshot on every getSnapshot.
-        if (Array.isArray(a) !== Array.isArray(b)) {
+    if (typeof a !== "object" ||
+        a === null ||
+        typeof b !== "object" ||
+        b === null) {
+        return false;
+    }
+    const aIsArray = Array.isArray(a);
+    if (aIsArray !== Array.isArray(b)) {
+        return false;
+    }
+    if (aIsArray) {
+        const arrayA = a;
+        const arrayB = b;
+        if (arrayA.length !== arrayB.length) {
             return false;
         }
-        const aSize = Array.isArray(a) ? a.length : Object.keys(a).length;
-        const bSize = Array.isArray(b) ? b.length : Object.keys(b).length;
-        if (aSize !== bSize) {
+        for (let i = 0; i < arrayA.length; i++) {
+            if (!defaultSnapshotEquals(arrayA[i], arrayB[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const objectA = a;
+    const objectB = b;
+    const keysA = Object.keys(objectA);
+    const keysB = Object.keys(objectB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+        const key = keysA[i];
+        if (key !== keysB[i] ||
+            !defaultSnapshotEquals(objectA[key], objectB[key])) {
             return false;
         }
-        return JSON.stringify(a) === JSON.stringify(b);
     }
-    return false;
+    return true;
 }
 /**
  * An optional type that additionally omits its key from a parent model's
@@ -6076,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
@@ -6088,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
@@ -6290,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) {
@@ -6319,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>";
     }
@@ -6477,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;
     }
@@ -6743,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
@@ -6814,7 +7093,6 @@ class BaseIdentifierType extends SimpleType {
  * @hidden
  */
 class IdentifierType extends BaseIdentifierType {
-    flags = TypeFlags.Identifier;
     constructor() {
         super(`identifier`, "string");
     }
@@ -7012,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()})`;
     }
@@ -7051,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);