mobx-keystone 1.22.0 → 1.24.0

package/src/types/objectBased/typesRecord.ts

@@ -2,13 +2,14 @@ import { isObservableObject, keys } from "mobx"
 import type { Path } from "../../parent/pathTypes"
 import { failure, isObject } from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { createPerEntryCachedCheck, recordCachePruning } from "../createPerEntryCachedCheck"
+import { createAdaptiveRecordCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, RecordType } from "../schemas"
 import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
+  snapshotProcessorPlan,
   TypeChecker,
   TypeCheckerBaseType,
   TypeInfo,
@@ -30,16 +31,19 @@ import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
  * @returns
  */
 export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
-  const typeInfoGen: TypeInfoGen = (tc) => new RecordTypeInfo(tc, resolveStandardType(valueType))
-
-  return lateTypeChecker(() => {
-    const valueChecker = resolveTypeChecker(valueType)
+  const resolvedValueType = resolveStandardType(valueType)
+  const typeInfoGen: TypeInfoGen = (tc) => new RecordTypeInfo(tc, resolvedValueType)
+  const typeChecker = lateTypeChecker(() => {
+    const valueChecker = resolveTypeChecker(resolvedValueType)
     const emptyChildPath: Path = []
 
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
       `Record<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
 
-    const applySnapshotProcessor = (obj: Record<string, unknown>, mode: "from" | "to") => {
+    const applySnapshotProcessor = (
+      obj: Record<string, unknown>,
+      processor: (snapshot: any) => unknown
+    ) => {
       if (valueChecker.unchecked) {
         return obj
       }
@@ -49,37 +53,44 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       const keys = Object.keys(obj)
       for (let i = 0; i < keys.length; i++) {
         const k = keys[i]
-        const v = withErrorPathSegment(k, () =>
-          mode === "from"
-            ? valueChecker.fromSnapshotProcessor(obj[k])
-            : valueChecker.toSnapshotProcessor(obj[k])
-        )
+        const v = withErrorPathSegment(k, () => processor(obj[k]))
         newObj[k] = v
       }
 
       return newObj
     }
 
-    const checkRecordValues = createPerEntryCachedCheck(
-      (obj, checkEntry) => {
-        // Use keys() from MobX for observable objects to track key additions/removals
-        // in MobX 4 (which lacks Proxy). Object.keys() doesn't establish MobX tracking
-        // in MobX 4, so the aggregation computed would miss newly added keys.
-        const objKeys = isObservableObject(obj) ? keys(obj) : Object.keys(obj)
-        for (let i = 0; i < objKeys.length; i++) {
-          const error = checkEntry(objKeys[i])
-          if (error) return error
-        }
-        return null
-      },
-      (obj, key, path, typeCheckedValue) => {
-        if (typeof key !== "string") {
-          throw failure(`record type keys must be strings, got ${typeof key}`)
-        }
-        const error = valueChecker.check(obj[key], emptyChildPath, typeCheckedValue)
-        return error ? prependPathElementToTypeCheckError(error, path, key, typeCheckedValue) : null
-      },
-      recordCachePruning
+    const iterateRecordEntries = (
+      obj: Record<string, unknown>,
+      checkEntry: (key: PropertyKey) => TypeCheckError | null
+    ): TypeCheckError | null => {
+      // Use keys() from MobX for observable objects to track key additions/removals
+      // in MobX 4 (which lacks Proxy). Object.keys() doesn't establish MobX tracking
+      // in MobX 4, so the aggregation computed would miss newly added keys.
+      const objKeys = isObservableObject(obj) ? keys(obj) : Object.keys(obj)
+      for (let i = 0; i < objKeys.length; i++) {
+        const error = checkEntry(objKeys[i])
+        if (error) return error
+      }
+      return null
+    }
+
+    const checkRecordEntry = (
+      obj: Record<string, unknown>,
+      key: PropertyKey,
+      path: Path,
+      typeCheckedValue: any
+    ): TypeCheckError | null => {
+      if (typeof key !== "string") {
+        throw failure(`record type keys must be strings, got ${typeof key}`)
+      }
+      const error = valueChecker.check(obj[key], emptyChildPath, typeCheckedValue)
+      return error ? prependPathElementToTypeCheckError(error, path, key, typeCheckedValue) : null
+    }
+
+    const checkRecordValues = createAdaptiveRecordCachedCheck(
+      iterateRecordEntries,
+      checkRecordEntry
     )
 
     const thisTc: TypeChecker = new TypeChecker(
@@ -125,17 +136,26 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
         return thisTc
       },
 
-      (obj: Record<string, unknown>) => {
-        return applySnapshotProcessor(obj, "from")
-      },
-
-      (obj: Record<string, unknown>) => {
-        return applySnapshotProcessor(obj, "to")
-      }
+      snapshotProcessorPlan(
+        () => [valueChecker],
+        ([processor]) =>
+          processor
+            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processor)
+            : undefined
+      ),
+
+      snapshotProcessorPlan(
+        () => [valueChecker],
+        ([processor]) =>
+          processor
+            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processor)
+            : undefined
+      )
     )
 
     return thisTc
-  }, typeInfoGen) as any
+  }, typeInfoGen)
+  return typeChecker as any
 }
 
 /**

package/src/types/objectBased/typesRef.ts

@@ -75,7 +75,7 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
       }
     },
 
-    (sn) => sn
+    undefined
   )
 
   return thisTc as any

package/src/types/primitiveBased/typesPrimitive.ts

@@ -1,4 +1,4 @@
-import { assertIsPrimitive, identityFn } from "../../utils"
+import { assertIsPrimitive } from "../../utils"
 import type { PrimitiveValue } from "../../utils/types"
 import { registerStandardTypeResolver, type StandardTypeResolverFn } from "../resolveTypeChecker"
 import type { AnyStandardType, IdentityType } from "../schemas"
@@ -54,8 +54,8 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
     typeInfoGen,
 
     (value) => (value === literal ? thisTc : null),
-    identityFn,
-    identityFn
+    undefined,
+    undefined
   )
 
   return thisTc as any
@@ -122,8 +122,8 @@ export const typesBoolean: IdentityType<boolean> = new TypeChecker(
   (t) => new BooleanTypeInfo(t),
 
   (value) => (typeof value === "boolean" ? (typesBoolean as any) : null),
-  identityFn,
-  identityFn
+  undefined,
+  undefined
 ) as any
 
 standardTypeResolvers.push((v) => (v === Boolean ? typesBoolean : undefined))
@@ -159,8 +159,8 @@ export const typesNumber: IdentityType<number> = new TypeChecker(
   (t) => new NumberTypeInfo(t),
 
   (value) => (typeof value === "number" ? (typesNumber as any) : null),
-  identityFn,
-  identityFn
+  undefined,
+  undefined
 ) as any
 
 standardTypeResolvers.push((v) => (v === Number ? typesNumber : undefined))
@@ -196,8 +196,8 @@ export const typesString: IdentityType<string> = new TypeChecker(
   (t) => new StringTypeInfo(t),
 
   (value) => (typeof value === "string" ? (typesString as any) : null),
-  identityFn,
-  identityFn
+  undefined,
+  undefined
 ) as any
 
 standardTypeResolvers.push((v) => (v === String ? typesString : undefined))

package/src/types/tProp.ts

@@ -3,6 +3,7 @@ import {
   type MaybeOptionalModelProp,
   type OptionalModelProp,
   prop,
+  toFullModelPropTransform,
 } from "../modelShared/prop"
 import { lazy } from "../utils"
 import {
@@ -14,6 +15,7 @@ import {
 } from "./primitiveBased/typesPrimitive"
 import { resolveStandardType, resolveTypeChecker } from "./resolveTypeChecker"
 import type { AnyStandardType, AnyType, TypeToData, TypeToSnapshotIn } from "./schemas"
+import { type SnapshotProcessor, TypeChecker } from "./TypeChecker"
 import { createCodecPropTransform, resolveCodecSupport } from "./utility/typesCodec"
 import { typesOr } from "./utility/typesOr"
 import type { TypeToStoredData } from "./utility/typeToStoredData"
@@ -22,6 +24,28 @@ const noDefaultValueSymbol = Symbol("noDefaultValue")
 
 const tPropCache = new WeakMap<AnyStandardType, Map<unknown, AnyModelProp>>()
 
+function createFromSnapshotProcessorGetter(
+  getType: () => AnyStandardType,
+  eagerType: AnyStandardType | undefined
+): (() => SnapshotProcessor | undefined) | undefined {
+  if (eagerType instanceof TypeChecker) {
+    const processor = eagerType.getFromSnapshotProcessor()
+    return processor ? () => processor : undefined
+  }
+  return lazy(() => resolveTypeChecker(getType()).getFromSnapshotProcessor())
+}
+
+function createToSnapshotProcessorGetter(
+  getType: () => AnyStandardType,
+  eagerType: AnyStandardType | undefined
+): (() => SnapshotProcessor | undefined) | undefined {
+  if (eagerType instanceof TypeChecker) {
+    const processor = eagerType.getToSnapshotProcessor()
+    return processor ? () => processor : undefined
+  }
+  return lazy(() => resolveTypeChecker(getType()).getToSnapshotProcessor())
+}
+
 type AnyTypeOrArray = AnyType | ReadonlyArray<AnyType>
 
 type StoredRequiredPropMetadata<TType extends AnyType> = {
@@ -40,26 +64,6 @@ type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToDat
   $typedFromSnapshotOverride: TypeToSnapshotIn<TType> | null | undefined
 }
 
-function getOrCreateTProp(
-  type: AnyStandardType,
-  defKey: unknown,
-  createTProp: () => AnyModelProp
-): AnyModelProp {
-  let defValueCache = tPropCache.get(type)
-  if (!defValueCache) {
-    defValueCache = new Map()
-    tPropCache.set(type, defValueCache)
-  }
-
-  let prop = defValueCache.get(defKey)
-  if (!prop) {
-    prop = createTProp()
-    defValueCache.set(defKey, prop)
-  }
-
-  return prop
-}
-
 /**
  * Defines a string model property with a default value.
  * Equivalent to `tProp(types.string, defaultValue)`.
@@ -244,34 +248,66 @@ export function tProp(
     : (typeOrArray as AnyType)
 
   const typeChecker = resolveStandardType(resolvedType)
-  const codecSupport = resolveCodecSupport(typeChecker)
+  const defKey = hasDefaultValue ? def : noDefaultValueSymbol
 
-  return getOrCreateTProp(typeChecker, hasDefaultValue ? def : noDefaultValueSymbol, () => {
-    const fromSnapshotTypeChecker = hasDefaultValue
-      ? typesOr(codecSupport.storedType, typesUndefined, typesNull)
-      : codecSupport.storedType
-    const getFromSnapshotProcessor = lazy(
-      () => resolveTypeChecker(fromSnapshotTypeChecker).fromSnapshotProcessor
-    )
-    const getToSnapshotProcessor = lazy(
-      () => resolveTypeChecker(codecSupport.storedType).toSnapshotProcessor
-    )
+  let defValueCache = tPropCache.get(typeChecker)
+  if (!defValueCache) {
+    defValueCache = new Map()
+    tPropCache.set(typeChecker, defValueCache)
+  }
 
-    // we use Object.create to avoid messing up with the prop cache
-    const baseProp = hasDefaultValue ? prop(def) : prop()
-    const newProp = codecSupport.hasCodec
-      ? baseProp.withTransform(createCodecPropTransform(typeChecker))
-      : Object.create(baseProp)
+  const cachedProp = defValueCache.get(defKey)
+  if (cachedProp) {
+    return cachedProp
+  }
 
-    Object.assign(newProp, {
-      _defaultValueIsTransformed: codecSupport.hasCodec,
-      _typeChecker: typeChecker,
+  const eagerCodecSupport =
+    typeChecker instanceof TypeChecker ? resolveCodecSupport(typeChecker) : undefined
+  const getCodecSupport = eagerCodecSupport
+    ? () => eagerCodecSupport
+    : lazy(() => resolveCodecSupport(typeChecker))
+  const eagerStoredType = eagerCodecSupport?.storedType
+  const getStoredType = eagerStoredType
+    ? () => eagerStoredType
+    : lazy(() => getCodecSupport().storedType)
+  const eagerFromSnapshotType = eagerStoredType
+    ? hasDefaultValue
+      ? typesOr(eagerStoredType, typesUndefined, typesNull)
+      : eagerStoredType
+    : undefined
+  const getFromSnapshotType = eagerFromSnapshotType
+    ? () => eagerFromSnapshotType
+    : lazy(() => {
+        const storedType = getStoredType()
+        return hasDefaultValue ? typesOr(storedType, typesUndefined, typesNull) : storedType
+      })
 
-      _fromSnapshotProcessor: (sn) => getFromSnapshotProcessor()(sn),
+  // we use Object.create to avoid messing up with the prop cache
+  const baseProp = hasDefaultValue ? prop(def) : prop()
+  const newProp = eagerCodecSupport?.hasCodec
+    ? baseProp.withTransform(createCodecPropTransform(typeChecker))
+    : Object.create(baseProp)
 
-      _toSnapshotProcessor: (sn) => getToSnapshotProcessor()(sn),
-    } satisfies Partial<AnyModelProp>)
+  Object.assign(newProp, {
+    _defaultValueIsTransformed: eagerCodecSupport?.hasCodec ?? false,
+    _getDefaultValueIsTransformed: eagerCodecSupport
+      ? undefined
+      : lazy(() => getCodecSupport().hasCodec),
+    _typeChecker: typeChecker,
+    _getTransform: eagerCodecSupport
+      ? undefined
+      : lazy(() =>
+          getCodecSupport().hasCodec
+            ? toFullModelPropTransform(createCodecPropTransform(typeChecker))
+            : undefined
+        ),
+    _getFromSnapshotProcessor: createFromSnapshotProcessorGetter(
+      getFromSnapshotType,
+      eagerFromSnapshotType
+    ),
+    _getToSnapshotProcessor: createToSnapshotProcessorGetter(getStoredType, eagerStoredType),
+  } satisfies Partial<AnyModelProp>)
 
-    return newProp
-  })
+  defValueCache.set(defKey, newProp)
+  return newProp
 }

package/src/types/utility/typesOr.ts

@@ -11,6 +11,7 @@ import { TypeCheckError } from "../TypeCheckError"
 import {
   getTypeCheckerBaseTypeFromValue,
   lateTypeChecker,
+  snapshotProcessorPlan,
   TypeChecker,
   TypeCheckerBaseType,
   TypeInfo,
@@ -74,11 +75,11 @@ export function typesOr(
   const originalDispatcher = firstTypeChecker
     ? undefined
     : (dispatcherOrType as (sn: any) => AnyType)
-  const typeInfoGen: TypeInfoGen = (t) =>
-    new OrTypeInfo(t, orTypes.map(resolveStandardType), originalDispatcher)
+  const resolvedOrTypes = orTypes.map(resolveStandardType)
+  const typeInfoGen: TypeInfoGen = (t) => new OrTypeInfo(t, resolvedOrTypes, originalDispatcher)
 
   return lateTypeChecker(() => {
-    const checkers = orTypes.map(resolveTypeChecker)
+    const checkers = resolvedOrTypes.map(resolveTypeChecker)
 
     // if the or includes unchecked then it is unchecked
     if (checkers.some((tc) => tc.unchecked)) {
@@ -207,29 +208,39 @@ export function typesOr(
         return null
       },
 
-      (sn) => {
-        const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn)
-        if (!type) {
-          throw new SnapshotTypeMismatchError({
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: sn,
-          })
-        }
-
-        return type.fromSnapshotProcessor(sn)
-      },
+      snapshotProcessorPlan(
+        () => checkers,
+        () => (sn) => {
+          const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn)
+          if (!type) {
+            throw new SnapshotTypeMismatchError({
+              expectedTypeName: getTypeName(thisTc),
+              actualValue: sn,
+            })
+          }
 
-      (sn) => {
-        const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn)
-        if (!type) {
-          throw new SnapshotTypeMismatchError({
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: sn,
-          })
-        }
+          const processor = type.getFromSnapshotProcessor()
+          return processor ? processor(sn) : sn
+        },
+        true
+      ),
+
+      snapshotProcessorPlan(
+        () => checkers,
+        () => (sn) => {
+          const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn)
+          if (!type) {
+            throw new SnapshotTypeMismatchError({
+              expectedTypeName: getTypeName(thisTc),
+              actualValue: sn,
+            })
+          }
 
-        return type.toSnapshotProcessor(sn)
-      }
+          const processor = type.getToSnapshotProcessor()
+          return processor ? processor(sn) : sn
+        },
+        true
+      )
     )
 
     return thisTc

package/src/types/utility/typesRefinement.ts

@@ -2,7 +2,13 @@ import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, TypeToData } from "../schemas"
 import { TypeCheckError } from "../TypeCheckError"
-import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+import {
+  lateTypeChecker,
+  snapshotProcessorPlan,
+  TypeChecker,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
 
 /**
  * A refinement over a given type. This allows you to do extra checks
@@ -44,11 +50,11 @@ export function typesRefinement<T extends AnyType>(
   checkFn: (data: TypeToData<T>) => TypeCheckError | null | boolean,
   typeName?: string
 ): T {
+  const resolvedBaseType = resolveStandardType(baseType)
   const typeInfoGen: TypeInfoGen = (t) =>
-    new RefinementTypeInfo(t, resolveStandardType(baseType), checkFn, typeName)
-
-  return lateTypeChecker(() => {
-    const baseChecker = resolveTypeChecker(baseType)
+    new RefinementTypeInfo(t, resolvedBaseType, checkFn, typeName)
+  const typeChecker = lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(resolvedBaseType)
 
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
       const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
@@ -96,12 +102,19 @@ export function typesRefinement<T extends AnyType>(
       // we cannot check refinement here since it checks data instances, not snapshots
       (sn) => baseChecker.snapshotType(sn),
 
-      (sn) => baseChecker.fromSnapshotProcessor(sn),
-      (sn) => baseChecker.toSnapshotProcessor(sn)
+      snapshotProcessorPlan(
+        () => [baseChecker],
+        ([processor]) => processor
+      ),
+      snapshotProcessorPlan(
+        () => [baseChecker],
+        ([processor]) => processor
+      )
     )
 
     return thisTc
-  }, typeInfoGen) as any
+  }, typeInfoGen)
+  return typeChecker as any
 }
 
 /**

package/src/types/utility/typesSkipCheck.ts

@@ -1,7 +1,13 @@
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType } from "../schemas"
-import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+import {
+  lateTypeChecker,
+  snapshotProcessorPlan,
+  TypeChecker,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
 
 /**
  * A type that wraps another type but skips runtime validation.
@@ -26,10 +32,10 @@ import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../Typ
  * @returns A type with the same runtime/snapshot behavior but no validation.
  */
 export function typesSkipCheck<T extends AnyType>(baseType: T): T {
-  const typeInfoGen: TypeInfoGen = (t) => new SkipCheckTypeInfo(t, resolveStandardType(baseType))
-
-  return lateTypeChecker(() => {
-    const baseChecker = resolveTypeChecker(baseType)
+  const resolvedBaseType = resolveStandardType(baseType)
+  const typeInfoGen: TypeInfoGen = (t) => new SkipCheckTypeInfo(t, resolvedBaseType)
+  const typeChecker = lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(resolvedBaseType)
 
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
       const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
@@ -42,13 +48,20 @@ export function typesSkipCheck<T extends AnyType>(baseType: T): T {
       getTypeName,
       typeInfoGen,
       (sn) => baseChecker.snapshotType(sn),
-      (sn) => baseChecker.fromSnapshotProcessor(sn),
-      (sn) => baseChecker.toSnapshotProcessor(sn)
+      snapshotProcessorPlan(
+        () => [baseChecker],
+        ([processor]) => processor
+      ),
+      snapshotProcessorPlan(
+        () => [baseChecker],
+        ([processor]) => processor
+      )
     )
     thisTc.skipCheck = true
 
     return thisTc
-  }, typeInfoGen) as any
+  }, typeInfoGen)
+  return typeChecker as any
 }
 
 /**

package/src/types/utility/typesTag.ts

@@ -1,7 +1,13 @@
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType } from "../schemas"
-import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+import {
+  lateTypeChecker,
+  snapshotProcessorPlan,
+  TypeChecker,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
 
 /**
  * Wrap a given type with tag information.
@@ -35,11 +41,10 @@ import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../Typ
  * @returns
  */
 export function typesTag<T extends AnyType, A>(baseType: T, tag: A, typeName?: string): T {
-  const typeInfoGen: TypeInfoGen = (t) =>
-    new TagTypeInfo(t, resolveStandardType(baseType), tag, typeName)
-
-  return lateTypeChecker(() => {
-    const baseChecker = resolveTypeChecker(baseType)
+  const resolvedBaseType = resolveStandardType(baseType)
+  const typeInfoGen: TypeInfoGen = (t) => new TagTypeInfo(t, resolvedBaseType, tag, typeName)
+  const typeChecker = lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(resolvedBaseType)
 
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
       const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
@@ -53,12 +58,19 @@ export function typesTag<T extends AnyType, A>(baseType: T, tag: A, typeName?: s
       getTypeName,
       typeInfoGen,
       (sn) => baseChecker.snapshotType(sn),
-      (sn) => baseChecker.fromSnapshotProcessor(sn),
-      (sn) => baseChecker.toSnapshotProcessor(sn)
+      snapshotProcessorPlan(
+        () => [baseChecker],
+        ([processor]) => processor
+      ),
+      snapshotProcessorPlan(
+        () => [baseChecker],
+        ([processor]) => processor
+      )
     )
 
     return thisTc
-  }, typeInfoGen) as any
+  }, typeInfoGen)
+  return typeChecker as any
 }
 
 /**

package/src/types/utility/typesUnchecked.ts

@@ -1,4 +1,3 @@
-import { identityFn } from "../../utils"
 import type { IdentityType } from "../schemas"
 import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker"
 
@@ -10,8 +9,8 @@ const unchecked: IdentityType<any> = new TypeChecker(
 
   () => unchecked as any,
 
-  identityFn,
-  identityFn
+  undefined,
+  undefined
 ) as any
 
 /**