mobx-keystone 2.1.0 → 2.2.0

package/src/types/arrayBased/typesTuple.ts

@@ -68,6 +68,19 @@ export function typesTuple<T extends AnyType[]>(...itemTypes: T): ArrayType<T> {
     // computeds cannot isolate tuple-item changes and only add allocation overhead.
     const checkTupleItems = createWholeContainerCachedCheck(checkTupleItemsImperatively)
 
+    const processorPlan = snapshotProcessorPlan(
+      () => checkers,
+      (processors) =>
+        processors.some(Boolean)
+          ? (array: unknown[]) => {
+              return array.map((item, i) => {
+                const processor = processors[i]
+                return processor ? withErrorPathSegment(i, () => processor(item)) : item
+              })
+            }
+          : undefined
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Array,
 
@@ -102,31 +115,9 @@ export function typesTuple<T extends AnyType[]>(...itemTypes: T): ArrayType<T> {
         return thisTc
       },
 
-      snapshotProcessorPlan(
-        () => checkers,
-        (processors) =>
-          processors.some(Boolean)
-            ? (array: unknown[]) => {
-                return array.map((item, i) => {
-                  const processor = processors[i]
-                  return processor ? withErrorPathSegment(i, () => processor(item)) : item
-                })
-              }
-            : undefined
-      ),
-
-      snapshotProcessorPlan(
-        () => checkers,
-        (processors) =>
-          processors.some(Boolean)
-            ? (array: unknown[]) => {
-                return array.map((item, i) => {
-                  const processor = processors[i]
-                  return processor ? withErrorPathSegment(i, () => processor(item)) : item
-                })
-              }
-            : undefined
-      )
+      processorPlan,
+
+      processorPlan
     )
 
     return thisTc

package/src/types/createCachedTypeCheck.ts

@@ -19,6 +19,7 @@ import {
 } from "../tweaker/tweakedChangeListeners"
 import { getMobxVersion } from "../utils"
 import { ChunkedSequence, ChunkedSet, chunkSize, type SequenceChunk } from "../utils/chunks"
+import { getOrCreate } from "../utils/mapUtils"
 import { TypeCheckError } from "./TypeCheckError"
 
 /**
@@ -79,11 +80,7 @@ function checkUncached(
   typeCheckedValue: any,
   check: () => TypeCheckError | null
 ): TypeCheckError | null {
-  let results = uncachedResults!.get(checker)
-  if (!results) {
-    results = new Map()
-    uncachedResults!.set(checker, results)
-  }
+  const results = getOrCreate(uncachedResults!, checker, () => new Map())
   let error = results.get(value)
   if (error === undefined) {
     error = check()
@@ -152,11 +149,9 @@ export function createWholeContainerCachedCheck(
       )
     }
 
-    let cached = cache.get(value)
-    if (!cached) {
-      cached = computed(() => check(value, emptyPath, undefined), { keepAlive: true })
-      cache.set(value, cached)
-    }
+    const cached = getOrCreate(cache, value, () =>
+      computed(() => check(value, emptyPath, undefined), { keepAlive: true })
+    )
     const error = cached.get()
     return contextualizeCachedError(error, path, typeCheckedValue)
   }
@@ -167,6 +162,10 @@ export function createWholeContainerCachedCheck(
 // check new chunks twice.
 const needsBatchToCacheChunks = getMobxVersion() < 6
 
+function checkChunks<T>(fn: () => T): T {
+  return needsBatchToCacheChunks ? transaction(fn) : fn()
+}
+
 /**
  * Checks the items of an array, starting at `firstIndex`, and returns the first
  * error, or null.
@@ -328,14 +327,8 @@ class RecordChunks
   readonly atom = createAtom("recordTypeCheckChunks")
   private readonly record: object
   private readonly checkKey: (key: string) => TypeCheckError | null
-  private readonly getEntry = (key: string): CachedEntry => {
-    let entry = this.entries.get(key)
-    if (!entry) {
-      entry = computed(() => this.checkKey(key))
-      this.entries.set(key, entry)
-    }
-    return entry
-  }
+  private readonly getEntry = (key: string): CachedEntry =>
+    getOrCreate(this.entries, key, () => computed(() => this.checkKey(key)))
 
   constructor(record: object, checkKey: (key: string) => TypeCheckError | null) {
     super()
@@ -458,10 +451,7 @@ export function createChunkedRecordCachedCheck(
       const chunks = cached?.chunks
       return checkUncached(cache, value, path, typeCheckedValue, () => {
         if (chunks && typeof key === "string") {
-          const hasError = needsBatchToCacheChunks
-            ? transaction(() => chunks.hasError(key))
-            : chunks.hasError(key)
-          if (!hasError) {
+          if (!checkChunks(() => chunks.hasError(key))) {
             return null
           }
         }
@@ -475,11 +465,10 @@ export function createChunkedRecordCachedCheck(
       addTweakedChangeListener<object>(value, chunks)
       const check = computed(
         () => {
-          const hasError = needsBatchToCacheChunks
-            ? transaction(() => chunks.hasError())
-            : chunks.hasError()
           // any added or removed key changes a chunk, so this runs again then
-          return hasError ? checkAllEntries(value, emptyPath, undefined) : null
+          return checkChunks(() => chunks.hasError())
+            ? checkAllEntries(value, emptyPath, undefined)
+            : null
         },
         { keepAlive: true }
       )
@@ -535,9 +524,7 @@ export function createChunkedArrayCachedCheck(
         if (!chunks || typeof index !== "number") {
           return checkItems(array, 0, emptyPath, undefined)
         }
-        return needsBatchToCacheChunks
-          ? transaction(() => chunks.check(index))
-          : chunks.check(index)
+        return checkChunks(() => chunks.check(index))
       })
     }
 
@@ -561,7 +548,7 @@ export function createChunkedArrayCachedCheck(
             }
 
             const chunks = state.chunks
-            return needsBatchToCacheChunks ? transaction(() => chunks.check()) : chunks.check()
+            return checkChunks(() => chunks.check())
           },
           { keepAlive: true }
         ),

package/src/types/index.ts

@@ -4,3 +4,4 @@ export * from "./TypeCheckError"
 export * from "./tProp"
 export { typeCheck } from "./typeCheck"
 export * from "./types"
+export type { CodecFromEncoded } from "./utility/typesCodecCore"

package/src/types/objectBased/typesDataModelData.ts

@@ -90,6 +90,11 @@ export function typesDataModelData<M = never, K = M>(
 
       const resolvedDataTypeChecker = resolveTypeChecker(standardDataType)
 
+      const processorPlan = snapshotProcessorPlan(
+        () => [resolvedDataTypeChecker],
+        ([processor]) => processor
+      )
+
       const thisTc: TypeChecker = new TypeChecker(
         TypeCheckerBaseType.Object,
 
@@ -104,15 +109,9 @@ export function typesDataModelData<M = never, K = M>(
           return resolvedDataTypeChecker.snapshotType(value) ? thisTc : null
         },
 
-        snapshotProcessorPlan(
-          () => [resolvedDataTypeChecker],
-          ([processor]) => processor
-        ),
+        processorPlan,
 
-        snapshotProcessorPlan(
-          () => [resolvedDataTypeChecker],
-          ([processor]) => processor
-        )
+        processorPlan
       )
 
       return thisTc

package/src/types/objectBased/typesObject.ts

@@ -173,6 +173,14 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       }
     )
 
+    const processorPlan = snapshotProcessorPlan(
+      () => schemaEntries.map((entry) => entry.getResolvedChecker()),
+      (processors) =>
+        processors.some(Boolean)
+          ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processors)
+          : undefined
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Object,
 
@@ -208,21 +216,9 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
         return thisTc
       },
 
-      snapshotProcessorPlan(
-        () => schemaEntries.map((entry) => entry.getResolvedChecker()),
-        (processors) =>
-          processors.some(Boolean)
-            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processors)
-            : undefined
-      ),
-
-      snapshotProcessorPlan(
-        () => schemaEntries.map((entry) => entry.getResolvedChecker()),
-        (processors) =>
-          processors.some(Boolean)
-            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processors)
-            : undefined
-      )
+      processorPlan,
+
+      processorPlan
     )
 
     return thisTc

package/src/types/objectBased/typesRecord.ts

@@ -83,6 +83,14 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
 
     const checkRecordValues = createChunkedRecordCachedCheck(iterateRecordEntries, checkRecordEntry)
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [valueChecker],
+      ([processor]) =>
+        processor
+          ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processor)
+          : undefined
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Object,
 
@@ -126,21 +134,9 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
         return thisTc
       },
 
-      snapshotProcessorPlan(
-        () => [valueChecker],
-        ([processor]) =>
-          processor
-            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processor)
-            : undefined
-      ),
-
-      snapshotProcessorPlan(
-        () => [valueChecker],
-        ([processor]) =>
-          processor
-            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processor)
-            : undefined
-      )
+      processorPlan,
+
+      processorPlan
     )
 
     return thisTc

package/src/types/schemas.ts

@@ -1,14 +1,11 @@
-import type { O } from "ts-toolbelt"
 import type { AnyDataModel } from "../dataModel/BaseDataModel"
 import type { AnyModel } from "../model/BaseModel"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import type { SnapshotInOf, SnapshotOutOf } from "../snapshot/SnapshotOf"
-import type { IsOptionalValue } from "../utils/types"
+import type { IsOptionalValue, SimplifyObject } from "../utils/types"
 
 // type schemas
 
-// infer is there just to cache type generation
-
 export interface Type<Name, Data> {
   /** @ignore */
   $$type: Name
@@ -38,21 +35,21 @@ export interface CodecType<
 }
 
 type ArrayData<S extends readonly unknown[]> = number extends S["length"]
