mobx-keystone 2.2.0 → 2.3.0

package/dist/types/types/SnapshotTypeMismatchError.d.ts

@@ -7,7 +7,9 @@ export interface SnapshotTypeMismatchErrorData {
     modelTrail?: readonly string[];
 }
 /**
- * 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/dist/types/types/modelTypeMatching.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -67,17 +67,17 @@
     "mobx": "^7.0.0 || ^6.0.0 || ^5.0.0 || ^4.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^8.0.1",
+    "@babel/core": "^8.0.6",
     "@babel/plugin-proposal-decorators": "^8.0.2",
     "@babel/plugin-transform-class-properties": "^8.0.1",
-    "@babel/plugin-transform-class-static-block": "^8.0.1",
-    "@babel/plugin-transform-typescript": "^8.0.1",
-    "@babel/preset-env": "^8.0.2",
+    "@babel/plugin-transform-class-static-block": "^8.0.5",
+    "@babel/plugin-transform-typescript": "^8.0.6",
+    "@babel/preset-env": "^8.0.6",
     "@swc/core": "^1.16.2",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.6.2",
     "@typescript/typescript6": "^6.0.2",
-    "@vitest/coverage-v8": "^5.0.0",
+    "@vitest/coverage-v8": "^5.0.1",
     "expect-type": "^1.4.0",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
@@ -89,9 +89,9 @@
     "typedoc-docusaurus-theme": "^1.4.3",
     "typedoc-plugin-markdown": "^4.13.1",
     "typescript": "^7.0.2",
-    "vite": "^8.2.2",
-    "vite-plugin-dts": "^5.1.0",
-    "vitest": "^5.0.0"
+    "vite": "^8.3.1",
+    "vite-plugin-dts": "^5.1.1",
+    "vitest": "^5.0.1"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/modelShared/modelDecorator.ts

@@ -9,7 +9,7 @@ import type { AnyModel } from "../model/BaseModel"
 import { modelTypeKey } from "../model/metadata"
 import { isModelClass } from "../model/utils"
 import { type ModelClass, modelInitializedSymbol } from "../modelShared/BaseModelShared"
-import { modelInfoByClass, modelInfoByName } from "../modelShared/modelInfo"
+import { modelInfoByClass, modelInfoByName, setModelInfo } from "../modelShared/modelInfo"
 import {
   modelUnwrappedClassSymbol,
   runAfterModelDecoratorSymbol,
@@ -167,10 +167,7 @@ const internalModel = <MC extends ModelClass<AnyModel | AnyDataModel>>(
     class: decoratedClass,
   }
 
-  modelInfoByName[name] = modelInfo
-
-  modelInfoByClass.set(decoratedClass, modelInfo)
-  modelInfoByClass.set(clazz, modelInfo)
+  setModelInfo(modelInfo, clazz)
 
   runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
 

package/src/modelShared/modelInfo.ts

@@ -22,6 +22,81 @@ 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>()
+  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/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/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/typesModel.ts

@@ -2,14 +2,20 @@ 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 { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import type { AnyStandardType, ModelType } from "../schemas"
 import { TypeCheckError } from "../TypeCheckError"
 import {
@@ -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/typesRef.ts

@@ -1,9 +1,16 @@
 import { modelTypeKey } from "../../model/metadata"
+import { isModel } from "../../model/utils"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import type { Ref, RefConstructor } from "../../ref/Ref"
 import { isObject } from "../../utils"
+import {
+  isModelInstanceOfModelName,
+  isUnrelatedSnapshotModelType,
+  snapshotModelTypeMatches,
+} from "../modelTypeMatching"
 import { typesString } from "../primitiveBased/typesPrimitive"
 import { resolveTypeChecker } from "../resolveTypeChecker"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import type { ModelType } from "../schemas"
 import { TypeCheckError } from "../TypeCheckError"
 import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker"
@@ -36,7 +43,10 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
     TypeCheckerBaseType.Object,
 
     (value, path, typeCheckedValue) => {
-      if (!(value instanceof refConstructor.refClass)) {
+      if (
+        !(value instanceof refConstructor.refClass) &&
+        !(isModel(value) && isModelInstanceOfModelName(value, modelInfo.name))
+      ) {
         return new TypeCheckError({
           path,
           expectedTypeName: typeName,
@@ -56,16 +66,25 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
         return null
       }
 
-      if (obj[modelTypeKey] !== undefined) {
+      const snModelType = obj[modelTypeKey]
+      if (snModelType !== undefined) {
         // fast check
-        return obj[modelTypeKey] === modelInfo.name ? thisTc : null
+        return snapshotModelTypeMatches(snModelType, modelInfo.name) ? thisTc : null
       }
 
       return refDataTypeChecker.snapshotType(obj) ? thisTc : null
     },
 
     (sn: Record<string, unknown>) => {
-      if (sn[modelTypeKey]) {
+      const snModelType = sn[modelTypeKey]
+      if (typeof snModelType === "string") {
+        // the snapshot names its own model; make sure it is this ref or a subclass of it
+        if (isUnrelatedSnapshotModelType(snModelType, modelInfo.name)) {
+          throw new SnapshotTypeMismatchError({
+            expectedTypeName: typeName,
+            actualValue: sn,
+          })
+        }
         return sn
       } else {
         return {

package/src/types/utility/typesCodecCore.ts

@@ -1,6 +1,7 @@
 import type { ModelPropTransform } from "../../modelShared/prop"
 import { lazy } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
+import { runInModelTypeMatchingPass } from "../modelTypeMatching"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type {
   AnyStandardType,
@@ -145,7 +146,8 @@ export function createCodecType<TEncodedType extends AnyType, TRuntime>(
       () => typeName,
       typeInfoGen,
 
-      (value) => (is(value) ? thisTc : null),
+      // user code, so it must not see the model type matching pass of an outer union
+      (value) => (runInModelTypeMatchingPass("none", is, value, undefined) ? thisTc : null),
 
       (snapshot) => {
         const processedSnapshot = encodedTypeChecker.fromSnapshotProcessor(snapshot)

package/src/types/utility/typesCodecSupport.ts

@@ -5,6 +5,7 @@ import { setIfDifferent } from "../../utils/setIfDifferent"
 import { ArrayTypeInfo, typesArray } from "../arrayBased/typesArray"
 import { TupleTypeInfo, typesTuple } from "../arrayBased/typesTuple"
 import { getTypeInfo } from "../getTypeInfo"
+import { findClosestModelTypeMatch, findFirstMatch } from "../modelTypeMatching"
 import { isDataModelDataStandardType } from "../objectBased/typesDataModelData"
 import { isModelStandardType } from "../objectBased/typesModel"
 import { ObjectTypeInfo, typesObject } from "../objectBased/typesObject"
@@ -577,6 +578,13 @@ function createCodecLeafRuntimeAdapter(
   }
 }
 
+function matchCodecSupport(
+  support: ResolvedCodecSupport,
+  value: unknown
+): ResolvedCodecSupport | undefined {
+  return resolveTypeChecker(support.storedType).snapshotType(value) ? support : undefined
+}
+
 function createOrRuntimeAdapter(
   childTypes: ReadonlyArray<AnyStandardType>,
   getChildSupports: () => ReadonlyArray<ResolvedCodecSupport>,
@@ -607,14 +615,12 @@ function createOrRuntimeAdapter(
     }
 
     const supports = getChildSupports()
-    for (let i = 0; i < supports.length; i++) {
-      const storedTypeChecker = resolveTypeChecker(supports[i].storedType)
-      if (storedTypeChecker.snapshotType(value)) {
-        return supports[i]
-      }
-    }
+    // prefer branches whose (possibly nested) models are the closest to the snapshot ones
+    const matchingSupport = isObject(value)
+      ? findClosestModelTypeMatch(supports, matchCodecSupport, value)
+      : findFirstMatch(supports, matchCodecSupport, value)
 
-    return supports[0]
+    return matchingSupport ?? supports[0]
   }
 
   return {