@jbrowse/mobx-state-tree 6.1.0 → 6.3.0

package/dist/mobx-state-tree.mjs

@@ -480,30 +480,20 @@ function getIdentifier(target) {
     return getStateTreeNode(target).identifier;
 }
 /**
- * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
- * else it returns undefined.
- *
- * @param getter Function to access the reference.
- * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.
- * @returns
+ * Resolves a reference getter to the referenced node, or `undefined` when the
+ * reference is empty, dangling, or (with `checkIfAlive`) points at a dead node.
+ * Backs both {@link tryReference} and {@link isValidReference}.
  */
-function tryReference(getter, checkIfAlive = true) {
+function resolveReference(getter, checkIfAlive) {
     try {
         const node = getter();
         if (node === undefined || node === null) {
             return undefined;
         }
-        else if (isStateTreeNode(node)) {
-            if (!checkIfAlive) {
-                return node;
-            }
-            else {
-                return isAlive(node) ? node : undefined;
-            }
-        }
-        else {
+        if (!isStateTreeNode(node)) {
             throw fail("The reference to be checked is not one of node, null or undefined");
         }
+        return !checkIfAlive || isAlive(node) ? node : undefined;
     }
     catch (e) {
         if (e instanceof InvalidReferenceError) {
@@ -512,6 +502,17 @@ function tryReference(getter, checkIfAlive = true) {
         throw e;
     }
 }
+/**
+ * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
+ * else it returns undefined.
+ *
+ * @param getter Function to access the reference.
+ * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.
+ * @returns
+ */
+function tryReference(getter, checkIfAlive = true) {
+    return resolveReference(getter, checkIfAlive);
+}
 /**
  * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns if the check passes or not.
  *
@@ -520,24 +521,7 @@ function tryReference(getter, checkIfAlive = true) {
  * @returns
  */
 function isValidReference(getter, checkIfAlive = true) {
-    try {
-        const node = getter();
-        if (node === undefined || node === null) {
-            return false;
-        }
-        else if (isStateTreeNode(node)) {
-            return checkIfAlive ? isAlive(node) : true;
-        }
-        else {
-            throw fail("The reference to be checked is not one of node, null or undefined");
-        }
-    }
-    catch (e) {
-        if (e instanceof InvalidReferenceError) {
-            return false;
-        }
-        throw e;
-    }
+    return resolveReference(getter, checkIfAlive) !== undefined;
 }
 /**
  * Try to resolve a given path relative to a given node.
@@ -1165,7 +1149,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 +1571,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 +1646,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 +1739,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 +1746,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 +1823,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)
  *
@@ -1913,7 +1943,6 @@ function assertIsType(type, argNumber) {
     assertArg(type, isType, "mobx-state-tree type", argNumber);
 }
 
-const runningActions = new Map();
 /**
  * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.
  *
@@ -1929,6 +1958,12 @@ const runningActions = new Map();
  * @returns
  */
 function createActionTrackingMiddleware(hooks) {
+    // per middleware, not per module: the entries hold the `context` this
+    // middleware's own onStart returned, so two middlewares on one tree would
+    // otherwise overwrite each other's context and then delete the shared entry —
+    // whichever saw `flow_return` second dereferenced `undefined`.
+    // createActionTrackingMiddleware2 scopes its map the same way.
+    const runningActions = new Map();
     return function actionTrackingMiddleware(call, next, _abort) {
         switch (call.type) {
             case "action": {
@@ -2121,7 +2156,7 @@ function createActionTrackingMiddleware2(middlewareHooks) {
     };
 }
 
-function serializeArgument(node, actionName, index, arg) {
+function serializeArgument(arg) {
     if (arg instanceof Date) {
         return { $MST_DATE: arg.getTime() };
     }
@@ -2149,7 +2184,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 +2228,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 +2345,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);
@@ -2651,6 +2686,8 @@ function shortenPrintValue(valueInString) {
 }
 function toErrorString(error) {
     const { value } = error;
+    // every context entry carries a type: they are built by getContextForPath and
+    // by typecheck's initial `[{ path: "", type }]`
     const type = error.context[error.context.length - 1].type;
     const fullPath = error.context
         .map(({ path }) => path)
@@ -2662,14 +2699,21 @@ function toErrorString(error) {
         : isPrimitive(value)
             ? "value"
             : "snapshot";
-    const isSnapshotCompatible = type && isStateTreeNode(value) && type.is(getStateTreeNode(value).snapshot);
-    return `${pathPrefix}${currentTypename} ${shortenPrintValue(prettyPrintValue(value))} is not assignable ${type ? `to type: \`${type.name}\`` : ``}${error.message ? ` (${error.message})` : ""}${type
-        ? isPrimitiveType(type) || isPrimitive(value)
-            ? `.`
-            : `, expected an instance of \`${type.name}\` or a snapshot like \`${shortenPrintValue(type.describe())}\` instead.${isSnapshotCompatible
-                ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
-                : ""}`
-        : `.`}`;
+    let expectation;
+    if (isPrimitiveType(type) || isPrimitive(value)) {
+        expectation = ".";
+    }
+    else {
+        // `isPrimitiveType` is declared `(type: IT) => type is IT`, so its negative
+        // branch narrows to `never` rather than to "some non-primitive type"; the
+        // annotation restores the type it actually has here.
+        const complexType = type;
+        const isSnapshotCompatible = isStateTreeNode(value) && complexType.is(getStateTreeNode(value).snapshot);
+        expectation = `, expected an instance of \`${complexType.name}\` or a snapshot like \`${shortenPrintValue(complexType.describe())}\` instead.${isSnapshotCompatible
+            ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
+            : ""}`;
+    }
+    return `${pathPrefix}${currentTypename} ${shortenPrintValue(prettyPrintValue(value))} is not assignable to type: \`${type.name}\`${error.message ? ` (${error.message})` : ""}${expectation}`;
 }
 /**
  * @internal
@@ -2778,10 +2822,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 +3168,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;
@@ -3491,6 +3542,8 @@ function createFlowSpawner(name, generator) {
     const spawner = function flowSpawner(...flowArgs) {
         // Implementation based on https://github.com/tj/co/blob/master/index.js
         const runId = getNextActionId();
+        // no `!`: the guard below is the point, and asserting non-null first made it
+        // dead to the checker while leaving it live at runtime
         const parentContext = getCurrentActionContext();
         if (!parentContext) {
             throw fail("a mst flow must always have a parent context");
@@ -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()})`;
     }
@@ -3743,8 +3812,10 @@ class SnapshotProcessor extends BaseType {
         return sn;
     }
     _fixNode(node) {
-        // the node has to use these methods rather than the original type ones
-        proxyNodeTypeMethods(node.type, this, "create");
+        // the node's type is the *inner* type, so `getType(instance).create(...)`
+        // would bypass the processors — point it at ours instead
+        const nodeType = node.type;
+        nodeType.create = this.create.bind(this);
         if (node instanceof ObjectNode) {
             node.hasSnapshotPostProcessor = !!this._processors.postProcessor;
         }
@@ -3813,11 +3884,6 @@ class SnapshotProcessor extends BaseType {
         return this._subtype.isMatchingSnapshotId(current, processedSn);
     }
 }
-function proxyNodeTypeMethods(nodeType, snapshotProcessorType, ...methods) {
-    for (const method of methods) {
-        nodeType[method] = snapshotProcessorType[method].bind(snapshotProcessorType);
-    }
-}
 /**
  * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.
  *
@@ -3868,6 +3934,41 @@ function snapshotProcessor(type, processors, name) {
     return new SnapshotProcessor(type, processors, name);
 }
 
+/**
+ * Append `hooks` to a collection type's initializer list. `EMPTY_ARRAY` is the
+ * shared default, so a type that never calls `.hooks()` allocates nothing.
+ *
+ * @internal
+ * @hidden
+ */
+function appendHookInitializer(current, hooks) {
+    return current.length > 0 ? [...current, hooks] : [hooks];
+}
+/**
+ * Install every hook the type's initializers produce onto `instance` as an MST
+ * action, mirroring how a model's `.actions()` members are attached.
+ *
+ * @internal
+ * @hidden
+ */
+function installHookInitializers(hookInitializers, instance) {
+    const addProp = !devMode() ? addHiddenFinalProp : addHiddenWritableProp;
+    for (const initializer of hookInitializers) {
+        const hooks = initializer(instance);
+        for (const name of Object.keys(hooks)) {
+            const hook = hooks[name];
+            addProp(instance, name, createActionInvoker(instance, name, hook));
+        }
+    }
+}
+/**
+ * The empty initializer list every collection type starts with.
+ *
+ * @internal
+ * @hidden
+ */
+const NO_HOOK_INITIALIZERS = EMPTY_ARRAY;
+
 const needsIdentifierError = `Map.put can only be used to store complex values that have an identifier type attribute`;
 function tryCollectModelTypes(type, modelTypes) {
     const subtypes = type.getSubTypes();
@@ -3964,21 +4065,21 @@ class MSTMap extends ObservableMap {
  */
 class MapType extends ComplexType {
     _subType;
+    hookInitializers;
     identifierMode = MapIdentifierMode.UNKNOWN;
     mapIdentifierAttribute = undefined;
     flags = TypeFlags.Map;
-    hookInitializers = [];
-    constructor(name, _subType, hookInitializers = []) {
-        super(name);
+    constructor(_subType, hookInitializers = NO_HOOK_INITIALIZERS) {
+        super();
         this._subType = _subType;
-        this._determineIdentifierMode();
         this.hookInitializers = hookInitializers;
+        this._determineIdentifierMode();
+    }
+    computeName() {
+        return `Map<string, ${this._subType.name}>`;
     }
     hooks(hooks) {
-        const hookInitializers = this.hookInitializers.length > 0
-            ? this.hookInitializers.concat(hooks)
-            : [hooks];
-        return new MapType(this.name, this._subType, hookInitializers);
+        return new MapType(this._subType, appendHookInitializer(this.hookInitializers, hooks));
     }
     instantiate(parent, subpath, environment, initialValue) {
         this._determineIdentifierMode();
@@ -4021,15 +4122,7 @@ class MapType extends ComplexType {
     }
     finalizeNewInstance(node, instance) {
         _interceptReads(instance, node.unbox);
-        const type = node.type;
-        type.hookInitializers.forEach(initializer => {
-            const hooks = initializer(instance);
-            Object.keys(hooks).forEach(name => {
-                const hook = hooks[name];
-                const actionInvoker = createActionInvoker(instance, name, hook);
-                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
-            });
-        });
+        installHookInitializers(node.type.hookInitializers, instance);
         intercept(instance, this.willChange);
         observe(instance, this.didChange);
     }
@@ -4212,7 +4305,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.
@@ -4230,18 +4323,18 @@ function isMapType(type) {
  */
 class ArrayType extends ComplexType {
     _subType;
+    hookInitializers;
     flags = TypeFlags.Array;
-    hookInitializers = [];
-    constructor(name, _subType, hookInitializers = []) {
-        super(name);
+    constructor(_subType, hookInitializers = NO_HOOK_INITIALIZERS) {
+        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, appendHookInitializer(this.hookInitializers, hooks));
     }
     instantiate(parent, subpath, environment, initialValue) {
         return createObjectNode(this, parent, subpath, environment, initialValue);
@@ -4261,15 +4354,7 @@ class ArrayType extends ComplexType {
     }
     finalizeNewInstance(node, instance) {
         _getAdministration(instance).dehancer = node.unbox;
-        const type = node.type;
-        type.hookInitializers.forEach(initializer => {
-            const hooks = initializer(instance);
-            Object.keys(hooks).forEach(name => {
-                const hook = hooks[name];
-                const actionInvoker = createActionInvoker(instance, name, hook);
-                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
-            });
-        });
+        installHookInitializers(node.type.hookInitializers, instance);
         intercept(instance, this.willChange);
         observe(instance, this.didChange);
     }
@@ -4290,14 +4375,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 +4395,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 +4520,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 +4535,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 +4702,52 @@ 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
-};
+const ANONYMOUS_MODEL_NAME = "AnonymousModel";
+/**
+ * A plain loop rather than `forAllProps`, which allocated a closure and made an
+ * indirect call per property. This runs once per `types.model()` over every
+ * 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 +4813,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 ?? ANONYMOUS_MODEL_NAME);
+        // Every field is assigned here, unconditionally and in a fixed order,
+        // rather than by `Object.assign(this, defaultObjectOptions, opts)`. `opts`
+        // carries a different key set at each of the three call sites — `model()`,
+        // 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 +4844,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 +
@@ -4820,19 +4956,7 @@ class ModelType extends ComplexType {
     }
     extend(fn) {
         const initializer = (self) => {
-            const { actions, views, state, ...rest } = fn(self);
-            for (const key in rest) {
-                throw fail(`The \`extend\` function should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '${key}'`);
-            }
-            if (state) {
-                this.instantiateVolatileState(self, state);
-            }
-            if (views) {
-                this.instantiateViews(self, views);
-            }
-            if (actions) {
-                this.instantiateActions(self, actions);
-            }
+            this.applyExtension(self, fn(self), "The `extend` function");
             return self;
         };
         return this.cloneAndEnhance({ initializers: [initializer] });
@@ -4853,9 +4977,17 @@ class ModelType extends ComplexType {
      * are permitted (see extendInstance, which runs this in an action context).
      */
     applyExtensionToInstance(self, extension) {
+        this.applyExtension(self, extension, "extendInstance");
+    }
+    /**
+     * Materializes an `{ actions, views, state }` bundle onto an instance. Shared
+     * by `.extend()` (at creation time) and `applyExtensionToInstance` (on a live
+     * instance); `subject` only names the caller in the invalid-key error.
+     */
+    applyExtension(self, extension, subject) {
         const { actions, views, state, ...rest } = extension;
         for (const key in rest) {
-            throw fail(`extendInstance should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '${key}'`);
+            throw fail(`${subject} should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '${key}'`);
         }
         if (state) {
             this.instantiateVolatileState(self, state);
@@ -4931,9 +5063,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 +5129,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 +5166,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}`);
             }
@@ -5122,7 +5277,7 @@ function model(...args) {
     if (devMode() && typeof args[0] !== "string" && args[1]) {
         throw fail("Model creation failed. First argument must be a string when two arguments are provided");
     }
-    const name = typeof args[0] === "string" ? args.shift() : "AnonymousModel";
+    const name = typeof args[0] === "string" ? args.shift() : ANONYMOUS_MODEL_NAME;
     const properties = args.shift() || {};
     return new ModelType({ name, properties });
 }
@@ -5136,7 +5291,7 @@ function model(...args) {
 function compose(...args) {
     // TODO: just join the base type names if no name is provided
     const hasTypename = typeof args[0] === "string";
-    const typeName = hasTypename ? args[0] : "AnonymousModel";
+    const typeName = hasTypename ? args[0] : ANONYMOUS_MODEL_NAME;
     if (hasTypename) {
         args.shift();
     }
@@ -5362,6 +5517,12 @@ function getPrimitiveFactoryFromValue(value) {
 /**
  * Returns if a given value represents a primitive type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
@@ -5371,6 +5532,8 @@ function isPrimitiveType(type) {
             (TypeFlags.String |
                 TypeFlags.Number |
                 TypeFlags.Integer |
+                TypeFlags.Float |
+                TypeFlags.Finite |
                 TypeFlags.Boolean |
                 TypeFlags.Date)) >
             0);
@@ -5424,6 +5587,12 @@ function literal(value) {
 /**
  * Returns if a given value represents a literal type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
@@ -5503,11 +5672,17 @@ function refinement(...args) {
 /**
  * Returns if a given value is a refinement type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
 function isRefinementType(type) {
-    return (type.flags & TypeFlags.Refinement) > 0;
+    return isType(type) && (type.flags & TypeFlags.Refinement) > 0;
 }
 
 /**
@@ -5548,10 +5723,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 +5753,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 +5848,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 +5882,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 +5979,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;
                     }
@@ -5818,7 +6015,8 @@ class Union extends BaseType {
         // - A failure is the definitive, scoped error only when every member is
         //   discriminated; otherwise a catch-all could still accept the value, so
         //   fall through to full validation.
-        if (isPlainObject(value) && !isStateTreeNode(value)) {
+        const isSnapshotObject = isPlainObject(value) && !isStateTreeNode(value);
+        if (isSnapshotObject) {
             const discriminator = value.type;
             if (typeof discriminator === "string") {
                 const candidate = this._findCandidateByTypeDiscriminator(discriminator);
@@ -5834,7 +6032,7 @@ class Union extends BaseType {
         // for plain-object snapshots, prefer union members whose literal-typed
         // discriminator properties match the value (e.g. {type: "MsaView"})
         // so error output is scoped to the intended branch instead of every member
-        const candidates = isPlainObject(value) && !isStateTreeNode(value)
+        const candidates = isSnapshotObject
             ? this._types.filter(t => this.snapshotLooksLikeType(value, t))
             : [];
         const typesToValidate = candidates.length > 0 ? candidates : this._types;
@@ -5863,6 +6061,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 +6076,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,16 +6097,22 @@ 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.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
 function 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 +6150,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 +6217,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");
     }
@@ -6049,6 +6286,12 @@ const undefinedAsOptionalValues = [undefined];
 /**
  * Returns if a value represents an optional type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @template IT
  * @param type
  * @returns
@@ -6134,7 +6377,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 +6388,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
@@ -6293,6 +6538,12 @@ function late(nameOrType, maybeType) {
 /**
  * Returns if a given value represents a late type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
@@ -6348,7 +6599,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 +6634,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>";
     }
@@ -6452,6 +6712,12 @@ function frozen(arg) {
 /**
  * Returns if a given value represents a frozen type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
@@ -6535,10 +6801,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;
     }
@@ -6679,9 +6948,6 @@ class BaseReferenceType extends SimpleType {
  * @hidden
  */
 class IdentifierReferenceType extends BaseReferenceType {
-    constructor(targetType, onInvalidated) {
-        super(targetType, onInvalidated);
-    }
     getValue(storedRefNode) {
         if (!storedRefNode.isAlive) {
             return undefined;
@@ -6797,11 +7063,17 @@ function reference(subType, options) {
 /**
  * Returns if a given value represents a reference type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
 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 +7144,6 @@ class BaseIdentifierType extends SimpleType {
  * @hidden
  */
 class IdentifierType extends BaseIdentifierType {
-    flags = TypeFlags.Identifier;
     constructor() {
         super(`identifier`, "string");
     }
@@ -6930,6 +7201,12 @@ const identifierNumber = new IdentifierNumberType();
 /**
  * Returns if a given value represents an identifier type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
@@ -7070,11 +7347,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 +7389,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);