-  ? Array<TypeToData<S[number]> extends infer R ? R : never>
+  ? Array<TypeToData<S[number]>>
   : {
-      [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never
+      [k in keyof S]: TypeToData<S[k]>
     }
 
 type ArraySnapshotInData<S extends readonly unknown[]> = number extends S["length"]
-  ? Array<TypeToSnapshotIn<S[number]> extends infer R ? R : never>
+  ? Array<TypeToSnapshotIn<S[number]>>
   : {
-      [k in keyof S]: TypeToSnapshotIn<S[k]> extends infer R ? R : never
+      [k in keyof S]: TypeToSnapshotIn<S[k]>
     }
 
 type ArraySnapshotOutData<S extends readonly unknown[]> = number extends S["length"]
-  ? Array<TypeToSnapshotOut<S[number]> extends infer R ? R : never>
+  ? Array<TypeToSnapshotOut<S[number]>>
   : {
-      [k in keyof S]: TypeToSnapshotOut<S[k]> extends infer R ? R : never
+      [k in keyof S]: TypeToSnapshotOut<S[k]>
     }
 
 export interface ArrayType<S extends readonly unknown[]> extends Type<"array", ArrayData<S>> {}
@@ -74,37 +71,28 @@ export type UndefinablePropsNames<T> = {
  * Computes the optional keys for an object type schema.
  * @ignore
  */
-export type ObjectOptionalKeys<S> = UndefinablePropsNames<{
-  [k in keyof S]: TypeToDataOpt<S[k]> extends infer R ? R : never
-}>
-
-type ObjectData<S> = O.Optional<
-  { [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never },
-  ObjectOptionalKeys<S>
+export type ObjectOptionalKeys<S> = {
+  [K in keyof S]: IsOptionalValue<TypeToDataOpt<S[K]>, K, never>
+}[keyof S]
+
+type ObjectData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<
+  { [k in keyof S as k extends OK ? never : k]: TypeToData<S[k]> } & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToData<S[k]>
+  }
 >
 
-type ObjectSnapshotInData<S> = O.Optional<
-  { [k in keyof S]: TypeToSnapshotIn<S[k]> extends infer R ? R : never },
-  ObjectOptionalKeys<S>
+type ObjectSnapshotInData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<
+  { [k in keyof S as k extends OK ? never : k]: TypeToSnapshotIn<S[k]> } & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToSnapshotIn<S[k]>
+  }
 >
 
-type ObjectSnapshotOutData<S> = O.Optional<
-  { [k in keyof S]: TypeToSnapshotOut<S[k]> extends infer R ? R : never },
-  ObjectOptionalKeys<S>
+type ObjectSnapshotOutData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<
+  { [k in keyof S as k extends OK ? never : k]: TypeToSnapshotOut<S[k]> } & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToSnapshotOut<S[k]>
+  }
 >
 
