mobx-keystone 1.25.0 → 2.0.0

package/src/tweaker/tweakPlainObject.ts

@@ -19,7 +19,13 @@ import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../model
 import { dataToModelNode } from "../parent/core"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
-import { hasPatchListenersFor, InternalPatchRecorder } from "../patch/emitPatch"
+import {
+  beginPatchEmission,
+  emitPatches,
+  endPatchEmission,
+  hasPatchListenersFor,
+  InternalPatchRecorder,
+} from "../patch/emitPatch"
 import {
   flushInternalSnapshot,
   freezeInternalSnapshot,
@@ -29,13 +35,23 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { takeModelInitialDataSnapshot } from "../snapshot/modelInitialData"
+import { withoutCachedTypeChecking } from "../types/createCachedTypeCheck"
 import { failure, isPlainObject, isPrimitive, setProtoProp } from "../utils"
+import {
+  addDelayedError,
+  type DelayedError,
+  throwDelayedError,
+} from "../utils/forEachWithDelayedThrow"
 import { setIfDifferent } from "../utils/setIfDifferent"
 import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker, tweak } from "./tweak"
-import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
+import {
+  isTypeCheckingAfterChangeEnabled,
+  recordTypeCheckingBatchChange,
+  runTypeCheckingAfterChange,
+} from "./typeChecking"
 
 /**
  * @internal
@@ -65,7 +81,9 @@ export function tweakPlainObject<T extends Record<string, any>>(
   )
 
   const initialDataSnapshot =
-    isDataObject && snapshotModelType ? takeModelInitialDataSnapshot(tweakedObj) : undefined
+    isDataObject && snapshotModelType !== undefined
+      ? takeModelInitialDataSnapshot(tweakedObj)
+      : undefined
   const untransformedSn: any = initialDataSnapshot ?? {}
 
   // substitute initial values by tweaked values
@@ -112,7 +130,7 @@ export function tweakPlainObject<T extends Record<string, any>>(
   }
 
   let transformFn: SnapshotTransformFn | undefined
-  if (snapshotModelType) {
+  if (snapshotModelType !== undefined) {
     untransformedSn[modelTypeKey] = snapshotModelType
 
     const modelInfo = getModelInfoForName(snapshotModelType)
@@ -167,27 +185,12 @@ function objectDidChange(change: IObjectDidChange): void {
 
   patchRecorder.reset()
 
-  switch (change.type) {
-    case "add":
-      emitObjectAddDeepChange(actualNode, obj, change.name, change.newValue)
-      break
-
-    case "update":
-      emitObjectUpdateDeepChange(actualNode, obj, change.name, change.newValue, change.oldValue)
-      break
-
-    case "remove":
-      emitObjectRemoveDeepChange(actualNode, obj, change.name, change.oldValue)
-      break
-
-    default:
-      throw failure("assertion error: unsupported object change type")
-  }
-
   if (runningWithoutSnapshotOrPatches) {
     return
   }
 
+  recordTypeCheckingBatchChange(change)
+
   const oldUntransformedSn = getInternalSnapshot(actualNode)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(actualNode)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
@@ -215,9 +218,59 @@ function objectDidChange(change: IObjectDidChange): void {
       throw failure("assertion error: unsupported object change type")
   }
 
-  runTypeCheckingAfterChange(obj, patchRecorder)
+  if (change.type !== "update" && isTypeCheckingAfterChangeEnabled()) {
+    // MobX notifies object observers before invalidating dependencies on missing
+    // keys (and removed keys in MobX 4). Cached ancestor checks may still
+    // describe the previous shape.
+    withoutCachedTypeChecking(obj, () => runTypeCheckingAfterChange(obj, patchRecorder))
+  } else {
+    runTypeCheckingAfterChange(obj, patchRecorder)
+  }
   updateInternalSnapshot(actualNode, mutate)
-  patchRecorder.emit(actualNode)
+
+  // Listeners may mutate another node and reuse the shared recorder.
+  // Keep this change's patches before publishing the validated deep change.
+  const { patches, invPatches } = patchRecorder
+  patchRecorder.reset()
+
+  // Reserve chronological patch notifications, then finish deep-change delivery
+  // before publishing them. Reentrant edits append behind this mutation.
+  // Every step below runs even when an earlier one throws, so a failing patch recorder
+  // cannot keep the mutation from reaching the deep change and public patch listeners,
+  // and no failure is lost to a later one.
+  beginPatchEmission()
+  let delayedError: DelayedError
+  try {
+    emitPatches(actualNode, patches, invPatches)
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    switch (change.type) {
+      case "add":
+        emitObjectAddDeepChange(actualNode, obj, change.name, change.newValue)
+        break
+
+      case "update":
+        emitObjectUpdateDeepChange(actualNode, obj, change.name, change.newValue, change.oldValue)
+        break
+
+      case "remove":
+        emitObjectRemoveDeepChange(actualNode, obj, change.name, change.oldValue)
+        break
+
+      default:
+        throw failure("assertion error: unsupported object change type")
+    }
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    endPatchEmission()
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  throwDelayedError(delayedError)
 }
 
 function objectDidChangeRemove(

package/src/tweaker/typeChecking.ts

@@ -1,3 +1,4 @@
+import { type IArrayDidChange, type IObjectDidChange, remove, set } from "mobx"
 import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig"
 import type { AnyModel } from "../model/BaseModel"
 import { getModelMetadata } from "../model/getModelMetadata"
@@ -8,7 +9,7 @@ import { internalApplyPatches } from "../patch/applyPatches"
 import type { InternalPatchRecorder } from "../patch/emitPatch"
 import { internalApplySnapshot } from "../snapshot/applySnapshot"
 import { runWithoutSnapshotOrPatches } from "./core"
-import { isTypeCheckingAllowed } from "./withoutTypeChecking"
+import { isTypeCheckingAllowed, withoutTypeChecking } from "./withoutTypeChecking"
 
 // Re-entrancy guard: when true, we are inside a type-check rollback.
 // During rollback, observe callbacks still fire, but we skip the auto
@@ -34,14 +35,15 @@ function isModelWithTypeChecker(obj: object): obj is AnyModel {
  * @internal
  *
  * Walks up parent chain from `obj`, calling `callback` for each typed model
- * ancestor (nearest-first / bottom-up). Stops early if the callback throws.
+ * including the target itself (nearest-first / bottom-up). Stops if the callback throws.
  */
 function forEachTypedModelAncestor(obj: object, callback: (model: AnyModel) => void): void {
   // obj might be a $ data object, so resolve to the model if applicable
   const start = dataToModelNode(obj)
 
-  // If we started from a $ data object, check the model itself
-  if (start !== obj && isModelWithTypeChecker(start)) {
+  // Both model-data mutations and whole-model reconciliation must validate
+  // the model itself before checking its ancestors.
+  if (isModelWithTypeChecker(start)) {
     callback(start)
   }
 
@@ -76,20 +78,19 @@ export function runTypeCheckingAfterChange(
     forEachTypedModelAncestor(obj, (model) => {
       const err = model.typeCheck()
       if (err) {
-        // quietly apply inverse patches (do not generate patches, snapshots, actions, etc)
-        // The re-entrancy guard prevents auto type checking during rollback:
-        // rollback mutations trigger observe callbacks which call this function,
-        // and with "all" scope those re-entrant checks could see partially-restored
-        // intermediate state and attempt another rollback, causing infinite recursion.
+        // A rejected individual mutation has not updated its snapshot yet,
+        // so inverse patches must stay quiet. Snapshot reconciliation has
+        // already published changes: its rollback must update snapshots and
+        // emit compensating patches as well.
         isRollingBackTypeCheckFailure = true
         try {
-          runWithoutSnapshotOrPatches(() => {
-            if (patchRecorder) {
+          if (patchRecorder) {
+            runWithoutSnapshotOrPatches(() => {
               internalApplyPatches.call(obj, patchRecorder.invPatches, true)
-            } else if (snapshotBeforeChanges) {
-              internalApplySnapshot.call(obj, snapshotBeforeChanges)
-            }
-          })
+            })
+          } else if (snapshotBeforeChanges) {
+            internalApplySnapshot.call(obj, snapshotBeforeChanges)
+          }
         } finally {
           isRollingBackTypeCheckFailure = false
         }
@@ -98,3 +99,111 @@ export function runTypeCheckingAfterChange(
     })
   }
 }
+
+interface TypeCheckingBatch {
+  models: Set<AnyModel>
+  undo: (() => void)[]
+  recording: boolean
+  /** Last recorded change target, so a run of changes to it walks ancestors once. */
+  previousTarget?: object
+}
+
+let typeCheckingBatch: TypeCheckingBatch | undefined
+
+/** @internal Called only when automatic type checking is enabled. */
+export function typeCheckAfterCreation(model: AnyModel): void {
+  if (typeCheckingBatch?.recording) {
+    typeCheckingBatch.models.add(model)
+  } else {
+    const error = model.typeCheck()
+    if (error) error.throw()
+  }
+}
+
+/**
+ * @internal
+ * Capture stored values before any listener can mutate them again. Restoring
+ * live values preserves identity and literal data, without snapshot processors
+ * or model defaults changing the state being restored.
+ */
+export function recordTypeCheckingBatchChange(change: IObjectDidChange | IArrayDidChange): void {
+  const batch = typeCheckingBatch
+  if (!batch?.recording) return
+  if (
+    change.type === "splice" &&
+    change.addedCount === change.removedCount &&
+    change.added.every((value, index) => value === change.removed[index])
+  )
+    return
+
+  const target = change.object
+  if (target !== batch.previousTarget) {
+    forEachTypedModelAncestor(target, (model) => batch.models.add(model))
+    batch.previousTarget = target
+  }
+
+  if (change.type === "splice") {
+    const { object, index, addedCount } = change
+    const removed = change.removed.slice()
+    batch.undo.push(() => object.spliceWithArray(index, addedCount, removed))
+  } else if ("index" in change) {
+    const { object, index, oldValue } = change
+    batch.undo.push(() => {
+      object[index] = oldValue
+    })
+  } else {
+    const { object } = change
+    const key = change.name as string
+    if (change.type === "add") {
+      batch.undo.push(() => remove(object, key))
+    } else {
+      const { oldValue } = change
+      batch.undo.push(() => set(object, key, oldValue))
+    }
+  }
+}
+
+/**
+ * @internal
+ * Nested calls and synchronous listener edits join the same validation batch.
+ * Rollback publishes compensating changes, just like snapshot reconciliation.
+ */
+export function withTypeCheckingBatch(fn: () => void): void {
+  if (typeCheckingBatch || !isTypeCheckingAfterChangeEnabled()) {
+    fn()
+    return
+  }
+
+  const batch: TypeCheckingBatch = { models: new Set(), undo: [], recording: true }
+  typeCheckingBatch = batch
+  let validating = false
+  try {
+    withoutTypeChecking(fn)
+    // MobX has now invalidated dependencies, including added/removed keys.
+    validating = true
+    for (const model of batch.models) {
+      const error = model.typeCheck()
+      if (error) error.throw()
+    }
+  } catch (error) {
+    // Only a rejected validation rolls back. Errors thrown by the batch body
+    // itself (an invalid patch, a throwing listener) keep the same partial
+    // application they produce while automatic type checking is disabled.
+    if (validating) {
+      batch.recording = false
+      withoutTypeChecking(() => {
+        for (let i = batch.undo.length - 1; i >= 0; i--) {
+          try {
+            batch.undo[i]()
+          } catch {
+            // Keep restoring after a rollback listener throws. The original
+            // failure takes precedence over errors from compensating changes.
+          }
+        }
+      })
+    }
+    throw error
+  } finally {
+    typeCheckingBatch = undefined
+  }
+}

package/src/types/TypeCheckError.ts

@@ -1,4 +1,5 @@
-import { fastGetRootPath } from "../parent/path"
+import { dataToModelNode } from "../parent/core"
+import { fastGetParent, fastGetRootPath } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 import { getSnapshot } from "../snapshot/getSnapshot"
 import { isTweakedObject } from "../tweaker/core"
@@ -10,6 +11,7 @@ import {
 } from "../utils/errorDiagnostics"
 
 export interface TypeCheckErrorData {
+  /** Path relative to the value being type checked. */
   path: Path
   expectedTypeName: string
   actualValue: any
@@ -71,8 +73,15 @@ export class TypeCheckError {
    */
   throw(): never {
     const diagnosticsPath = getErrorPathSnapshot()
+    const hasTreeParent =
+      isTweakedObject(this.typeCheckedValue, true) &&
+      fastGetParent(dataToModelNode(this.typeCheckedValue), false) !== undefined
+    // Attached values supply their location through the tree. Context supplies
+    // the location for detached values, such as models being hydrated.
     const path =
-      diagnosticsPath && diagnosticsPath.length > 0 ? [...diagnosticsPath, ...this.path] : this.path
+      diagnosticsPath && diagnosticsPath.length > 0 && !hasTreeParent
+        ? [...diagnosticsPath, ...this.path]
+        : this.path
 
     throw new TypeCheckErrorFailure({
       path,
@@ -146,7 +155,7 @@ function resolveTypeCheckErrorData(data: TypeCheckErrorData): {
   const modelTrail = data.modelTrail ?? getErrorModelTrailSnapshot()
   const fullPath = resolveFullPath(data.path, data.typeCheckedValue)
   const actualValueSnapshot = isTweakedObject(data.actualValue, true)
-    ? getSnapshot(data.actualValue)
+    ? getSnapshot(dataToModelNode(data.actualValue))
     : data.actualValue
 
   return {
@@ -162,22 +171,11 @@ function resolveTypeCheckErrorData(data: TypeCheckErrorData): {
 }
 
 function resolveFullPath(path: Path, typeCheckedValue: any): Path {
-  let rootPath: Path = []
-  if (typeCheckedValue && isTweakedObject(typeCheckedValue, true)) {
-    rootPath = fastGetRootPath(typeCheckedValue, false).path
-  }
-  return rootPath.length > 0 && !pathStartsWith(path, rootPath) ? [...rootPath, ...path] : path
-}
-
-function pathStartsWith(path: Path, prefix: Path): boolean {
-  if (prefix.length > path.length) {
-    return false
-  }
-
-  for (let i = 0; i < prefix.length; i++) {
-    if (path[i] !== prefix[i]) {
-      return false
+  if (isTweakedObject(typeCheckedValue, true)) {
+    const rootPath = fastGetRootPath(dataToModelNode(typeCheckedValue), false).path
+    if (rootPath.length > 0) {
+      return [...rootPath, ...path]
     }
   }
-  return true
+  return path
 }

package/src/types/createCachedTypeCheck.ts

@@ -1,8 +1,32 @@
 import { computed, type IComputedValue, type IObjectDidChange, observe } from "mobx"
+import { dataToModelNode, modelToDataNode } from "../parent/core"
+import { fastGetParent } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 import { isTweakedObject } from "../tweaker/core"
 import { TypeCheckError } from "./TypeCheckError"
 
+let uncachedTypeCheckObjects: Set<object> | undefined
+
+/** @internal */
+export function withoutCachedTypeChecking(obj: object, fn: () => void): void {
+  const previous = uncachedTypeCheckObjects
+  const affected = new Set(previous)
+  // Only these containers can retain a cached result for the old shape.
+  // Model schema checks run on $ data, while refinements can check the model.
+  let current: object | undefined = dataToModelNode(obj)
+  while (current) {
+    affected.add(current)
+    affected.add(modelToDataNode(current))
+    current = fastGetParent(current, false)
+  }
+  uncachedTypeCheckObjects = affected
+  try {
+    fn()
+  } finally {
+    uncachedTypeCheckObjects = previous
+  }
+}
+
 const emptyPath: Path = []
 
 function contextualizeCachedError(
@@ -16,6 +40,7 @@ function contextualizeCachedError(
 
   return new TypeCheckError({
     path: [...path, ...error.path],
+    modelTrail: error.modelTrail,
     expectedTypeName: error.expectedTypeName,
     actualValue: error.actualValue,
     typeCheckedValue,
@@ -52,7 +77,7 @@ function createAdaptivePerEntryCachedCheck<K>(
     iterateEntries(value, (key) => checkEntry(value, key, path, typeCheckedValue))
 
   return (value, path, typeCheckedValue) => {
-    if (!isTweakedObject(value, true)) {
+    if (uncachedTypeCheckObjects?.has(value) || !isTweakedObject(value, true)) {
       return checkAllEntries(value, path, typeCheckedValue)
     }
 
@@ -142,7 +167,7 @@ export function createWholeContainerCachedCheck(
   const cache = new WeakMap<object, IComputedValue<TypeCheckError | null>>()
 
   return (value, path, typeCheckedValue) => {
-    if (!isTweakedObject(value, true)) {
+    if (uncachedTypeCheckObjects?.has(value) || !isTweakedObject(value, true)) {
       return check(value, path, typeCheckedValue)
     }
 

package/src/types/objectBased/typesDataModelData.ts

@@ -10,7 +10,7 @@ import type {
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
-import { failure, lazy } from "../../utils"
+import { failure, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
 import {
   registerStandardTypeResolver,
@@ -168,12 +168,14 @@ export class DataModelDataTypeInfo extends TypeInfo {
         hasDefault = true
       }
 
-      propTypes[propName] = {
+      const propInfo = {
         type,
         typeInfo,
         hasDefault,
         default: defaultValue,
       }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesModel.ts

@@ -7,7 +7,7 @@ import type { ModelClass } from "../../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
-import { isObject, lazy } from "../../utils"
+import { isObject, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
 import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, ModelType } from "../schemas"
@@ -178,12 +178,14 @@ export class ModelTypeInfo extends TypeInfo {
         hasDefault = true
       }
 
-      propTypes[propName] = {
+      const propInfo = {
         type,
         typeInfo,
         hasDefault,
         default: defaultValue,
       }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesObject.ts

@@ -2,7 +2,16 @@ import { isObservableObject, keys } from "mobx"
 import type { O } from "ts-toolbelt"
 import { Frozen } from "../../frozen/Frozen"
 import type { Path } from "../../parent/pathTypes"
-import { assertIsFunction, assertIsObject, getMobxVersion, isObject, lazy } from "../../utils"
+import {
+  assertIsFunction,
+  assertIsObject,
+  copyOwnEnumerableProps,
+  getMobxVersion,
+  isArray,
+  isObject,
+  lazy,
+  setProtoProp,
+} from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
 import { createIndexedPerEntryCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
@@ -106,27 +115,20 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       obj: Record<string, unknown>,
       processors: ReadonlyArray<SnapshotProcessor | undefined>
     ) => {
-      const newObj: typeof obj = {}
-
       // note: we allow excess properties when checking objects
-      const keys = Object.keys(obj)
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]
+      return copyOwnEnumerableProps({}, obj, (value, k) => {
         const schemaEntry = schemaEntryByPropName[k]
         if (schemaEntry) {
           const processor = processors[schemaEntry.processorIndex]
-          newObj[k] = processor ? withErrorPathSegment(k, () => processor(obj[k])) : obj[k]
-        } else {
-          // unknown prop, copy as is
-          newObj[k] = obj[k]
+          return processor ? withErrorPathSegment(k, () => processor(value)) : value
         }
-      }
-
-      return newObj
+        // unknown prop, copy as is
+        return value
+      })
     }
 
     const checkObjectType = (obj: any, path: Path, typeCheckedValue: any) => {
-      if (!isObject(obj) || (frozen && !(obj instanceof Frozen))) {
+      if (!isObject(obj) || isArray(obj) || (frozen && !(obj instanceof Frozen))) {
         return new TypeCheckError({
           path,
           expectedTypeName: getTypeName(thisTc),
@@ -187,7 +189,7 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       typeInfoGen,
 
       (obj) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return null
         }
 
@@ -278,7 +280,9 @@ export class ObjectTypeInfo extends TypeInfo {
     const propTypes: O.Writable<ObjectTypeInfoProps> = {}
     Object.keys(objSchema).forEach((propName) => {
       const type = resolveStandardType(objSchema[propName])
-      propTypes[propName] = { type, typeInfo: getTypeInfo(type) }
+      const propInfo = { type, typeInfo: getTypeInfo(type) }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesRecord.ts

@@ -1,6 +1,6 @@
 import { isObservableObject, keys } from "mobx"
 import type { Path } from "../../parent/pathTypes"
-import { failure, isObject } from "../../utils"
+import { copyOwnEnumerableProps, failure, isArray, isObject } from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
 import { createAdaptiveRecordCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
@@ -48,16 +48,9 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
         return obj
       }
 
-      const newObj: typeof obj = {}
-
-      const keys = Object.keys(obj)
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]
-        const v = withErrorPathSegment(k, () => processor(obj[k]))
-        newObj[k] = v
-      }
-
-      return newObj
+      return copyOwnEnumerableProps({}, obj, (value, key) =>
+        withErrorPathSegment(key, () => processor(value))
+      )
     }
 
     const iterateRecordEntries = (
@@ -97,7 +90,7 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       TypeCheckerBaseType.Object,
 
       (obj, path, typeCheckedValue) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return new TypeCheckError({
             path,
             expectedTypeName: getTypeName(thisTc),
@@ -117,7 +110,7 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       typeInfoGen,
 
       (obj) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return null
         }
 

package/src/types/objectBased/typesRef.ts

@@ -1,6 +1,6 @@
 import { modelTypeKey } from "../../model/metadata"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { Ref, type RefConstructor } from "../../ref/Ref"
+import type { Ref, RefConstructor } from "../../ref/Ref"
 import { isObject } from "../../utils"
 import { typesString } from "../primitiveBased/typesPrimitive"
 import { resolveTypeChecker } from "../resolveTypeChecker"
@@ -36,7 +36,7 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
     TypeCheckerBaseType.Object,
 
     (value, path, typeCheckedValue) => {
-      if (!(value instanceof Ref)) {
+      if (!(value instanceof refConstructor.refClass)) {
         return new TypeCheckError({
           path,
           expectedTypeName: typeName,

package/src/types/primitiveBased/typesEnum.ts

@@ -1,4 +1,4 @@
-import { assertIsObject } from "../../utils"
+import { assertIsObject, isEqualOrBothNaN } from "../../utils"
 import type { IdentityType } from "../schemas"
 import { typesOr } from "../utility/typesOr"
 import { typesLiteral } from "./typesPrimitive"
@@ -17,6 +17,7 @@ export interface EnumLike {
  */
 export function enumValues(e: EnumLike): (string | number)[] {
   const vals: (string | number)[] = []
+  const seen = new Set<string | number>()
   for (const k of Object.keys(e)) {
     const v = e[k]
     // we have to do this since TS does something weird
@@ -24,7 +25,8 @@ export function enumValues(e: EnumLike): (string | number)[] {
     // Hi = 0 -> { Hi: 0, 0: "Hi" }
     // and SWC currently generates enum code inconsistent with TS/Babel
     // https://github.com/swc-project/swc/issues/3711
-    if (!vals.includes(v) && ((typeof v !== "string" && v !== +k) || e[v] !== +k)) {
+    if (!seen.has(v) && ((typeof v !== "string" && v !== +k) || !isEqualOrBothNaN(e[v], +k))) {
+      seen.add(v)
       vals.push(v)
     }
   }