mobx-keystone 1.20.0 → 1.22.0

package/src/types/utility/typesCodecSupport.ts

@@ -1,806 +1,806 @@
-import { isObservableArray, isObservableObject, remove } from "mobx"
-import type { ModelPropTransform } from "../../modelShared/prop"
-import { 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 { isDataModelDataStandardType } from "../objectBased/typesDataModelData"
-import { isModelStandardType } from "../objectBased/typesModel"
-import { ObjectTypeInfo, typesObject } from "../objectBased/typesObject"
-import { RecordTypeInfo, typesRecord } from "../objectBased/typesRecord"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType } from "../schemas"
-import { lateTypeChecker } from "../TypeChecker"
-import {
-  getCodecMetadata,
-  identityRuntimeAdapter,
-  type ResolvedCodecSupport,
-  type RuntimeAdapter,
-} from "./typesCodecCore"
-import { OrTypeInfo, typesOr } from "./typesOr"
-import { RefinementTypeInfo } from "./typesRefinement"
-import { SkipCheckTypeInfo, typesSkipCheck } from "./typesSkipCheck"
-import { TagTypeInfo, typesTag } from "./typesTag"
-
-const codecSupportCache = new WeakMap<AnyStandardType, ResolvedCodecSupport>()
-
-function getArrayIndex(prop: PropertyKey): number | undefined {
-  // Proxy get/set traps always receive string|symbol keys (ECMAScript ToPropertyKey),
-  // so we only need to check for string numeric indices.
-  if (typeof prop === "string" && /^(0|[1-9]\d*)$/.test(prop)) {
-    return Number(prop)
-  }
-
-  return undefined
-}
-
-function normalizeArrayIndex(index: number, length: number): number {
-  if (index < 0) {
-    return Math.max(length + index, 0)
-  }
-
-  return Math.min(index, length)
-}
-
-function resolveArrayAtIndex(index: number, length: number): number | undefined {
-  const resolvedIndex = index < 0 ? length + index : index
-
-  if (resolvedIndex < 0 || resolvedIndex >= length) {
-    return undefined
-  }
-
-  return resolvedIndex
-}
-
-/**
- * Common proxy traps shared between object and record runtime adapters.
- * Only deleteProperty needs special handling for MobX observable objects.
- */
-const objectRecordProxyTraps: Pick<ProxyHandler<Record<string, unknown>>, "deleteProperty"> = {
-  deleteProperty(target, prop) {
-    if (typeof prop === "string" && isObservableObject(target)) {
-      remove(target, prop)
-      return true
-    }
-
-    return Reflect.deleteProperty(target, prop)
-  },
-}
-
-/**
- * Converts a runtime object to its stored form using a cache.
- * Shared by object and record adapters.
- */
-function objectLikeToStored(
-  runtime: unknown,
-  storedByRuntime: WeakMap<object, Record<string, unknown>>,
-  convertValue: (key: string, value: unknown) => unknown
-): Record<string, unknown> {
-  if (isObject(runtime)) {
-    const cachedStored = storedByRuntime.get(runtime)
-    if (cachedStored) {
-      return cachedStored
-    }
-
-    if (isArray(runtime)) {
-      return runtime as never
-    }
-  } else {
-    return runtime as never
-  }
-
-  const stored: Record<string, unknown> = {}
-  for (const key of Object.keys(runtime)) {
-    stored[key] = convertValue(key, runtime[key])
-  }
-  return stored
-}
-
-/**
- * Checks the stored cache for a runtime object.
- * Shared by object and record adapters.
- */
-function objectLikeToStoredIfCached(
-  runtime: unknown,
-  storedByRuntime: WeakMap<object, Record<string, unknown>>
-): { found: true; value: Record<string, unknown> } | { found: false } {
-  if (isObject(runtime) && !isArray(runtime)) {
-    const cachedStored = storedByRuntime.get(runtime)
-    if (cachedStored) {
-      return { found: true, value: cachedStored }
-    }
-  }
-
-  return { found: false }
-}
-
-function createObjectRuntimeAdapter(
-  getChildSupports: () => Record<string, ResolvedCodecSupport>
-): RuntimeAdapter<Record<string, unknown>, Record<string, unknown>> {
-  const runtimeByStored = new WeakMap<object, Record<string, unknown>>()
-  const storedByRuntime = new WeakMap<object, Record<string, unknown>>()
-
-  return {
-    toRuntime(stored) {
-      if (!isObject(stored) || isArray(stored)) {
-        return stored as never
-      }
-
-      const cachedRuntime = runtimeByStored.get(stored)
-      if (cachedRuntime) {
-        return cachedRuntime
-      }
-
-      const proxy = new Proxy(stored, {
-        get(target, prop, receiver) {
-          if (typeof prop === "string") {
-            const childSupport = getChildSupports()[prop]
-            if (childSupport && Object.hasOwn(target, prop)) {
-              return childSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
-                target[prop] = newStoredValue
-              })
-            }
-          }
-
-          return Reflect.get(target, prop, receiver)
-        },
-
-        set(target, prop, value) {
-          if (typeof prop === "string") {
-            const childSupport = getChildSupports()[prop]
-            if (childSupport) {
-              setIfDifferent(target, prop, childSupport.adapter.toStored(value))
-              return true
-            }
-          }
-
-          Reflect.set(target, prop, value)
-          return true
-        },
-
-        ...objectRecordProxyTraps,
-      })
-
-      runtimeByStored.set(stored, proxy)
-      storedByRuntime.set(proxy, stored)
-
-      return proxy
-    },
-
-    toStored(runtime) {
-      const childSupports = getChildSupports()
-      return objectLikeToStored(runtime, storedByRuntime, (key, value) => {
-        const childSupport = childSupports[key]
-        return childSupport ? childSupport.adapter.toStored(value) : value
-      })
-    },
-
-    toStoredIfCached(runtime) {
-      return objectLikeToStoredIfCached(runtime, storedByRuntime)
-    },
-  }
-}
-
-function createRecordRuntimeAdapter(
-  getValueSupport: () => ResolvedCodecSupport
-): RuntimeAdapter<Record<string, unknown>, Record<string, unknown>> {
-  const runtimeByStored = new WeakMap<object, Record<string, unknown>>()
-  const storedByRuntime = new WeakMap<object, Record<string, unknown>>()
-
-  return {
-    toRuntime(stored) {
-      if (!isObject(stored) || isArray(stored)) {
-        return stored as never
-      }
-
-      const cachedRuntime = runtimeByStored.get(stored)
-      if (cachedRuntime) {
-        return cachedRuntime
-      }
-
-      const proxy = new Proxy(stored, {
-        get(target, prop, receiver) {
-          if (typeof prop === "string" && Object.hasOwn(target, prop)) {
-            const valueSupport = getValueSupport()
-            return valueSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
-              target[prop] = newStoredValue
-            })
-          }
-
-          return Reflect.get(target, prop, receiver)
-        },
-
-        set(target, prop, value) {
-          if (typeof prop === "string") {
-            setIfDifferent(target, prop, getValueSupport().adapter.toStored(value))
-            return true
-          }
-
-          Reflect.set(target, prop, value)
-          return true
-        },
-
-        ...objectRecordProxyTraps,
-      })
-
-      runtimeByStored.set(stored, proxy)
-      storedByRuntime.set(proxy, stored)
-
-      return proxy
-    },
-
-    toStored(runtime) {
-      const valueSupport = getValueSupport()
-      return objectLikeToStored(runtime, storedByRuntime, (_key, value) =>
-        valueSupport.adapter.toStored(value)
-      )
-    },
-
-    toStoredIfCached(runtime) {
-      return objectLikeToStoredIfCached(runtime, storedByRuntime)
-    },
-  }
-}
-
-function createArrayLikeRuntimeAdapter(
-  getItemAdapter: (index: number) => RuntimeAdapter<unknown, unknown>
-): RuntimeAdapter<unknown[], unknown[]> {
-  const runtimeByStored = new WeakMap<unknown[], unknown[]>()
-  const storedByRuntime = new WeakMap<unknown[], unknown[]>()
-
-  const decodeIndex = (target: unknown[], index: number) =>
-    index < 0 || index >= target.length || !Reflect.has(target, index)
-      ? undefined
-      : getItemAdapter(index).toRuntime(target[index], (newStoredValue) => {
-          target[index] = newStoredValue
-        })
-
-  const callReadOnlyRuntimeMethod = (
-    receiver: unknown[],
-    methodName: PropertyKey,
-    args: unknown[]
-  ) => {
-    const method = Reflect.get(Array.prototype, methodName, receiver)
-    return Reflect.apply(method, receiver, args)
-  }
-  const materializeRuntimeValues = (target: unknown[]) =>
-    Array.from({ length: target.length }, (_, index) => decodeIndex(target, index))
-  const replaceStoredValues = (target: unknown[], runtimeValues: unknown[]) => {
-    target.splice(
-      0,
-      target.length,
-      ...runtimeValues.map((value, index) => getItemAdapter(index).toStored(value))
-    )
-  }
-  const mutateViaRuntime = (
-    target: unknown[],
-    receiver: unknown[],
-    fn: (values: unknown[]) => void
-  ) => {
-    const runtimeValues = materializeRuntimeValues(target)
-    fn(runtimeValues)
-    replaceStoredValues(target, runtimeValues)
-    return receiver
-  }
-
-  return {
-    toRuntime(stored) {
-      if (!isArray(stored)) {
-        return stored as never
-      }
-
-      const cachedRuntime = runtimeByStored.get(stored)
-      if (cachedRuntime) {
-        return cachedRuntime
-      }
-
-      const proxy: unknown[] = new Proxy(stored, {
-        get(target, prop, receiver) {
-          const index = getArrayIndex(prop)
-          if (index !== undefined) {
-            return decodeIndex(target, index)
-          }
-
-          // MobX 4 observable arrays are array-like but fail `Array.isArray`, so native
-          // `Array.prototype.concat` won't spread this proxy unless we opt in explicitly.
-          if (
-            prop === Symbol.isConcatSpreadable &&
-            isObservableArray(target) &&
-            !Array.isArray(target)
-          ) {
-            return true
-          }
-
-          switch (prop) {
-            case "at":
-              return (indexValue: number) => {
-                const resolvedIndex = resolveArrayAtIndex(indexValue, target.length)
-                return resolvedIndex === undefined ? undefined : decodeIndex(target, resolvedIndex)
-              }
-            case "push":
-              return (...items: unknown[]) =>
-                target.push(
-                  ...items.map((item, offset) =>
-                    getItemAdapter(target.length + offset).toStored(item)
-                  )
-                )
-            case "pop":
-              return () => {
-                if (target.length <= 0) {
-                  return undefined
-                }
-
-                const indexValue = target.length - 1
-                const value = target.pop()
-                return getItemAdapter(indexValue).toRuntime(value)
-              }
-            case "shift":
-              return () => {
-                if (target.length <= 0) {
-                  return undefined
-                }
-
-                const value = target.shift()
-                return getItemAdapter(0).toRuntime(value)
-              }
-            case "unshift":
-              return (...items: unknown[]) =>
-                target.unshift(
-                  ...items.map((item, indexValue) => getItemAdapter(indexValue).toStored(item))
-                )
-            case "splice":
-              return (start: number, deleteCount?: number, ...items: unknown[]) => {
-                const normalizedStart = normalizeArrayIndex(start, target.length)
-                const actualDeleteCount =
-                  deleteCount === undefined
-                    ? target.length - normalizedStart
-                    : Math.max(0, Math.min(deleteCount, target.length - normalizedStart))
-
-                const removedValues = target
-                  .slice(normalizedStart, normalizedStart + actualDeleteCount)
-                  .map((value, indexValue) =>
-                    getItemAdapter(normalizedStart + indexValue).toRuntime(value)
-                  )
-
-                target.splice(
-                  normalizedStart,
-                  actualDeleteCount,
-                  ...items.map((item, indexValue) =>
-                    getItemAdapter(normalizedStart + indexValue).toStored(item)
-                  )
-                )
-
-                return removedValues
-              }
-            case "reverse":
-              return () => mutateViaRuntime(target, receiver, (v) => v.reverse())
-            case "sort":
-              return (compareFn?: (a: unknown, b: unknown) => number) =>
-                mutateViaRuntime(target, receiver, (v) => v.sort(compareFn))
-            case "fill":
-              return (value: unknown, start?: number, end?: number) =>
-                mutateViaRuntime(target, receiver, (v) => v.fill(value, start, end))
-            case "copyWithin":
-              return (targetIndex: number, start?: number, end?: number) =>
-                mutateViaRuntime(target, receiver, (v) =>
-                  v.copyWithin(targetIndex, start ?? 0, end)
-                )
-            case "concat":
-            case "flat":
-            case "flatMap":
-            case "filter":
-            case "find":
-            case "findIndex":
-            case "forEach":
-            case "every":
-            case "includes":
-            case "indexOf":
-            case "join":
-            case "lastIndexOf":
-            case "map":
-            case "reduce":
-            case "reduceRight":
-            case "slice":
-            case "some":
-            case "findLast":
-            case "findLastIndex":
-            case "toReversed":
-            case "toSorted":
-            case "toSpliced":
-            case "toString":
-            case "toLocaleString":
-            case "with":
-              return (...args: unknown[]) => callReadOnlyRuntimeMethod(receiver, prop, args)
-            case "entries":
-              return function* () {
-                for (let i = 0; i < target.length; i++) {
-                  yield [i, decodeIndex(target, i)] as const
-                }
-              }
-            case "keys":
-              return function* () {
-                for (let i = 0; i < target.length; i++) {
-                  yield i
-                }
-              }
-            case "values":
-            case Symbol.iterator:
-              return function* () {
-                for (let i = 0; i < target.length; i++) {
-                  yield decodeIndex(target, i)
-                }
-              }
-            default:
-              return Reflect.get(target, prop, receiver)
-          }
-        },
-
-        set(target, prop, value) {
-          const index = getArrayIndex(prop)
-          if (index !== undefined) {
-            target[index] = getItemAdapter(index).toStored(value)
-            return true
-          }
-
-          Reflect.set(target, prop, value)
-          return true
-        },
-      })
-
-      runtimeByStored.set(stored, proxy)
-      storedByRuntime.set(proxy, stored)
-
-      return proxy
-    },
-
-    toStored(runtime) {
-      if (isArray(runtime)) {
-        const cachedStored = storedByRuntime.get(runtime)
-        if (cachedStored) {
-          return cachedStored
-        }
-
-        return Array.from(runtime, (value, index) => getItemAdapter(index).toStored(value))
-      }
-
-      return runtime as never
-    },
-
-    toStoredIfCached(runtime) {
-      if (isArray(runtime)) {
-        const cachedStored = storedByRuntime.get(runtime)
-        if (cachedStored) {
-          return { found: true, value: cachedStored }
-        }
-      }
-
-      return { found: false }
-    },
-  }
-}
-
-function createCodecLeafRuntimeAdapter(
-  transform: ModelPropTransform<unknown, unknown>
-): RuntimeAdapter<unknown, unknown> {
-  const runtimeByStored = new WeakMap<object, unknown>()
-  const storedByRuntime = new WeakMap<object, unknown>()
-
-  return {
-    toRuntime(stored, setStored) {
-      const cachedRuntime = isObject(stored) ? runtimeByStored.get(stored) : undefined
-
-      const runtime = transform.transform({
-        originalValue: stored,
-        cachedTransformedValue: cachedRuntime,
-        setOriginalValue(newStoredValue) {
-          if (setStored) {
-            setStored(newStoredValue)
-          }
-        },
-      })
-
-      if (isObject(runtime)) {
-        storedByRuntime.set(runtime, stored)
-      }
-
-      if (isObject(stored)) {
-        runtimeByStored.set(stored, runtime)
-      }
-
-      return runtime
-    },
-
-    toStored(runtime) {
-      const cachedStored = isObject(runtime) ? storedByRuntime.get(runtime) : undefined
-      if (cachedStored !== undefined) {
-        return cachedStored
-      }
-
-      const stored = transform.untransform({
-        transformedValue: runtime,
-        cacheTransformedValue: () => {},
-      })
-
-      if (isObject(runtime)) {
-        storedByRuntime.set(runtime, stored)
-      }
-
-      if (isObject(stored)) {
-        runtimeByStored.set(stored, runtime)
-      }
-
-      return stored
-    },
-
-    toStoredIfCached(runtime) {
-      if (isObject(runtime)) {
-        const cachedStored = storedByRuntime.get(runtime)
-        if (cachedStored !== undefined) {
-          return { found: true, value: cachedStored }
-        }
-      }
-
-      return { found: false }
-    },
-  }
-}
-
-function createOrRuntimeAdapter(
-  childTypes: ReadonlyArray<AnyStandardType>,
-  getChildSupports: () => ReadonlyArray<ResolvedCodecSupport>,
-  dispatcher: OrTypeInfo["dispatcher"]
-): RuntimeAdapter<unknown, unknown> {
-  const getRuntimeSupportForValue = (value: unknown) => {
-    const supports = getChildSupports()
-    for (let i = 0; i < supports.length; i++) {
-      const childType = childTypes[i]
-      const tc = resolveTypeChecker(childType)
-      if (tc.skipCheck) {
-        // For skipCheck branches, use snapshotType for structural matching
-        // instead of check (which always passes and would match any value)
-        if (tc.snapshotType(value)) {
-          return supports[i]
-        }
-      } else if (!tc.check(value, [], value)) {
-        return supports[i]
-      }
-    }
-
-    return supports[0]
-  }
-
-  const getStoredSupportForValue = (value: unknown) => {
-    if (dispatcher) {
-      return resolveCodecSupport(dispatcher(value))
-    }
-
-    const supports = getChildSupports()
-    for (let i = 0; i < supports.length; i++) {
-      const storedTypeChecker = resolveTypeChecker(supports[i].storedType)
-      if (storedTypeChecker.snapshotType(value)) {
-        return supports[i]
-      }
-    }
-
-    return supports[0]
-  }
-
-  return {
-    toRuntime(stored, setStored) {
-      return getStoredSupportForValue(stored).adapter.toRuntime(stored, setStored)
-    },
-
-    toStored(runtime) {
-      return getRuntimeSupportForValue(runtime).adapter.toStored(runtime)
-    },
-
-    toStoredIfCached(runtime) {
-      return getRuntimeSupportForValue(runtime).adapter.toStoredIfCached(runtime)
-    },
-  }
-}
-
-function noCodecSupport(type: AnyStandardType): ResolvedCodecSupport {
-  return { hasCodec: false, storedType: type, adapter: identityRuntimeAdapter }
-}
-
-function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCodecSupport {
-  const cachedSupport = codecSupportCache.get(type)
-  if (cachedSupport) {
-    return cachedSupport
-  }
-
-  let resolvedSupport: ResolvedCodecSupport | undefined
-  let resolvedStoredType: AnyStandardType | undefined
-
-  const placeholderSupport: ResolvedCodecSupport = {
-    hasCodec: false,
-    storedType: lateTypeChecker(
-      () => resolveTypeChecker(resolvedStoredType ?? type),
-      () => getTypeInfo(resolvedStoredType ?? type)
-    ) as any,
-    adapter: {
-      toRuntime(stored, setStored) {
-        return (resolvedSupport?.adapter ?? identityRuntimeAdapter).toRuntime(stored, setStored)
-      },
-
-      toStored(runtime) {
-        return (resolvedSupport?.adapter ?? identityRuntimeAdapter).toStored(runtime)
-      },
-
-      toStoredIfCached(runtime) {
-        return (resolvedSupport?.adapter ?? identityRuntimeAdapter).toStoredIfCached(runtime)
-      },
-    },
-  }
-
-  codecSupportCache.set(type, placeholderSupport)
-
-  const codecMetadata = getCodecMetadata(type)
-  if (codecMetadata) {
-    resolvedSupport = {
-      hasCodec: true,
-      storedType: resolveStandardType(codecMetadata.encodedType),
-      adapter: createCodecLeafRuntimeAdapter(codecMetadata.transform),
-    }
-  } else if (isModelStandardType(type) || isDataModelDataStandardType(type)) {
-    resolvedSupport = noCodecSupport(type)
-  } else {
-    const typeInfo = getTypeInfo(type)
-
-    if (typeInfo instanceof ArrayTypeInfo) {
-      const itemSupport = lazy(() => resolveCodecSupportForStandardType(typeInfo.itemType))
-
-      resolvedSupport = !itemSupport().hasCodec
-        ? noCodecSupport(type)
-        : {
-            hasCodec: true,
-            storedType: typesArray(itemSupport().storedType),
-            adapter: createArrayLikeRuntimeAdapter(() => itemSupport().adapter),
-          }
-    } else if (typeInfo instanceof TupleTypeInfo) {
-      const itemSupports = lazy(() =>
-        typeInfo.itemTypes.map((itemType) => resolveCodecSupportForStandardType(itemType))
-      )
-
-      resolvedSupport = !itemSupports().some((itemSupport) => itemSupport.hasCodec)
-        ? noCodecSupport(type)
-        : {
-            hasCodec: true,
-            storedType: typesTuple(...itemSupports().map((itemSupport) => itemSupport.storedType)),
-            adapter: createArrayLikeRuntimeAdapter(
-              (index) => itemSupports()[index]?.adapter ?? identityRuntimeAdapter
-            ),
-          }
-    } else if (typeInfo instanceof ObjectTypeInfo) {
-      const childSupports = lazy(() => {
-        const supports: Record<string, ResolvedCodecSupport> = {}
-        const props = typeInfo.props
-        for (const propName of Object.keys(props)) {
-          supports[propName] = resolveCodecSupportForStandardType(props[propName].type)
-        }
-        return supports
-      })
-
-      resolvedSupport = !Object.values(childSupports()).some(
-        (childSupport) => childSupport.hasCodec
-      )
-        ? noCodecSupport(type)
-        : {
-            hasCodec: true,
-            storedType: typesObject(() => {
-              const storedProps: Record<string, AnyStandardType> = {}
-              const props = typeInfo.props
-              for (const propName of Object.keys(props)) {
-                storedProps[propName] = childSupports()[propName].storedType
-              }
-              return storedProps
-            }),
-            adapter: createObjectRuntimeAdapter(childSupports),
-          }
-    } else if (typeInfo instanceof RecordTypeInfo) {
-      const valueSupport = lazy(() => resolveCodecSupportForStandardType(typeInfo.valueType))
-
-      resolvedSupport = !valueSupport().hasCodec
-        ? noCodecSupport(type)
-        : {
-            hasCodec: true,
-            storedType: typesRecord(valueSupport().storedType),
-            adapter: createRecordRuntimeAdapter(valueSupport),
-          }
-    } else if (typeInfo instanceof TagTypeInfo) {
-      const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
-
-      resolvedSupport = !baseSupport.hasCodec
-        ? noCodecSupport(type)
-        : {
-            hasCodec: true,
-            storedType: typesTag(baseSupport.storedType, typeInfo.tag, typeInfo.typeName),
-            adapter: baseSupport.adapter,
-          }
-    } else if (typeInfo instanceof RefinementTypeInfo) {
-      const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
-
-      resolvedSupport = baseSupport.hasCodec ? baseSupport : noCodecSupport(type)
-    } else if (typeInfo instanceof SkipCheckTypeInfo) {
-      const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
-
-      // Always wrap storedType with skipCheck, even when hasCodec is false.
-      // resolveStoredType() feeds model-internal automatic validation in sharedInternalModel.ts,
-      // so the skipCheck wrapper must propagate to prevent the stored type from being validated.
-      resolvedSupport = {
-        hasCodec: baseSupport.hasCodec,
-        storedType: typesSkipCheck(baseSupport.storedType),
-        adapter: baseSupport.adapter,
-      }
-    } else if (typeInfo instanceof OrTypeInfo) {
-      const childSupports = lazy(() =>
-        typeInfo.orTypes.map((orType) => resolveCodecSupportForStandardType(orType))
-      )
-
-      resolvedSupport = !childSupports().some((childSupport) => childSupport.hasCodec)
-        ? noCodecSupport(type)
-        : {
-            hasCodec: true,
-            storedType: typeInfo.dispatcher
-              ? typesOr(
-                  (snapshot) => resolveStoredType(typeInfo.dispatcher!(snapshot)),
-                  ...childSupports().map((childSupport) => childSupport.storedType)
-                )
-              : typesOr(...childSupports().map((childSupport) => childSupport.storedType)),
-            adapter: createOrRuntimeAdapter(typeInfo.orTypes, childSupports, typeInfo.dispatcher),
-          }
-    } else {
-      resolvedSupport = noCodecSupport(type)
-    }
-  }
-
-  resolvedStoredType = resolvedSupport.storedType
-  placeholderSupport.hasCodec = resolvedSupport.hasCodec
-  placeholderSupport.storedType = resolvedSupport.storedType
-  placeholderSupport.adapter = resolvedSupport.adapter
-
-  return placeholderSupport
-}
-
-export function resolveCodecSupport(type: AnyType) {
-  return resolveCodecSupportForStandardType(resolveStandardType(type))
-}
-
-export function resolveStoredType(type: AnyType) {
-  return resolveCodecSupport(type).storedType
-}
-
-export function resolveStoredTypeChecker(type: AnyType) {
-  return resolveTypeChecker(resolveCodecSupport(type).storedType)
-}
-
-export function createCodecPropTransform(type: AnyType): ModelPropTransform<any, unknown> {
-  const adapter = resolveCodecSupport(type).adapter
-
-  return {
-    transform({ originalValue, cachedTransformedValue, setOriginalValue }) {
-      // For leaf codecs backed by primitive stored data (e.g. timestamps, ISO strings),
-      // the adapter's WeakMap cache can't work. Thread the model's cachedTransformedValue
-      // to avoid creating new runtime objects when the stored value hasn't changed.
-      if (cachedTransformedValue !== undefined) {
-        const cachedStored = adapter.toStoredIfCached(cachedTransformedValue)
-        if (cachedStored.found && cachedStored.value === originalValue) {
-          return cachedTransformedValue
-        }
-      }
-      return adapter.toRuntime(originalValue, setOriginalValue)
-    },
-
-    untransform({ transformedValue, cacheTransformedValue }) {
-      const cachedStored = adapter.toStoredIfCached(transformedValue)
-      if (cachedStored.found) {
-        cacheTransformedValue()
-        return cachedStored.value
-      }
-
-      return adapter.toStored(transformedValue)
-    },
-  }
-}
+import { isObservableArray, isObservableObject, remove } from "mobx"
+import type { ModelPropTransform } from "../../modelShared/prop"
+import { 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 { isDataModelDataStandardType } from "../objectBased/typesDataModelData"
+import { isModelStandardType } from "../objectBased/typesModel"
+import { ObjectTypeInfo, typesObject } from "../objectBased/typesObject"
+import { RecordTypeInfo, typesRecord } from "../objectBased/typesRecord"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType } from "../schemas"
+import { lateTypeChecker } from "../TypeChecker"
+import {
+  getCodecMetadata,
+  identityRuntimeAdapter,
+  type ResolvedCodecSupport,
+  type RuntimeAdapter,
+} from "./typesCodecCore"
+import { OrTypeInfo, typesOr } from "./typesOr"
+import { RefinementTypeInfo } from "./typesRefinement"
+import { SkipCheckTypeInfo, typesSkipCheck } from "./typesSkipCheck"
+import { TagTypeInfo, typesTag } from "./typesTag"
+
+const codecSupportCache = new WeakMap<AnyStandardType, ResolvedCodecSupport>()
+
+function getArrayIndex(prop: PropertyKey): number | undefined {
+  // Proxy get/set traps always receive string|symbol keys (ECMAScript ToPropertyKey),
+  // so we only need to check for string numeric indices.
+  if (typeof prop === "string" && /^(0|[1-9]\d*)$/.test(prop)) {
+    return Number(prop)
+  }
+
+  return undefined
+}
+
+function normalizeArrayIndex(index: number, length: number): number {
+  if (index < 0) {
+    return Math.max(length + index, 0)
+  }
+
+  return Math.min(index, length)
+}
+
+function resolveArrayAtIndex(index: number, length: number): number | undefined {
+  const resolvedIndex = index < 0 ? length + index : index
+
+  if (resolvedIndex < 0 || resolvedIndex >= length) {
+    return undefined
+  }
+
+  return resolvedIndex
+}
+
+/**
+ * Common proxy traps shared between object and record runtime adapters.
+ * Only deleteProperty needs special handling for MobX observable objects.
+ */
+const objectRecordProxyTraps: Pick<ProxyHandler<Record<string, unknown>>, "deleteProperty"> = {
+  deleteProperty(target, prop) {
+    if (typeof prop === "string" && isObservableObject(target)) {
+      remove(target, prop)
+      return true
+    }
+
+    return Reflect.deleteProperty(target, prop)
+  },
+}
+
+/**
+ * Converts a runtime object to its stored form using a cache.
+ * Shared by object and record adapters.
+ */
+function objectLikeToStored(
+  runtime: unknown,
+  storedByRuntime: WeakMap<object, Record<string, unknown>>,
+  convertValue: (key: string, value: unknown) => unknown
+): Record<string, unknown> {
+  if (isObject(runtime)) {
+    const cachedStored = storedByRuntime.get(runtime)
+    if (cachedStored) {
+      return cachedStored
+    }
+
+    if (isArray(runtime)) {
+      return runtime as never
+    }
+  } else {
+    return runtime as never
+  }
+
+  const stored: Record<string, unknown> = {}
+  for (const key of Object.keys(runtime)) {
+    stored[key] = convertValue(key, runtime[key])
+  }
+  return stored
+}
+
+/**
+ * Checks the stored cache for a runtime object.
+ * Shared by object and record adapters.
+ */
+function objectLikeToStoredIfCached(
+  runtime: unknown,
+  storedByRuntime: WeakMap<object, Record<string, unknown>>
+): { found: true; value: Record<string, unknown> } | { found: false } {
+  if (isObject(runtime) && !isArray(runtime)) {
+    const cachedStored = storedByRuntime.get(runtime)
+    if (cachedStored) {
+      return { found: true, value: cachedStored }
+    }
+  }
+
+  return { found: false }
+}
+
+function createObjectRuntimeAdapter(
+  getChildSupports: () => Record<string, ResolvedCodecSupport>
+): RuntimeAdapter<Record<string, unknown>, Record<string, unknown>> {
+  const runtimeByStored = new WeakMap<object, Record<string, unknown>>()
+  const storedByRuntime = new WeakMap<object, Record<string, unknown>>()
+
+  return {
+    toRuntime(stored) {
+      if (!isObject(stored) || isArray(stored)) {
+        return stored as never
+      }
+
+      const cachedRuntime = runtimeByStored.get(stored)
+      if (cachedRuntime) {
+        return cachedRuntime
+      }
+
+      const proxy = new Proxy(stored, {
+        get(target, prop, receiver) {
+          if (typeof prop === "string") {
+            const childSupport = getChildSupports()[prop]
+            if (childSupport && Object.hasOwn(target, prop)) {
+              return childSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
+                target[prop] = newStoredValue
+              })
+            }
+          }
+
+          return Reflect.get(target, prop, receiver)
+        },
+
+        set(target, prop, value) {
+          if (typeof prop === "string") {
+            const childSupport = getChildSupports()[prop]
+            if (childSupport) {
+              setIfDifferent(target, prop, childSupport.adapter.toStored(value))
+              return true
+            }
+          }
+
+          Reflect.set(target, prop, value)
+          return true
+        },
+
+        ...objectRecordProxyTraps,
+      })
+
+      runtimeByStored.set(stored, proxy)
+      storedByRuntime.set(proxy, stored)
+
+      return proxy
+    },
+
+    toStored(runtime) {
+      const childSupports = getChildSupports()
+      return objectLikeToStored(runtime, storedByRuntime, (key, value) => {
+        const childSupport = childSupports[key]
+        return childSupport ? childSupport.adapter.toStored(value) : value
+      })
+    },
+
+    toStoredIfCached(runtime) {
+      return objectLikeToStoredIfCached(runtime, storedByRuntime)
+    },
+  }
+}
+
+function createRecordRuntimeAdapter(
+  getValueSupport: () => ResolvedCodecSupport
+): RuntimeAdapter<Record<string, unknown>, Record<string, unknown>> {
+  const runtimeByStored = new WeakMap<object, Record<string, unknown>>()
+  const storedByRuntime = new WeakMap<object, Record<string, unknown>>()
+
+  return {
+    toRuntime(stored) {
+      if (!isObject(stored) || isArray(stored)) {
+        return stored as never
+      }
+
+      const cachedRuntime = runtimeByStored.get(stored)
+      if (cachedRuntime) {
+        return cachedRuntime
+      }
+
+      const proxy = new Proxy(stored, {
+        get(target, prop, receiver) {
+          if (typeof prop === "string" && Object.hasOwn(target, prop)) {
+            const valueSupport = getValueSupport()
+            return valueSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
+              target[prop] = newStoredValue
+            })
+          }
+
+          return Reflect.get(target, prop, receiver)
+        },
+
+        set(target, prop, value) {
+          if (typeof prop === "string") {
+            setIfDifferent(target, prop, getValueSupport().adapter.toStored(value))
+            return true
+          }
+
+          Reflect.set(target, prop, value)
+          return true
+        },
+
+        ...objectRecordProxyTraps,
+      })
+
+      runtimeByStored.set(stored, proxy)
+      storedByRuntime.set(proxy, stored)
+
+      return proxy
+    },
+
+    toStored(runtime) {
+      const valueSupport = getValueSupport()
+      return objectLikeToStored(runtime, storedByRuntime, (_key, value) =>
+        valueSupport.adapter.toStored(value)
+      )
+    },
+
+    toStoredIfCached(runtime) {
+      return objectLikeToStoredIfCached(runtime, storedByRuntime)
+    },
+  }
+}
+
+function createArrayLikeRuntimeAdapter(
+  getItemAdapter: (index: number) => RuntimeAdapter<unknown, unknown>
+): RuntimeAdapter<unknown[], unknown[]> {
+  const runtimeByStored = new WeakMap<unknown[], unknown[]>()
+  const storedByRuntime = new WeakMap<unknown[], unknown[]>()
+
+  const decodeIndex = (target: unknown[], index: number) =>
+    index < 0 || index >= target.length || !Reflect.has(target, index)
+      ? undefined
+      : getItemAdapter(index).toRuntime(target[index], (newStoredValue) => {
+          target[index] = newStoredValue
+        })
+
+  const callReadOnlyRuntimeMethod = (
+    receiver: unknown[],
+    methodName: PropertyKey,
+    args: unknown[]
+  ) => {
+    const method = Reflect.get(Array.prototype, methodName, receiver)
+    return Reflect.apply(method, receiver, args)
+  }
+  const materializeRuntimeValues = (target: unknown[]) =>
+    Array.from({ length: target.length }, (_, index) => decodeIndex(target, index))
+  const replaceStoredValues = (target: unknown[], runtimeValues: unknown[]) => {
+    target.splice(
+      0,
+      target.length,
+      ...runtimeValues.map((value, index) => getItemAdapter(index).toStored(value))
+    )
+  }
+  const mutateViaRuntime = (
+    target: unknown[],
+    receiver: unknown[],
+    fn: (values: unknown[]) => void
+  ) => {
+    const runtimeValues = materializeRuntimeValues(target)
+    fn(runtimeValues)
+    replaceStoredValues(target, runtimeValues)
+    return receiver
+  }
+
+  return {
+    toRuntime(stored) {
+      if (!isArray(stored)) {
+        return stored as never
+      }
+
+      const cachedRuntime = runtimeByStored.get(stored)
+      if (cachedRuntime) {
+        return cachedRuntime
+      }
+
+      const proxy: unknown[] = new Proxy(stored, {
+        get(target, prop, receiver) {
+          const index = getArrayIndex(prop)
+          if (index !== undefined) {
+            return decodeIndex(target, index)
+          }
+
+          // MobX 4 observable arrays are array-like but fail `Array.isArray`, so native
+          // `Array.prototype.concat` won't spread this proxy unless we opt in explicitly.
+          if (
+            prop === Symbol.isConcatSpreadable &&
+            isObservableArray(target) &&
+            !Array.isArray(target)
+          ) {
+            return true
+          }
+
+          switch (prop) {
+            case "at":
+              return (indexValue: number) => {
+                const resolvedIndex = resolveArrayAtIndex(indexValue, target.length)
+                return resolvedIndex === undefined ? undefined : decodeIndex(target, resolvedIndex)
+              }
+            case "push":
+              return (...items: unknown[]) =>
+                target.push(
+                  ...items.map((item, offset) =>
+                    getItemAdapter(target.length + offset).toStored(item)
+                  )
+                )
+            case "pop":
+              return () => {
+                if (target.length <= 0) {
+                  return undefined
+                }
+
+                const indexValue = target.length - 1
+                const value = target.pop()
+                return getItemAdapter(indexValue).toRuntime(value)
+              }
+            case "shift":
+              return () => {
+                if (target.length <= 0) {
+                  return undefined
+                }
+
+                const value = target.shift()
+                return getItemAdapter(0).toRuntime(value)
+              }
+            case "unshift":
+              return (...items: unknown[]) =>
+                target.unshift(
+                  ...items.map((item, indexValue) => getItemAdapter(indexValue).toStored(item))
+                )
+            case "splice":
+              return (start: number, deleteCount?: number, ...items: unknown[]) => {
+                const normalizedStart = normalizeArrayIndex(start, target.length)
+                const actualDeleteCount =
+                  deleteCount === undefined
+                    ? target.length - normalizedStart
+                    : Math.max(0, Math.min(deleteCount, target.length - normalizedStart))
+
+                const removedValues = target
+                  .slice(normalizedStart, normalizedStart + actualDeleteCount)
+                  .map((value, indexValue) =>
+                    getItemAdapter(normalizedStart + indexValue).toRuntime(value)
+                  )
+
+                target.splice(
+                  normalizedStart,
+                  actualDeleteCount,
+                  ...items.map((item, indexValue) =>
+                    getItemAdapter(normalizedStart + indexValue).toStored(item)
+                  )
+                )
+
+                return removedValues
+              }
+            case "reverse":
+              return () => mutateViaRuntime(target, receiver, (v) => v.reverse())
+            case "sort":
+              return (compareFn?: (a: unknown, b: unknown) => number) =>
+                mutateViaRuntime(target, receiver, (v) => v.sort(compareFn))
+            case "fill":
+              return (value: unknown, start?: number, end?: number) =>
+                mutateViaRuntime(target, receiver, (v) => v.fill(value, start, end))
+            case "copyWithin":
+              return (targetIndex: number, start?: number, end?: number) =>
+                mutateViaRuntime(target, receiver, (v) =>
+                  v.copyWithin(targetIndex, start ?? 0, end)
+                )
+            case "concat":
+            case "flat":
+            case "flatMap":
+            case "filter":
+            case "find":
+            case "findIndex":
+            case "forEach":
+            case "every":
+            case "includes":
+            case "indexOf":
+            case "join":
+            case "lastIndexOf":
+            case "map":
+            case "reduce":
+            case "reduceRight":
+            case "slice":
+            case "some":
+            case "findLast":
+            case "findLastIndex":
+            case "toReversed":
+            case "toSorted":
+            case "toSpliced":
+            case "toString":
+            case "toLocaleString":
+            case "with":
+              return (...args: unknown[]) => callReadOnlyRuntimeMethod(receiver, prop, args)
+            case "entries":
+              return function* () {
+                for (let i = 0; i < target.length; i++) {
+                  yield [i, decodeIndex(target, i)] as const
+                }
+              }
+            case "keys":
+              return function* () {
+                for (let i = 0; i < target.length; i++) {
+                  yield i
+                }
+              }
+            case "values":
+            case Symbol.iterator:
+              return function* () {
+                for (let i = 0; i < target.length; i++) {
+                  yield decodeIndex(target, i)
+                }
+              }
+            default:
+              return Reflect.get(target, prop, receiver)
+          }
+        },
+
+        set(target, prop, value) {
+          const index = getArrayIndex(prop)
+          if (index !== undefined) {
+            target[index] = getItemAdapter(index).toStored(value)
+            return true
+          }
+
+          Reflect.set(target, prop, value)
+          return true
+        },
+      })
+
+      runtimeByStored.set(stored, proxy)
+      storedByRuntime.set(proxy, stored)
+
+      return proxy
+    },
+
+    toStored(runtime) {
+      if (isArray(runtime)) {
+        const cachedStored = storedByRuntime.get(runtime)
+        if (cachedStored) {
+          return cachedStored
+        }
+
+        return Array.from(runtime, (value, index) => getItemAdapter(index).toStored(value))
+      }
+
+      return runtime as never
+    },
+
+    toStoredIfCached(runtime) {
+      if (isArray(runtime)) {
+        const cachedStored = storedByRuntime.get(runtime)
+        if (cachedStored) {
+          return { found: true, value: cachedStored }
+        }
+      }
+
+      return { found: false }
+    },
+  }
+}
+
+function createCodecLeafRuntimeAdapter(
+  transform: ModelPropTransform<unknown, unknown>
+): RuntimeAdapter<unknown, unknown> {
+  const runtimeByStored = new WeakMap<object, unknown>()
+  const storedByRuntime = new WeakMap<object, unknown>()
+
+  return {
+    toRuntime(stored, setStored) {
+      const cachedRuntime = isObject(stored) ? runtimeByStored.get(stored) : undefined
+
+      const runtime = transform.transform({
+        originalValue: stored,
+        cachedTransformedValue: cachedRuntime,
+        setOriginalValue(newStoredValue) {
+          if (setStored) {
+            setStored(newStoredValue)
+          }
+        },
+      })
+
+      if (isObject(runtime)) {
+        storedByRuntime.set(runtime, stored)
+      }
+
+      if (isObject(stored)) {
+        runtimeByStored.set(stored, runtime)
+      }
+
+      return runtime
+    },
+
+    toStored(runtime) {
+      const cachedStored = isObject(runtime) ? storedByRuntime.get(runtime) : undefined
+      if (cachedStored !== undefined) {
+        return cachedStored
+      }
+
+      const stored = transform.untransform({
+        transformedValue: runtime,
+        cacheTransformedValue: () => {},
+      })
+
+      if (isObject(runtime)) {
+        storedByRuntime.set(runtime, stored)
+      }
+
+      if (isObject(stored)) {
+        runtimeByStored.set(stored, runtime)
+      }
+
+      return stored
+    },
+
+    toStoredIfCached(runtime) {
+      if (isObject(runtime)) {
+        const cachedStored = storedByRuntime.get(runtime)
+        if (cachedStored !== undefined) {
+          return { found: true, value: cachedStored }
+        }
+      }
+
+      return { found: false }
+    },
+  }
+}
+
+function createOrRuntimeAdapter(
+  childTypes: ReadonlyArray<AnyStandardType>,
+  getChildSupports: () => ReadonlyArray<ResolvedCodecSupport>,
+  dispatcher: OrTypeInfo["dispatcher"]
+): RuntimeAdapter<unknown, unknown> {
+  const getRuntimeSupportForValue = (value: unknown) => {
+    const supports = getChildSupports()
+    for (let i = 0; i < supports.length; i++) {
+      const childType = childTypes[i]
+      const tc = resolveTypeChecker(childType)
+      if (tc.skipCheck) {
+        // For skipCheck branches, use snapshotType for structural matching
+        // instead of check (which always passes and would match any value)
+        if (tc.snapshotType(value)) {
+          return supports[i]
+        }
+      } else if (!tc.check(value, [], value)) {
+        return supports[i]
+      }
+    }
+
+    return supports[0]
+  }
+
+  const getStoredSupportForValue = (value: unknown) => {
+    if (dispatcher) {
+      return resolveCodecSupport(dispatcher(value))
+    }
+
+    const supports = getChildSupports()
+    for (let i = 0; i < supports.length; i++) {
+      const storedTypeChecker = resolveTypeChecker(supports[i].storedType)
+      if (storedTypeChecker.snapshotType(value)) {
+        return supports[i]
+      }
+    }
+
+    return supports[0]
+  }
+
+  return {
+    toRuntime(stored, setStored) {
+      return getStoredSupportForValue(stored).adapter.toRuntime(stored, setStored)
+    },
+
+    toStored(runtime) {
+      return getRuntimeSupportForValue(runtime).adapter.toStored(runtime)
+    },
+
+    toStoredIfCached(runtime) {
+      return getRuntimeSupportForValue(runtime).adapter.toStoredIfCached(runtime)
+    },
+  }
+}
+
+function noCodecSupport(type: AnyStandardType): ResolvedCodecSupport {
+  return { hasCodec: false, storedType: type, adapter: identityRuntimeAdapter }
+}
+
+function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCodecSupport {
+  const cachedSupport = codecSupportCache.get(type)
+  if (cachedSupport) {
+    return cachedSupport
+  }
+
+  let resolvedSupport: ResolvedCodecSupport | undefined
+  let resolvedStoredType: AnyStandardType | undefined
+
+  const placeholderSupport: ResolvedCodecSupport = {
+    hasCodec: false,
+    storedType: lateTypeChecker(
+      () => resolveTypeChecker(resolvedStoredType ?? type),
+      () => getTypeInfo(resolvedStoredType ?? type)
+    ) as any,
+    adapter: {
+      toRuntime(stored, setStored) {
+        return (resolvedSupport?.adapter ?? identityRuntimeAdapter).toRuntime(stored, setStored)
+      },
+
+      toStored(runtime) {
+        return (resolvedSupport?.adapter ?? identityRuntimeAdapter).toStored(runtime)
+      },
+
+      toStoredIfCached(runtime) {
+        return (resolvedSupport?.adapter ?? identityRuntimeAdapter).toStoredIfCached(runtime)
+      },
+    },
+  }
+
+  codecSupportCache.set(type, placeholderSupport)
+
+  const codecMetadata = getCodecMetadata(type)
+  if (codecMetadata) {
+    resolvedSupport = {
+      hasCodec: true,
+      storedType: resolveStandardType(codecMetadata.encodedType),
+      adapter: createCodecLeafRuntimeAdapter(codecMetadata.transform),
+    }
+  } else if (isModelStandardType(type) || isDataModelDataStandardType(type)) {
+    resolvedSupport = noCodecSupport(type)
+  } else {
+    const typeInfo = getTypeInfo(type)
+
+    if (typeInfo instanceof ArrayTypeInfo) {
+      const itemSupport = lazy(() => resolveCodecSupportForStandardType(typeInfo.itemType))
+
+      resolvedSupport = !itemSupport().hasCodec
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesArray(itemSupport().storedType),
+            adapter: createArrayLikeRuntimeAdapter(() => itemSupport().adapter),
+          }
+    } else if (typeInfo instanceof TupleTypeInfo) {
+      const itemSupports = lazy(() =>
+        typeInfo.itemTypes.map((itemType) => resolveCodecSupportForStandardType(itemType))
+      )
+
+      resolvedSupport = !itemSupports().some((itemSupport) => itemSupport.hasCodec)
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesTuple(...itemSupports().map((itemSupport) => itemSupport.storedType)),
+            adapter: createArrayLikeRuntimeAdapter(
+              (index) => itemSupports()[index]?.adapter ?? identityRuntimeAdapter
+            ),
+          }
+    } else if (typeInfo instanceof ObjectTypeInfo) {
+      const childSupports = lazy(() => {
+        const supports: Record<string, ResolvedCodecSupport> = {}
+        const props = typeInfo.props
+        for (const propName of Object.keys(props)) {
+          supports[propName] = resolveCodecSupportForStandardType(props[propName].type)
+        }
+        return supports
+      })
+
+      resolvedSupport = !Object.values(childSupports()).some(
+        (childSupport) => childSupport.hasCodec
+      )
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesObject(() => {
+              const storedProps: Record<string, AnyStandardType> = {}
+              const props = typeInfo.props
+              for (const propName of Object.keys(props)) {
+                storedProps[propName] = childSupports()[propName].storedType
+              }
+              return storedProps
+            }),
+            adapter: createObjectRuntimeAdapter(childSupports),
+          }
+    } else if (typeInfo instanceof RecordTypeInfo) {
+      const valueSupport = lazy(() => resolveCodecSupportForStandardType(typeInfo.valueType))
+
+      resolvedSupport = !valueSupport().hasCodec
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesRecord(valueSupport().storedType),
+            adapter: createRecordRuntimeAdapter(valueSupport),
+          }
+    } else if (typeInfo instanceof TagTypeInfo) {
+      const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
+
+      resolvedSupport = !baseSupport.hasCodec
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesTag(baseSupport.storedType, typeInfo.tag, typeInfo.typeName),
+            adapter: baseSupport.adapter,
+          }
+    } else if (typeInfo instanceof RefinementTypeInfo) {
+      const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
+
+      resolvedSupport = baseSupport.hasCodec ? baseSupport : noCodecSupport(type)
+    } else if (typeInfo instanceof SkipCheckTypeInfo) {
+      const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
+
+      // Always wrap storedType with skipCheck, even when hasCodec is false.
+      // resolveStoredType() feeds model-internal automatic validation in sharedInternalModel.ts,
+      // so the skipCheck wrapper must propagate to prevent the stored type from being validated.
+      resolvedSupport = {
+        hasCodec: baseSupport.hasCodec,
+        storedType: typesSkipCheck(baseSupport.storedType),
+        adapter: baseSupport.adapter,
+      }
+    } else if (typeInfo instanceof OrTypeInfo) {
+      const childSupports = lazy(() =>
+        typeInfo.orTypes.map((orType) => resolveCodecSupportForStandardType(orType))
+      )
+
+      resolvedSupport = !childSupports().some((childSupport) => childSupport.hasCodec)
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typeInfo.dispatcher
+              ? typesOr(
+                  (snapshot) => resolveStoredType(typeInfo.dispatcher!(snapshot)),
+                  ...childSupports().map((childSupport) => childSupport.storedType)
+                )
+              : typesOr(...childSupports().map((childSupport) => childSupport.storedType)),
+            adapter: createOrRuntimeAdapter(typeInfo.orTypes, childSupports, typeInfo.dispatcher),
+          }
+    } else {
+      resolvedSupport = noCodecSupport(type)
+    }
+  }
+
+  resolvedStoredType = resolvedSupport.storedType
+  placeholderSupport.hasCodec = resolvedSupport.hasCodec
+  placeholderSupport.storedType = resolvedSupport.storedType
+  placeholderSupport.adapter = resolvedSupport.adapter
+
+  return placeholderSupport
+}
+
+export function resolveCodecSupport(type: AnyType) {
+  return resolveCodecSupportForStandardType(resolveStandardType(type))
+}
+
+export function resolveStoredType(type: AnyType) {
+  return resolveCodecSupport(type).storedType
+}
+
+export function resolveStoredTypeChecker(type: AnyType) {
+  return resolveTypeChecker(resolveCodecSupport(type).storedType)
+}
+
+export function createCodecPropTransform(type: AnyType): ModelPropTransform<any, unknown> {
+  const adapter = resolveCodecSupport(type).adapter
+
+  return {
+    transform({ originalValue, cachedTransformedValue, setOriginalValue }) {
+      // For leaf codecs backed by primitive stored data (e.g. timestamps, ISO strings),
+      // the adapter's WeakMap cache can't work. Thread the model's cachedTransformedValue
+      // to avoid creating new runtime objects when the stored value hasn't changed.
+      if (cachedTransformedValue !== undefined) {
+        const cachedStored = adapter.toStoredIfCached(cachedTransformedValue)
+        if (cachedStored.found && cachedStored.value === originalValue) {
+          return cachedTransformedValue
+        }
+      }
+      return adapter.toRuntime(originalValue, setOriginalValue)
+    },
+
+    untransform({ transformedValue, cacheTransformedValue }) {
+      const cachedStored = adapter.toStoredIfCached(transformedValue)
+      if (cachedStored.found) {
+        cacheTransformedValue()
+        return cachedStored.value
+      }
+
+      return adapter.toStored(transformedValue)
+    },
+  }
+}