mobx-keystone 2.1.0 → 2.3.0

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>

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,
@@ -45,6 +46,11 @@ type CodecConfig<TEncodedType extends AnyType, TRuntime> = {
   is(value: unknown): value is TRuntime
 } & ModelPropTransform<TypeToData<TEncodedType>, TRuntime>
 
+// 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 codec type whose snapshot and stored forms are those of its encoded type.
+ */
 export type CodecFromEncoded<TEncodedType extends AnyType, TRuntime> = CodecType<
   TRuntime,
   TypeToSnapshotIn<TEncodedType>,
@@ -140,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

@@ -1,10 +1,11 @@
 import { isObservableArray, isObservableObject, remove } from "mobx"
 import type { ModelPropTransform } from "../../modelShared/prop"
-import { copyOwnEnumerableProps, isArray, isObject, lazy } from "../../utils"
+import { copyOwnEnumerableProps, hasOwnProp, isArray, isObject, lazy } from "../../utils"
 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"
@@ -136,7 +137,7 @@ function createObjectRuntimeAdapter(
         get(target, prop, receiver) {
           if (typeof prop === "string") {
             const childSupport = getChildSupports()[prop]
-            if (childSupport && Object.hasOwn(target, prop)) {
+            if (childSupport && hasOwnProp(target, prop)) {
               return childSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
                 target[prop] = newStoredValue
               })
@@ -200,7 +201,7 @@ function createRecordRuntimeAdapter(
 
       const proxy = new Proxy(stored, {
         get(target, prop, receiver) {
-          if (typeof prop === "string" && Object.hasOwn(target, prop)) {
+          if (typeof prop === "string" && hasOwnProp(target, prop)) {
             const valueSupport = getValueSupport()
             return valueSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
               target[prop] = newStoredValue
@@ -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 {

package/src/types/utility/typesMap.ts

@@ -41,18 +41,14 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
             return getValue(storedKey)
           }
         case "getOrInsert":
-          return (key: TKeyRuntime, defaultValue: TValueRuntime) => {
-            const storedKey = keyAdapter.toStored(key)
-            if (!target.has(storedKey)) {
-              target.set(storedKey, valueAdapter.toStored(defaultValue))
-            }
-            return getValue(storedKey)
-          }
         case "getOrInsertComputed":
-          return (key: TKeyRuntime, callback: (key: TKeyRuntime) => TValueRuntime) => {
+          return (key: TKeyRuntime, valueOrCallback: unknown) => {
             const storedKey = keyAdapter.toStored(key)
             if (!target.has(storedKey)) {
-              const value = callback(key)
+              const value =
+                prop === "getOrInsert"
+                  ? (valueOrCallback as TValueRuntime)
+                  : (valueOrCallback as (key: TKeyRuntime) => TValueRuntime)(key)
               target.set(storedKey, valueAdapter.toStored(value))
             }
             return getValue(storedKey)
@@ -114,10 +110,18 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   }) as unknown as Map<TKeyRuntime, TValueRuntime>
 }
 
-function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
-  valueAdapter: RuntimeAdapter<TStoredValue, TRuntimeValue>
-): ModelPropTransform<Record<string, TStoredValue>, Map<string, TRuntimeValue>> {
-  const storedByRuntime = new WeakMap<Map<string, TRuntimeValue>, Record<string, TStoredValue>>()
+function makeMapTransform<
+  TStored extends object,
+  TKeyStored,
+  TKeyRuntime,
+  TValueStored,
+  TValueRuntime,
+>(
+  keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
+  valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>,
+  toStored: (runtimeMap: Map<TKeyRuntime, TValueRuntime>) => TStored
+): ModelPropTransform<TStored, Map<TKeyRuntime, TValueRuntime>> {
+  const storedByRuntime = new WeakMap<Map<TKeyRuntime, TValueRuntime>, TStored>()
 
   return {
     transform({ originalValue, cachedTransformedValue }) {
@@ -125,63 +129,51 @@ function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
         return cachedTransformedValue
       }
 
-      const runtimeMap = makeMapProxy(asMap(originalValue), identityRuntimeAdapter, valueAdapter)
+      const runtimeMap = makeMapProxy(
+        asMap(originalValue as any) as Map<TKeyStored, TValueStored>,
+        keyAdapter,
+        valueAdapter
+      )
 
       storedByRuntime.set(runtimeMap, originalValue)
       return runtimeMap
     },
 
     untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
+      return storedByRuntime.get(transformedValue) ?? toStored(transformedValue)
+    },
+  }
+}
 
+function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
+  valueAdapter: RuntimeAdapter<TStoredValue, TRuntimeValue>
+): ModelPropTransform<Record<string, TStoredValue>, Map<string, TRuntimeValue>> {
+  return makeMapTransform(
+    identityRuntimeAdapter as RuntimeAdapter<string, string>,
+    valueAdapter,
+    (runtimeMap) => {
       const result: Record<string, TStoredValue> = {}
-      transformedValue.forEach((value, key) => {
+      runtimeMap.forEach((value, key) => {
         const storedValue = valueAdapter.toStored(value)
         if (key === "__proto__") setProtoProp(result, storedValue)
         else result[key] = storedValue
       })
       return result
-    },
-  }
+    }
+  )
 }
 
 function makeArrayBackedMapTransform<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
   valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>
 ): ModelPropTransform<Array<[TKeyStored, TValueStored]>, Map<TKeyRuntime, TValueRuntime>> {
-  const storedByRuntime = new WeakMap<
-    Map<TKeyRuntime, TValueRuntime>,
-    Array<[TKeyStored, TValueStored]>
-  >()
-
-  return {
-    transform({ originalValue, cachedTransformedValue }) {
-      if (cachedTransformedValue) {
-        return cachedTransformedValue
-      }
-
-      const runtimeMap = makeMapProxy(asMap(originalValue), keyAdapter, valueAdapter)
-
-      storedByRuntime.set(runtimeMap, originalValue)
-      return runtimeMap
-    },
-
-    untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
-
-      const result: Array<[TKeyStored, TValueStored]> = []
-      transformedValue.forEach((value, key) => {
-        result.push([keyAdapter.toStored(key), valueAdapter.toStored(value)])
-      })
-      return result
-    },
-  }
+  return makeMapTransform(keyAdapter, valueAdapter, (runtimeMap) => {
+    const result: Array<[TKeyStored, TValueStored]> = []
+    runtimeMap.forEach((value, key) => {
+      result.push([keyAdapter.toStored(key), valueAdapter.toStored(value)])
+    })
+    return result
+  })
 }
 
 export function typesMapFromObject<TValueType extends AnyType>(