mobx-keystone 2.2.0 → 2.3.1

package/src/modelShared/modelInfo.ts

@@ -22,6 +22,82 @@ export const modelInfoByName: {
  */
 export const modelInfoByClass = new WeakMap<ModelClass<AnyModel | AnyDataModel>, ModelInfo>()
 
+// registered model prototypes (looked up rather than reading `constructor`, since that might be
+// a model prop)
+const modelInfoByPrototype = new WeakMap<object, ModelInfo>()
+
+// for each registered model, how many registered models below each of its base models
+// (including itself, at 0) it is, by name
+const ancestorDistancesByModelInfo = new WeakMap<ModelInfo, ReadonlyMap<string, number>>()
+// the same, by name for the current registration of each model name
+const ancestorDistancesByModelName = new Map<string, ReadonlyMap<string, number>>()
+
+/**
+ * Finds the info of the first registered model class in a prototype chain.
+ *
+ * @internal
+ */
+export function findModelInfoForPrototype(proto: object | null): ModelInfo | undefined {
+  for (let p = proto; p; p = Object.getPrototypeOf(p)) {
+    const modelInfo = modelInfoByPrototype.get(p)
+    if (modelInfo) {
+      return modelInfo
+    }
+  }
+  return undefined
+}
+
+/**
+ * Registers a model.
+ *
+ * @internal
+ */
+export function setModelInfo(modelInfo: ModelInfo, unwrappedClass: ModelClass<any>): void {
+  // the base classes were registered before, so their distances are already known; names are
+  // used rather than classes since with hot reloading a subclass might still extend a previous
+  // registration of a model
+  const baseModelInfo = findModelInfoForPrototype(Object.getPrototypeOf(unwrappedClass.prototype))
+  const ancestorDistances = new Map<string, number>()
+  if (baseModelInfo) {
+    ancestorDistancesByModelInfo.get(baseModelInfo)?.forEach((distance, name) => {
+      ancestorDistances.set(name, distance + 1)
+    })
+  }
+  ancestorDistances.set(modelInfo.name, 0)
+  ancestorDistancesByModelInfo.set(modelInfo, ancestorDistances)
+  ancestorDistancesByModelName.set(modelInfo.name, ancestorDistances)
+
+  modelInfoByName[modelInfo.name] = modelInfo
+  modelInfoByClass.set(modelInfo.class, modelInfo)
+  modelInfoByClass.set(unwrappedClass, modelInfo)
+  modelInfoByPrototype.set(unwrappedClass.prototype, modelInfo)
+}
+
+/**
+ * How many registered models a model is below a base model (0 if it is that model), or -1 if
+ * it does not extend it.
+ *
+ * @internal
+ */
+export function getModelSubclassDistance(modelInfo: ModelInfo, baseModelName: string): number {
+  return ancestorDistancesByModelInfo.get(modelInfo)?.get(baseModelName) ?? -1
+}
+
+/**
+ * How many registered models the model currently registered with a name is below a base model
+ * (0 if it is that model), -1 if it does not extend it, or `undefined` if the name is not
+ * registered.
+ *
+ * @internal
+ */
+export function getModelSubclassDistanceForName(
+  modelName: string,
+  baseModelName: string
+): number | undefined {
+  const ancestorDistances = ancestorDistancesByModelName.get(modelName)
+  return ancestorDistances ? (ancestorDistances.get(baseModelName) ?? -1) : undefined
+}
+
 /**
  * Returns the model info for a model type name, or `undefined` if not found.
  *

package/src/modelShared/sharedInternalModel.ts

@@ -11,8 +11,8 @@ import type { DataModelMetadata } from "../dataModel/getDataModelMetadata"
 import { getGlobalConfig } from "../globalConfig/globalConfig"
 import { type AnyModel, BaseModel, baseModelPropNames } from "../model/BaseModel"
 import type { ModelMetadata } from "../model/getModelMetadata"
-import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { modelTypeKey } from "../model/metadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { typesObject } from "../types/objectBased/typesObject"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import type { AnyType } from "../types/schemas"

package/src/ref/Ref.ts

@@ -1,5 +1,5 @@
-import { Model } from "../model/Model"
 import { modelTypeKey } from "../model/metadata"
+import { Model } from "../model/Model"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import { tProp } from "../types/tProp"

package/src/snapshot/SnapshotterAndReconcilerPriority.ts

@@ -1,10 +1,11 @@
 /**
  * @internal
  */
-// biome-ignore lint/style/useEnumInitializers: that's ok, it is not serialized
+/* oxlint-disable typescript/prefer-enum-initializers -- that's ok, it is not serialized */
 export enum SnapshotterAndReconcilerPriority {
   Array,
   Frozen,
   Model,
   PlainObject,
 }
+/* oxlint-enable typescript/prefer-enum-initializers */

package/src/snapshot/fromModelSnapshot.ts

@@ -1,7 +1,7 @@
 import type { AnyModel } from "../model/BaseModel"
 import { getModelIdPropertyName } from "../model/getModelMetadata"
-import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { modelTypeKey } from "../model/metadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { getModelOrSnapshotTypeAndId, getSnapshotModelType } from "../model/utils"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"

package/src/snapshot/fromSnapshot.ts

@@ -83,7 +83,7 @@ export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
     let snapshot: any
     let unprocessedSnapshot: unknown
     let options: Partial<FromSnapshotOptions> | undefined
-    // biome-ignore lint/complexity/noArguments: overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
+    // oxlint-disable-next-line eslint/prefer-rest-params -- overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
     const standardType = arguments.length >= 2 ? resolveStandardTypeNoThrow(arg1) : undefined
 
     if (isLateTypeChecker(arg1) || arg1 instanceof TypeChecker || standardType) {

package/src/transforms/ImmutableDate.ts

@@ -3,25 +3,25 @@ import { failure } from "../utils"
 /**
  * @internal
  */
-export interface ImmutableDate
-  extends Omit<
-    Date,
-    | "setTime"
-    | "setMilliseconds"
-    | "setUTCMilliseconds"
-    | "setSeconds"
-    | "setUTCSeconds"
-    | "setMinutes"
-    | "setUTCMinutes"
-    | "setHours"
-    | "setUTCHours"
-    | "setDate"
-    | "setUTCDate"
-    | "setMonth"
-    | "setUTCMonth"
-    | "setFullYear"
-    | "setUTCFullYear"
-  > {}
+// oxlint-disable-next-line typescript/no-unsafe-declaration-merging -- the class implements this narrowed Date API.
+export interface ImmutableDate extends Omit<
+  Date,
+  | "setTime"
+  | "setMilliseconds"
+  | "setUTCMilliseconds"
+  | "setSeconds"
+  | "setUTCSeconds"
+  | "setMinutes"
+  | "setUTCMinutes"
+  | "setHours"
+  | "setUTCHours"
+  | "setDate"
+  | "setUTCDate"
+  | "setMonth"
+  | "setUTCMonth"
+  | "setFullYear"
+  | "setUTCFullYear"
+> {}
 
 const errMessage = "this Date object is immutable"
 

package/src/tweaker/tweakArray.ts

@@ -36,7 +36,6 @@ import { failure, inDevMode, isArray, isPrimitive } from "../utils"
 import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
 import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
 import { activateHandlers, areHandlersActive, runningWithoutSnapshotOrPatches } from "./core"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import {
   assertCanAttach,
@@ -46,6 +45,7 @@ import {
   tweak,
 } from "./tweak"
 import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { TweakerPriority } from "./TweakerPriority"
 import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**

package/src/tweaker/tweakFrozen.ts

@@ -2,9 +2,9 @@ import { Frozen, frozenKey } from "../frozen/Frozen"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
 import { setNewInternalSnapshot } from "../snapshot/internal"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker } from "./tweak"
+import { TweakerPriority } from "./TweakerPriority"
 
 /**
  * @internal

package/src/tweaker/tweakModel.ts

@@ -1,9 +1,9 @@
 import { isModel } from "../model/utils"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker } from "./tweak"
+import { TweakerPriority } from "./TweakerPriority"
 
 /**
  * @internal

package/src/tweaker/tweakPlainObject.ts

@@ -43,10 +43,10 @@ import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedT
 import { setIfDifferent } from "../utils/setIfDifferent"
 import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
 import { activateHandlers, runningWithoutSnapshotOrPatches } from "./core"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject, treeNodeMetadata } from "./treeNodeMetadata"
 import { assertCanAttachValue, registerTweaker, tweak } from "./tweak"
 import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { TweakerPriority } from "./TweakerPriority"
 import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**

package/src/types/SnapshotTypeMismatchError.ts

@@ -14,7 +14,9 @@ export interface SnapshotTypeMismatchErrorData {
 }
 
 /**
- * Thrown when a snapshot value does not match any of the expected types in a union (extends `MobxKeystoneError`).
+ * Thrown when a snapshot value does not match any of the expected types in a union, or when a
+ * model snapshot names a model (`$modelType`) that is not the expected model or a subclass of it
+ * (extends `MobxKeystoneError`).
  *
  * Use `instanceof SnapshotTypeMismatchError` to distinguish snapshot type-mismatch errors
  * from other `MobxKeystoneError` instances.

package/src/types/arrayBased/typesArray.ts

@@ -5,7 +5,6 @@ import { createChunkedArrayCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -14,6 +13,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 /**

package/src/types/arrayBased/typesTuple.ts

@@ -5,7 +5,6 @@ import { createWholeContainerCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -14,6 +13,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 /**

package/src/types/modelTypeMatching.ts

@@ -0,0 +1,276 @@
+import { modelTypeKey } from "../model/metadata"
+import {
+  findModelInfoForPrototype,
+  getModelSubclassDistance,
+  getModelSubclassDistanceForName,
+} from "../modelShared/modelInfo"
+import { isObject } from "../utils"
+
+/**
+ * Model type matching pass used while unions match a value against their branches, so they can
+ * prefer the branches whose models are the closest to the ones named by the snapshot
+ * (`$modelType`):
+ * - `none`: not matching union branches; model types match snapshots of their own model and of
+ *   its subclasses.
+ * - `exact`: model types only match snapshots of their own model.
+ * - `closest`: model types also match snapshots of subclasses, adding how far the subclass is
+ *   from the model to `subclassDistance`, so unions can pick the branch with the lowest total.
+ *
+ * @internal
+ */
+export type ModelTypeMatchingPass = "none" | "exact" | "closest"
+
+let currentPass: ModelTypeMatchingPass = "none"
+let subclassDistance = 0
+let rejectedModelSnapshot = false
+
+/**
+ * @internal
+ */
+export function getModelTypeMatchingPass(): ModelTypeMatchingPass {
+  return currentPass
+}
+
+/**
+ * Records that a model type matched a snapshot of a subclass `distance` levels below it.
+ *
+ * @internal
+ */
+export function addModelSubclassDistance(distance: number): void {
+  if (currentPass === "closest") {
+    subclassDistance += distance
+  }
+}
+
+/**
+ * Records, while unions match their branches, that a model type (or ref) rejected a model
+ * snapshot that some other branch could accept: one of a subclass in the exact pass (it would
+ * match it in the closest pass), or one of another registered model.
+ *
+ * @internal
+ */
+export function rejectModelSnapshot(): void {
+  if (currentPass !== "none") {
+    rejectedModelSnapshot = true
+  }
+}
+
+/**
+ * Runs a value match, returning whether it matched, or `undefined` if it did not because a model
+ * type (or ref) rejected a model snapshot (see `rejectModelSnapshot`).
+ *
+ * @internal
+ */
+export function matchUnlessModelSnapshotRejected<A, B>(
+  fn: (a: A, b: B) => unknown,
+  a: A,
+  b: B
+): boolean | undefined {
+  const prevRejectedModelSnapshot = rejectedModelSnapshot
+  rejectedModelSnapshot = false
+  try {
+    const matched = !!fn(a, b)
+    return matched || !rejectedModelSnapshot ? matched : undefined
+  } finally {
+    // let outer matches know too
+    rejectedModelSnapshot ||= prevRejectedModelSnapshot
+  }
+}
+
+/**
+ * Whether a snapshot `$modelType` matches a model (`modelName`): its own model or, outside the
+ * exact pass, a subclass of it. Registered names are compared rather than classes, since with
+ * hot reloading a subclass might still extend a previous registration of the model.
+ *
+ * @internal
+ */
+export function snapshotModelTypeMatches(snModelType: unknown, modelName: string): boolean {
+  if (typeof snModelType !== "string") {
+    return false
+  }
+  if (snModelType === modelName) {
+    return true
+  }
+  const distance = getModelSubclassDistanceForName(snModelType, modelName)
+  if (distance === undefined) {
+    return false
+  }
+  if (distance < 0 || currentPass === "exact") {
+    rejectModelSnapshot()
+    return false
+  }
+  addModelSubclassDistance(distance)
+  return true
+}
+
+/**
+ * Whether a snapshot `$modelType` names a registered model that is neither a model
+ * (`modelName`) nor a subclass of it, so processing the snapshot as that model would silently
+ * create an unrelated model (unregistered names are reported later by the model snapshotter).
+ *
+ * @internal
+ */
+export function isUnrelatedSnapshotModelType(snModelType: unknown, modelName: string): boolean {
+  return (
+    typeof snModelType === "string" &&
+    snModelType !== modelName &&
+    (getModelSubclassDistanceForName(snModelType, modelName) ?? 0) < 0
+  )
+}
+
+/**
+ * Whether a model instance is of a model (`modelName`) or of a subclass of it, comparing
+ * registered names, since with hot reloading the instance model might still extend a previous
+ * registration of the model.
+ *
+ * @internal
+ */
+export function isModelInstanceOfModelName(value: object, modelName: string): boolean {
+  const valueModelInfo = findModelInfoForPrototype(Object.getPrototypeOf(value))
+  return !!valueModelInfo && getModelSubclassDistance(valueModelInfo, modelName) >= 0
+}
+
+/**
+ * Whether a value is a snapshot that names its model (`$modelType`).
+ *
+ * @internal
+ */
+export function hasSnapshotModelType(value: unknown): boolean {
+  return isObject(value) && typeof value[modelTypeKey] === "string"
+}
+
+/**
+ * Runs a function in the given model type matching pass, restoring the current one afterwards.
+ *
+ * @internal
+ */
+export function runInModelTypeMatchingPass<A, B, R>(
+  pass: ModelTypeMatchingPass,
+  fn: (a: A, b: B) => R,
+  a: A,
+  b: B
+): R {
+  if (pass === "none" && currentPass === "none") {
+    return fn(a, b)
+  }
+
+  const prevPass = currentPass
+  const prevDistance = subclassDistance
+  const prevRejectedModelSnapshot = rejectedModelSnapshot
+  currentPass = pass
+  subclassDistance = 0
+  rejectedModelSnapshot = false
+  try {
+    return fn(a, b)
+  } finally {
+    currentPass = prevPass
+    subclassDistance = prevDistance
+    rejectedModelSnapshot = prevRejectedModelSnapshot
+  }
+}
+
+/**
+ * Finds the union branch (candidate) that matches a value, preferring branches that match the
+ * exact models named by the snapshot (branches without models count as exact matches), then
+ * the branches whose models are the closest base models of the snapshot ones (the fewest
+ * subclass levels away in total), and the first one on ties.
+ *
+ * @internal
+ */
+export function findClosestModelTypeMatch<T, R>(
+  candidates: ReadonlyArray<T>,
+  match: (candidate: T, value: unknown) => R | null | undefined,
+  value: unknown
+): R | undefined {
+  switch (currentPass) {
+    case "exact":
+      // nested inside an exact pass
+      return findNestedMatch(findFirstMatch, candidates, match, value, 0)
+    case "closest":
+      // nested inside a closest pass
+      return findNestedMatch(findClosestMatch, candidates, match, value, 0)
+    default:
+      try {
+        currentPass = "exact"
+        const exactMatch = findFirstMatch(candidates, match, value)
+        if (exactMatch != null) {
+          return exactMatch
+        }
+
+        currentPass = "closest"
+        subclassDistance = 0
+        // no branch matched exactly, so none can be less than one subclass level away
+        return findClosestMatch(candidates, match, value, 1)
+      } finally {
+        currentPass = "none"
+        subclassDistance = 0
+        rejectedModelSnapshot = false
+      }
+  }
+}
+
+function findNestedMatch<T, R>(
+  find: (
+    candidates: ReadonlyArray<T>,
+    match: (candidate: T, value: unknown) => R | null | undefined,
+    value: unknown,
+    minPossibleDistance: number
+  ) => R | undefined,
+  candidates: ReadonlyArray<T>,
+  match: (candidate: T, value: unknown) => R | null | undefined,
+  value: unknown,
+  minPossibleDistance: number
+): R | undefined {
+  const prevRejectedModelSnapshot = rejectedModelSnapshot
+  const result = find(candidates, match, value, minPossibleDistance)
+  if (result != null) {
+    // model snapshots rejected by other branches do not matter then
+    rejectedModelSnapshot = prevRejectedModelSnapshot
+  }
+  return result
+}
+
+/**
+ * Finds the first candidate that matches a value.
+ *
+ * @internal
+ */
+export function findFirstMatch<T, R>(
+  candidates: ReadonlyArray<T>,
+  match: (candidate: T, value: unknown) => R | null | undefined,
+  value: unknown
+): R | undefined {
+  for (let i = 0; i < candidates.length; i++) {
+    const result = match(candidates[i], value)
+    if (result != null) {
+      return result
+    }
+  }
+  return undefined
+}
+
+function findClosestMatch<T, R>(
+  candidates: ReadonlyArray<T>,
+  match: (candidate: T, value: unknown) => R | null | undefined,
+  value: unknown,
+  minPossibleDistance: number
+): R | undefined {
+  const prevDistance = subclassDistance
+  let best: R | undefined
+  let bestDistance = Number.POSITIVE_INFINITY
+
+  for (let i = 0; i < candidates.length; i++) {
+    subclassDistance = 0
+    const result = match(candidates[i], value)
+    if (result != null && subclassDistance < bestDistance) {
+      best = result
+      bestDistance = subclassDistance
+      if (bestDistance <= minPossibleDistance) {
+        break
+      }
+    }
+  }
+
+  subclassDistance = prevDistance + (best != null ? bestDistance : 0)
+  return best
+}

package/src/types/objectBased/typesArraySet.ts

@@ -7,7 +7,6 @@ import { typesArray } from "../arrayBased/typesArray"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -16,6 +15,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { resolveCodecSupport } from "../utility/typesCodec"
 import { typesObject } from "./typesObject"
 

package/src/types/objectBased/typesModel.ts

@@ -2,16 +2,21 @@ import type { O } from "ts-toolbelt"
 import type { AnyModel } from "../../model/BaseModel"
 import { getModelMetadata } from "../../model/getModelMetadata"
 import { modelTypeKey } from "../../model/metadata"
-import { isModelClass } from "../../model/utils"
+import { isModel, isModelClass } from "../../model/utils"
 import type { ModelClass } from "../../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
 import { isObject, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
+import {
+  isModelInstanceOfModelName,
+  isUnrelatedSnapshotModelType,
+  snapshotModelTypeMatches,
+} from "../modelTypeMatching"
 import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, ModelType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import {
   lateTypeChecker,
   TypeChecker,
@@ -19,6 +24,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 
 const cachedModelTypeChecker = new WeakMap<ModelClass<AnyModel>, TypeChecker>()
 const modelStandardTypes = new WeakSet<object>()
@@ -73,7 +79,10 @@ export function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>):
         TypeCheckerBaseType.Object,
 
         (value, path, typeCheckedValue) => {
-          if (!(value instanceof modelClazz)) {
+          if (
+            !(value instanceof modelClazz) &&
+            !(isModel(value) && isModelInstanceOfModelName(value, modelInfo.name))
+          ) {
             return new TypeCheckError({
               path,
               expectedTypeName: typeName,
@@ -96,9 +105,9 @@ export function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>):
             return null
           }
 
-          if (value[modelTypeKey] !== undefined) {
-            // fast check
-            return value[modelTypeKey] === modelInfo.name ? thisTc : null
+          const snModelType = value[modelTypeKey]
+          if (snModelType !== undefined) {
+            return snapshotModelTypeMatches(snModelType, modelInfo.name) ? thisTc : null
           }
 
           if (resolvedDataTypeChecker) {
@@ -112,7 +121,15 @@ export function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>):
         // No withErrorPathSegment wrapping needed here — model snapshot processors
         // delegate to the data type checker, which handles path segments at the property level.
         (sn) => {
-          if (sn[modelTypeKey]) {
+          const snModelType = sn[modelTypeKey]
+          if (typeof snModelType === "string") {
+            // the snapshot names its own model; make sure it is this model or a subclass of it
+            if (isUnrelatedSnapshotModelType(snModelType, modelInfo.name)) {
+              throw new SnapshotTypeMismatchError({
+                expectedTypeName: typeName,
+                actualValue: sn,
+              })
+            }
             return sn
           } else {
             return {

package/src/types/objectBased/typesObject.ts

@@ -23,7 +23,6 @@ import type {
   ObjectTypeFunction,
   TypeToData,
 } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   type LateTypeChecker,
   lateTypeChecker,
@@ -34,6 +33,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 const needsObservableObjectKeyTracking = getMobxVersion() < 5