-type RecordData<S> = {
-  [k: string]: TypeToData<S> extends infer R ? R : never
-}
-
-type RecordSnapshotInData<S> = {
-  [k: string]: TypeToSnapshotIn<S> extends infer D ? D : never
-}
-
-type RecordSnapshotOutData<S> = {
-  [k: string]: TypeToSnapshotOut<S> extends infer D ? D : never
-}
-
 export interface ObjectType<S> extends Type<"object", ObjectData<S>> {}
 
 export interface ObjectTypeFunction {
@@ -112,7 +100,9 @@ export interface ObjectTypeFunction {
   (): ObjectOfTypes
 }
 
-export interface RecordType<S> extends Type<"record", RecordData<S>> {}
+// the record data types are written inline (instead of through an alias) so they are displayed as
+// plain index signatures (e.g. `{ [k: string]: number }`)
+export interface RecordType<S> extends Type<"record", { [k: string]: TypeToData<S> }> {}
 
 export type AnyStandardType =
   | IdentityType<any>
@@ -162,47 +152,45 @@ type TypeToSnapshotLeaf<S, Dir extends "in" | "out"> =
     ? Dir extends "in"
       ? SnapshotInOf<M>
       : SnapshotOutOf<M>
-    : S extends { $$data: infer D }
-      ? D
-      : ConstructorToSnapshotData<S>
+    : ConstructorToSnapshotData<S>
 
 export type TypeToData<S> = S extends ObjectTypeFunction
-  ? ObjectType<ReturnType<S>>["$$data"] extends infer R
-    ? R
-    : never
+  ? ObjectType<ReturnType<S>>["$$data"]
   : TypeToDataLeaf<S>
 
+// standard types are dispatched through their `$$type` discriminant (and codec / identity types
+// through indexed accesses), which is cheaper than checking them against each type interface
 export type TypeToSnapshotIn<S> = S extends ObjectTypeFunction
-  ? ObjectSnapshotInData<ReturnType<S>> extends infer R
-    ? R
-    : never
-  : S extends CodecType<any, infer D, any>
-    ? D
-    : S extends ArrayType<infer A>
-      ? ArraySnapshotInData<A>
-      : S extends ObjectType<infer O>
-        ? ObjectSnapshotInData<O>
-        : S extends RecordType<infer R>
-          ? RecordSnapshotInData<R>
-          : S extends ModelType<infer M>
-            ? SnapshotInOf<M>
-            : TypeToSnapshotLeaf<S, "in">
+  ? ObjectSnapshotInData<ReturnType<S>>
+  : S extends { $$type: infer K }
+    ? K extends "codec"
+      ? S["$$snapshotIn" & keyof S]
+      : S extends ArrayType<infer A>
+        ? ArraySnapshotInData<A>
+        : S extends ObjectType<infer O>
+          ? ObjectSnapshotInData<O>
+          : S extends RecordType<infer R>
+            ? { [k: string]: TypeToSnapshotIn<R> }
+            : S extends ModelType<infer M>
+              ? SnapshotInOf<M>
+              : S["$$data" & keyof S]
+    : TypeToSnapshotLeaf<S, "in">
 
 export type TypeToSnapshotOut<S> = S extends ObjectTypeFunction
-  ? ObjectSnapshotOutData<ReturnType<S>> extends infer R
-    ? R
-    : never
-  : S extends CodecType<any, any, infer D>
-    ? D
-    : S extends ArrayType<infer A>
-      ? ArraySnapshotOutData<A>
-      : S extends ObjectType<infer O>
-        ? ObjectSnapshotOutData<O>
-        : S extends RecordType<infer R>
-          ? RecordSnapshotOutData<R>
-          : S extends ModelType<infer M>
-            ? SnapshotOutOf<M>
-            : TypeToSnapshotLeaf<S, "out">
+  ? ObjectSnapshotOutData<ReturnType<S>>
+  : S extends { $$type: infer K }
+    ? K extends "codec"
+      ? S["$$snapshotOut" & keyof S]
+      : S extends ArrayType<infer A>
+        ? ArraySnapshotOutData<A>
+        : S extends ObjectType<infer O>
+          ? ObjectSnapshotOutData<O>
+          : S extends RecordType<infer R>
+            ? { [k: string]: TypeToSnapshotOut<R> }
+            : S extends ModelType<infer M>
+              ? SnapshotOutOf<M>
+              : S["$$data" & keyof S]
+    : TypeToSnapshotLeaf<S, "out">
 
 /** @ignore */
-export type TypeToDataOpt<S> = S extends { $$data: infer D } ? D & undefined : never
+export type TypeToDataOpt<S> = S extends { $$data: unknown } ? S["$$data"] & undefined : never

package/src/types/tProp.ts

@@ -6,6 +6,7 @@ import {
   toFullModelPropTransform,
 } from "../modelShared/prop"
 import { lazy } from "../utils"
+import { getOrCreate } from "../utils/mapUtils"
 import {
   typesBoolean,
   typesNull,
@@ -24,26 +25,16 @@ const noDefaultValueSymbol = Symbol("noDefaultValue")
 
 const tPropCache = new WeakMap<AnyStandardType, Map<unknown, AnyModelProp>>()
 
-function createFromSnapshotProcessorGetter(
+function createSnapshotProcessorGetter(
   getType: () => AnyStandardType,
-  eagerType: AnyStandardType | undefined
+  eagerType: AnyStandardType | undefined,
+  getProcessor: (typeChecker: TypeChecker) => SnapshotProcessor | undefined
 ): (() => SnapshotProcessor | undefined) | undefined {
   if (eagerType instanceof TypeChecker) {
-    const processor = eagerType.getFromSnapshotProcessor()
+    const processor = getProcessor(eagerType)
     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())
+  return lazy(() => getProcessor(resolveTypeChecker(getType())))
 }
 
 type AnyTypeOrArray = AnyType | ReadonlyArray<AnyType>
@@ -53,12 +44,22 @@ type StoredRequiredPropMetadata<TType extends AnyType> = {
   $storedCreationValueType: TypeToStoredData<TType>
 }
 
-type TypedMaybeOptionalModelProp<TType extends AnyType> = MaybeOptionalModelProp<
+// exported (and publicly re-exported) so emitted declaration files can reference it by name
+// instead of expanding it inline in every exported model class, which is much slower and larger
+/**
+ * A model property created by `tProp` without a default value.
+ */
+export type TypedMaybeOptionalModelProp<TType extends AnyType> = MaybeOptionalModelProp<
   TypeToData<TType>
 > &
   StoredRequiredPropMetadata<TType>
 
-type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToData<TType>> & {
+// exported (and publicly re-exported) so emitted declaration files can reference it by name
+// instead of expanding it inline in every exported model class, which is much slower and larger
+/**
+ * A model property created by `tProp` with a default value.
+ */
+export type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToData<TType>> & {
   $storedValueType: TypeToStoredData<TType>
   $storedCreationValueType: TypeToStoredData<TType> | null | undefined
   $typedFromSnapshotOverride: TypeToSnapshotIn<TType> | null | undefined
@@ -124,7 +125,7 @@ export function tProp(defaultValue: boolean): TypedOptionalModelProp<typeof type
  */
 export function tProp<TType extends AnyType>(
   type: TType,
-  defaultFn: () => TypeToData<TType>
+  defaultFn: () => NoInfer<TypeToData<TType>>
 ): TypedOptionalModelProp<TType>
 
 /**
@@ -145,7 +146,7 @@ export function tProp<TType extends AnyType>(
  */
 export function tProp<TType extends ReadonlyArray<AnyType>>(
   type: TType,
-  defaultFn: () => TypeToData<TType[number]>
+  defaultFn: () => NoInfer<TypeToData<TType[number]>>
 ): TypedOptionalModelProp<TType[number]>
 
 /**
@@ -167,7 +168,7 @@ export function tProp<TType extends ReadonlyArray<AnyType>>(
  */
 export function tProp<TType extends AnyType>(
   type: TType,
-  defaultValue: TypeToData<TType>
+  defaultValue: NoInfer<TypeToData<TType>>
 ): TypedOptionalModelProp<TType>
 
 /**
@@ -188,7 +189,7 @@ export function tProp<TType extends AnyType>(
  */
 export function tProp<TType extends ReadonlyArray<AnyType>>(
   type: TType,
-  defaultValue: TypeToData<TType[number]>
+  defaultValue: NoInfer<TypeToData<TType[number]>>
 ): TypedOptionalModelProp<TType[number]>
 
 /**
@@ -250,11 +251,7 @@ export function tProp(
   const typeChecker = resolveStandardType(resolvedType)
   const defKey = hasDefaultValue ? def : noDefaultValueSymbol
 
-  let defValueCache = tPropCache.get(typeChecker)
-  if (!defValueCache) {
-    defValueCache = new Map()
-    tPropCache.set(typeChecker, defValueCache)
-  }
+  const defValueCache = getOrCreate(tPropCache, typeChecker, () => new Map())
 
   const cachedProp = defValueCache.get(defKey)
   if (cachedProp) {
@@ -301,11 +298,14 @@ export function tProp(
             ? toFullModelPropTransform(createCodecPropTransform(typeChecker))
             : undefined
         ),
-    _getFromSnapshotProcessor: createFromSnapshotProcessorGetter(
+    _getFromSnapshotProcessor: createSnapshotProcessorGetter(
       getFromSnapshotType,
-      eagerFromSnapshotType
+      eagerFromSnapshotType,
+      (tc) => tc.getFromSnapshotProcessor()
+    ),
+    _getToSnapshotProcessor: createSnapshotProcessorGetter(getStoredType, eagerStoredType, (tc) =>
+      tc.getToSnapshotProcessor()
     ),
-    _getToSnapshotProcessor: createToSnapshotProcessorGetter(getStoredType, eagerStoredType),
   } satisfies Partial<AnyModelProp>)
 
   defValueCache.set(defKey, newProp)

package/src/types/utility/typeToStoredData.ts

@@ -1,7 +1,6 @@
-import type { O } from "ts-toolbelt"
+import type { SimplifyObject } from "../../utils/types"
 import type {
   ArrayType,
-  CodecType,
   ObjectOptionalKeys,
   ObjectType,
   ObjectTypeFunction,
@@ -10,28 +9,30 @@ import type {
 } from "../schemas"
 
 type ArrayStoredData<S extends readonly unknown[]> = number extends S["length"]
-  ? Array<TypeToStoredData<S[number]> extends infer R ? R : never>
+  ? Array<TypeToStoredData<S[number]>>
   : {
-      [k in keyof S]: TypeToStoredData<S[k]> extends infer R ? R : never
+      [k in keyof S]: TypeToStoredData<S[k]>
     }
 
-type ObjectStoredData<S> = O.Optional<
-  { [k in keyof S]: TypeToStoredData<S[k]> extends infer R ? R : never },
-  ObjectOptionalKeys<S>
+type ObjectStoredData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<
+  { [k in keyof S as k extends OK ? never : k]: TypeToStoredData<S[k]> } & {
+    [k in keyof S as k extends OK ? k : never]?: TypeToStoredData<S[k]>
+  }
 >
 
+// standard types are dispatched through their `$$type` discriminant (see TypeToSnapshotIn)
 export type TypeToStoredData<S> = S extends ObjectTypeFunction
-  ? ObjectStoredData<ReturnType<S>> extends infer R
-    ? R
-    : never
-  : S extends CodecType<any, any, any, infer D>
-    ? D
-    : S extends ArrayType<infer A>
-      ? ArrayStoredData<A>
-      : S extends ObjectType<infer O>
-        ? ObjectStoredData<O>
-        : S extends RecordType<infer R>
-          ? {
-              [k: string]: TypeToStoredData<R> extends infer D ? D : never
-            }
-          : TypeToData<S>
+  ? ObjectStoredData<ReturnType<S>>
+  : S extends { $$type: infer K }
+    ? K extends "codec"
+      ? S["$$storedData" & keyof S]
+      : S extends ArrayType<infer A>
+        ? ArrayStoredData<A>
+        : S extends ObjectType<infer O>
+          ? ObjectStoredData<O>
+          : S extends RecordType<infer R>
+            ? {
+                [k: string]: TypeToStoredData<R>
+              }
+            : TypeToData<S>
+    : TypeToData<S>