@jbrowse/mobx-state-tree 6.2.0 → 6.3.0

package/dist/index.d.ts

@@ -1800,10 +1800,16 @@ declare const DatePrimitive: IType<number | Date, number, Date>;
 /**
  * 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
  */
-declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): type is IT;
+declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): boolean;
 
 /**
  * `types.literal` - The literal type will return a type that will match only the exact given type.
@@ -1825,20 +1831,32 @@ declare function literal<S extends Primitives>(value: S): ISimpleType<S>;
 /**
  * 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
  */
-declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): type is IT;
+declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): boolean;
 
 declare function refinement<IT extends IAnyType>(name: string, type: IT, predicate: (snapshot: IT["CreationType"]) => boolean, message?: string | ((v: IT["CreationType"]) => string)): IT;
 declare function refinement<IT extends IAnyType>(type: IT, predicate: (snapshot: IT["CreationType"]) => boolean, message?: string | ((v: IT["CreationType"]) => string)): IT;
 /**
  * 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
  */
-declare function isRefinementType<IT extends IAnyType>(type: IT): type is IT;
+declare function isRefinementType<IT extends IAnyType>(type: IT): boolean;
 
 /** @hidden */
 type UnionStringArray<T extends readonly string[]> = T[number];
@@ -1895,10 +1913,16 @@ declare function union(dispatchOrType: UnionOptions | IAnyType, ...otherTypes: I
 /**
  * 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
  */
-declare function isUnionType<IT extends IAnyType>(type: IT): type is IT;
+declare function isUnionType<IT extends IAnyType>(type: IT): boolean;
 /**
  * Returns the member types of a union.
  *
@@ -1928,11 +1952,17 @@ declare function optional<IT extends IAnyType, OptionalVals extends ValidOptiona
 /**
  * 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
  */
-declare function isOptionalType<IT extends IAnyType>(type: IT): type is IT;
+declare function isOptionalType<IT extends IAnyType>(type: IT): boolean;
 /**
  * `types.stripDefault` - Like `types.optional`, but the property is omitted from
  * a parent model's snapshot entirely when its value equals the default (instead
@@ -1976,10 +2006,16 @@ declare function late<T extends IAnyType>(name: string, type: () => T): T;
 /**
  * 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
  */
-declare function isLateType<IT extends IAnyType>(type: IT): type is IT;
+declare function isLateType<IT extends IAnyType>(type: IT): boolean;
 
 interface LazyOptions<T extends IType<any, any, any>, U> {
     loadType: () => Promise<T>;
@@ -1993,10 +2029,16 @@ declare function frozen<T = any>(): IType<T, T, T>;
 /**
  * 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
  */
-declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): type is IT;
+declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): boolean;
 
 type OnReferenceInvalidatedEvent<STN extends IAnyStateTreeNode> = {
     parent: IAnyStateTreeNode;
@@ -2028,10 +2070,16 @@ declare function reference<IT extends IAnyComplexType>(subType: IT, options?: Re
 /**
  * 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
  */
-declare function isReferenceType<IT extends IReferenceType<any>>(type: IT): type is IT;
+declare function isReferenceType<IT extends IReferenceType<any>>(type: IT): boolean;
 declare function safeReference<IT extends IAnyComplexType>(subType: IT, options: (ReferenceOptionsGetSet<IT> | object) & {
     acceptsUndefined: false;
     onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>>;
@@ -2076,10 +2124,16 @@ declare const identifierNumber: ISimpleType<number>;
 /**
  * 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
  */
-declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): type is IT;
+declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): boolean;
 /**
  * Valid types for identifiers.
  */

package/dist/mobx-state-tree.cjs

@@ -482,30 +482,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) {
@@ -514,6 +504,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.
  *
@@ -522,24 +523,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.
@@ -1961,7 +1945,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.
  *
@@ -1977,6 +1960,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": {
@@ -2699,6 +2688,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)
@@ -2710,14 +2701,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
@@ -3546,6 +3544,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");
@@ -3814,8 +3814,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;
         }
@@ -3884,11 +3886,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.
  *
@@ -3939,6 +3936,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();
@@ -4035,24 +4067,21 @@ class MSTMap extends mobx.ObservableMap {
  */
 class MapType extends ComplexType {
     _subType;
+    hookInitializers;
     identifierMode = MapIdentifierMode.UNKNOWN;
     mapIdentifierAttribute = undefined;
     flags = TypeFlags.Map;
-    hookInitializers = [];
-    constructor(_subType, hookInitializers = []) {
+    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._subType, hookInitializers);
+        return new MapType(this._subType, appendHookInitializer(this.hookInitializers, hooks));
     }
     instantiate(parent, subpath, environment, initialValue) {
         this._determineIdentifierMode();
@@ -4095,15 +4124,7 @@ class MapType extends ComplexType {
     }
     finalizeNewInstance(node, instance) {
         mobx._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);
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
@@ -4304,9 +4325,9 @@ function isMapType(type) {
  */
 class ArrayType extends ComplexType {
     _subType;
+    hookInitializers;
     flags = TypeFlags.Array;
-    hookInitializers = [];
-    constructor(_subType, hookInitializers = []) {
+    constructor(_subType, hookInitializers = NO_HOOK_INITIALIZERS) {
         super();
         this._subType = _subType;
         this.hookInitializers = hookInitializers;
@@ -4315,10 +4336,7 @@ class ArrayType extends ComplexType {
         return `${this._subType.name}[]`;
     }
     hooks(hooks) {
-        const hookInitializers = this.hookInitializers.length > 0
-            ? this.hookInitializers.concat(hooks)
-            : [hooks];
-        return new ArrayType(this._subType, hookInitializers);
+        return new ArrayType(this._subType, appendHookInitializer(this.hookInitializers, hooks));
     }
     instantiate(parent, subpath, environment, initialValue) {
         return createObjectNode(this, parent, subpath, environment, initialValue);
@@ -4338,15 +4356,7 @@ class ArrayType extends ComplexType {
     }
     finalizeNewInstance(node, instance) {
         mobx._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);
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
@@ -4722,8 +4732,7 @@ function getPropObservables(storedValue) {
 function objectTypeToString() {
     return getStateTreeNode(this).toString();
 }
-const defaultObjectOptions = {
-    name: "AnonymousModel"};
+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
@@ -4809,7 +4818,7 @@ class ModelType extends ComplexType {
         // `??`, 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);
+        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()`,
@@ -4949,19 +4958,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] });
@@ -4982,9 +4979,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);
@@ -5274,7 +5279,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 });
 }
@@ -5288,7 +5293,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();
     }
@@ -5514,6 +5519,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
  */
@@ -5578,6 +5589,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
  */
@@ -5657,6 +5674,12 @@ 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
  */
@@ -5994,7 +6017,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);
@@ -6010,7 +6034,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;
@@ -6080,6 +6104,12 @@ function union(...args) {
 /**
  * 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
  */
@@ -6258,6 +6288,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
@@ -6504,6 +6540,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
  */
@@ -6672,6 +6714,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
  */
@@ -6902,9 +6950,6 @@ class BaseReferenceType extends SimpleType {
  * @hidden
  */
 class IdentifierReferenceType extends BaseReferenceType {
-    constructor(targetType, onInvalidated) {
-        super(targetType, onInvalidated);
-    }
     getValue(storedRefNode) {
         if (!storedRefNode.isAlive) {
             return undefined;
@@ -7020,6 +7065,12 @@ 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
  */
@@ -7152,6 +7203,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
  */