mobx-keystone 2.1.0 → 2.3.0

package/src/modelShared/prop.ts

@@ -3,7 +3,7 @@ import type { AnyStandardType } from "../types/schemas"
 import { isEqualOrBothNaN, lazy } from "../utils"
 import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
 import { getOrCreate } from "../utils/mapUtils"
-import type { Flatten, IsNeverType, IsOptionalValue } from "../utils/types"
+import type { IsNeverType, IsOptionalValue, SimplifyObject } from "../utils/types"
 
 /**
  * @ignore
@@ -71,50 +71,18 @@ export interface ModelProp<
    * Adds a setter to the property. The setter will be named `set${CapitalizedPropName}`
    * and will be available in the model instance.
    */
-  withSetter(): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    string,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  withSetter(): ModelPropWithSetter<this>
   /**
    * Adds a setter with a transform to the property. The setter will be named `set${CapitalizedPropName}`
    * and will be available in the model instance.
    */
   withSetter(
     valueTransform: ModelPropSetterValueTransform<TTransformedValue>
-  ): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    string,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  ): ModelPropWithSetter<this>
   /**
    * @deprecated Setter methods are preferred.
    */
-  withSetter(
-    mode: "assign"
-  ): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    string,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  withSetter(mode: "assign"): ModelPropWithSetter<this>
 
   /**
    * Sets a transform for the property instance value.
@@ -130,17 +98,7 @@ export interface ModelProp<
    */
   withTransform<TTV>(
     transform: ModelPropTransform<NonNullable<TPropValue>, TTV>
-  ): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTV | Extract<TPropValue, null | undefined>,
-    TTV | Extract<TPropCreationValue, null | undefined>,
-    TIsRequired,
-    TIsId,
-    THasSetter,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  ): ModelPropWithTransform<this, TTV>
 
   /**
    * Sets snapshot processors for this property.
@@ -158,18 +116,69 @@ export interface ModelProp<
   >(processor: {
     fromSnapshot?: (sn: FS) => ModelPropFromSnapshot<This>
     toSnapshot?: (sn: ModelPropToSnapshot<This>) => TS
-  }): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    THasSetter,
-    FS,
-    TS
-  >
+  }): ModelPropWithSnapshotProcessor<this, FS, TS>
+}
+
+type ModelPropStoredMetadataKey = "$storedValueType" | "$storedCreationValueType"
+
+// keeps the stored value metadata that `tProp` adds (e.g. the encoded type of a codec)
+// when a model prop is derived through one of its modifiers
+type ModelPropStoredMetadata<MP, K extends PropertyKey> = MP extends {
+  $storedValueType: unknown
 }
+  ? Pick<MP, Extract<keyof MP, K>>
+  : {}
+
+// the modifier result types are exported so emitted declaration files can reference them by name
+// instead of expanding them inline in every exported model class
+
+/**
+ * The model property returned by `withSetter`.
+ */
+export type ModelPropWithSetter<MP extends AnyModelProp> = ModelProp<
+  MP["$valueType"],
+  MP["$creationValueType"],
+  MP["$transformedValueType"],
+  MP["$transformedCreationValueType"],
+  MP["$isRequired"],
+  MP["$isId"],
+  string,
+  MP["$fromSnapshotOverride"],
+  MP["$toSnapshotOverride"]
+> &
+  ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey | "$typedFromSnapshotOverride">
+
+/**
+ * The model property returned by `withTransform`.
+ */
+export type ModelPropWithTransform<MP extends AnyModelProp, TTV> = ModelProp<
+  MP["$valueType"],
+  MP["$creationValueType"],
+  TTV | Extract<MP["$valueType"], null | undefined>,
+  TTV | Extract<MP["$creationValueType"], null | undefined>,
+  MP["$isRequired"],
+  MP["$isId"],
+  MP["$hasSetter"],
+  MP["$fromSnapshotOverride"],
+  MP["$toSnapshotOverride"]
+> &
+  ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey | "$typedFromSnapshotOverride">
+
+/**
+ * The model property returned by `withSnapshotProcessor`.
+ */
+export type ModelPropWithSnapshotProcessor<MP extends AnyModelProp, FS, TS> = ModelProp<
+  MP["$valueType"],
+  MP["$creationValueType"],
+  MP["$transformedValueType"],
+  MP["$transformedCreationValueType"],
+  MP["$isRequired"],
+  MP["$isId"],
+  MP["$hasSetter"],
+  FS,
+  TS
+> &
+  ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey>
 
 /**
  * The snapshot in type of a model property.
@@ -189,23 +198,19 @@ export type ModelPropToSnapshot<MP extends AnyModelProp> = IsNeverType<
   MP["$toSnapshotOverride"]
 >
 
-export type ModelPropStoredValue<MP extends AnyModelProp> = MP extends {
-  $storedValueType: infer TStoredValue
-}
-  ? TStoredValue
+export type ModelPropStoredValue<MP extends AnyModelProp> = "$storedValueType" extends keyof MP
+  ? MP["$storedValueType" & keyof MP]
   : MP["$valueType"]
 
-export type ModelPropStoredCreationValue<MP extends AnyModelProp> = MP extends {
-  $storedCreationValueType: infer TStoredCreationValue
-}
-  ? TStoredCreationValue
-  : MP["$creationValueType"]
+export type ModelPropStoredCreationValue<MP extends AnyModelProp> =
+  "$storedCreationValueType" extends keyof MP
+    ? MP["$storedCreationValueType" & keyof MP]
+    : MP["$creationValueType"]
 
-export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> = MP extends {
-  $typedFromSnapshotOverride: infer TFromSnapshotOverride
-}
-  ? TFromSnapshotOverride
-  : MP["$fromSnapshotOverride"]
+export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> =
+  "$typedFromSnapshotOverride" extends keyof MP
+    ? MP["$typedFromSnapshotOverride" & keyof MP]
+    : MP["$fromSnapshotOverride"]
 
 /**
  * A model prop transform.
@@ -245,13 +250,13 @@ export type RequiredModelProps<MP extends ModelProps> = {
   [K in keyof MP]: MP[K]["$isRequired"] & K
 }[keyof MP]
 
-export type ModelPropsToUntransformedData<MP extends ModelProps> = Flatten<{
+export type ModelPropsToUntransformedData<MP extends ModelProps> = {
   [k in keyof MP]: ModelPropStoredValue<MP[k]>
-}>
+} & {}
 
-export type ModelPropsToSnapshotData<MP extends ModelProps> = Flatten<{
+export type ModelPropsToSnapshotData<MP extends ModelProps> = {
   [k in keyof MP]: ModelPropToSnapshot<MP[k]> extends infer R ? R : never
-}>
+} & {}
 
 // we don't use O.Optional anymore since it generates unions too heavy
 // also if we use Pick over the optional props we will loose the ability to infer generics
@@ -264,23 +269,29 @@ export type ModelPropsToUntransformedCreationData<MP extends ModelProps> = {
 
 // we don't use O.Optional anymore since it generates unions too heavy
 // also if we use Pick over the optional props we will loose the ability to infer generics
-export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = Flatten<
+export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = SimplifyObject<
   {
     [k in keyof MP]?: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never
   } & {
-    [k in {
-      [K in keyof MP]: IsNeverType<
-        ModelPropFromSnapshotOverride<MP[K]>,
-        MP[K]["$isRequired"] & K, // no override
-        IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K> // with override
-      >
-    }[keyof MP]]: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never
+    [k in SnapshotCreationRequiredKeys<MP>]: ModelPropFromSnapshot<MP[k]> extends infer R
+      ? R
+      : never
   }
 >
 
-export type ModelPropsToTransformedData<MP extends ModelProps> = Flatten<{
+// without a snapshot processor a key is required when the prop is required,
+// with one when the processor input does not accept undefined
+type SnapshotCreationRequiredKeys<MP extends ModelProps> = {
+  [K in keyof MP]: IsNeverType<
+    ModelPropFromSnapshotOverride<MP[K]>,
+    MP[K]["$isRequired"] & K,
+    IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K>
+  >
+}[keyof MP]
+
+export type ModelPropsToTransformedData<MP extends ModelProps> = {
   [k in keyof MP]: MP[k]["$transformedValueType"]
-}>
+} & {}
 
 // we don't use O.Optional anymore since it generates unions too heavy
 // also if we use Pick over the optional props we will loose the ability to infer generics
@@ -292,11 +303,11 @@ export type ModelPropsToTransformedCreationData<MP extends ModelProps> = {
   [k in RequiredModelProps<MP>]: MP[k]["$transformedCreationValueType"]
 }
 
-export type ModelPropsToSetter<MP extends ModelProps> = Flatten<{
+export type ModelPropsToSetter<MP extends ModelProps> = {
   [k in keyof MP as MP[k]["$hasSetter"] & `set${Capitalize<k & string>}`]: (
     value: MP[k]["$transformedValueType"]
   ) => void
-}>
+} & {}
 
 export type ModelIdProp<T extends string = string> = ModelProp<
   T,
@@ -307,7 +318,12 @@ export type ModelIdProp<T extends string = string> = ModelProp<
   true
 >
 
-type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<
+// 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
+/**
+ * The type of `idProp`.
+ */
+export type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<
   ModelProp<T, T | undefined, T, T | undefined, never, true, THasSetter>,
   "withSetter"
 > & {
@@ -569,21 +585,17 @@ export function prop(...args: [] | [def: any]): AnyModelProp {
 
   const [def] = args
 
-  let p = propCache.get(def)
-
-  if (!p) {
-    p = Object.create(baseProp)
+  return getOrCreate(propCache, def, () => {
+    const p: AnyModelProp = Object.create(baseProp)
 
     if (typeof def === "function") {
-      p!._defaultFn = def
+      p._defaultFn = def
     } else {
-      p!._defaultValue = def
+      p._defaultValue = def
     }
 
-    propCache.set(def, p!)
-  }
-
-  return p!
+    return p
+  })
 }
 
 function parseSetterConfig(
@@ -599,19 +611,11 @@ function parseSetterConfig(
     }
   }
 
-  if (
-    modeOrValueTransform === undefined ||
-    typeof modeOrValueTransform === "boolean" ||
-    modeOrValueTransform === "assign"
-  ) {
-    return {
-      mode: modeOrValueTransform ?? true,
-      valueTransform: undefined,
-    }
-  }
-
   return {
-    mode: true,
+    mode:
+      typeof modeOrValueTransform === "boolean" || modeOrValueTransform === "assign"
+        ? modeOrValueTransform
+        : true,
     valueTransform: undefined,
   }
 }

package/src/modelShared/sharedInternalModel.ts

@@ -241,7 +241,7 @@ export function sharedInternalModel<
     const idPropGenerator = idProp._idGenerator
     const baseIdProp = baseModelProps?.[idKey]
     const baseIdPropGenerator = baseIdProp?._idGenerator
-    const isOverridingBaseIdProp = !!baseIdProp?._isId && Object.hasOwn(modelProps, idKey)
+    const isOverridingBaseIdProp = !!baseIdProp?._isId && hasOwnProp(modelProps, idKey)
     if (isOverridingBaseIdProp && baseIdPropGenerator !== idPropGenerator) {
       throw failure(
         `expected same idProp.withGenerator function when overriding a base idProp, but got different references`
@@ -315,7 +315,7 @@ export function sharedInternalModel<
     // make sure abstract classes do not override prototype props
     if (!propsToDeleteFromBase) {
       propsToDeleteFromBase = Object.keys(modelProps).filter(
-        (p) => !basePropNames.has(p as any) && Object.hasOwn(baseModel, p)
+        (p) => !basePropNames.has(p as any) && hasOwnProp(baseModel, p)
       )
     }
 

package/src/parent/arrayPaths.ts

@@ -235,8 +235,5 @@ export function getArrayPaths(
  * @internal
  */
 export function setLazyArrayParentPath(entry: LazyArrayParentPath, node: object): void {
-  const metadata = treeNodeMetadata.get(node)!
-  if (metadata.parentPath !== entry) {
-    metadata.parentPath = entry
-  }
+  treeNodeMetadata.get(node)!.parentPath = entry
 }

package/src/parent/path.ts

@@ -127,16 +127,6 @@ export function fastGetParent<T extends object = any>(
   return fastGetParentPath(value, useAtom)?.parent
 }
 
-/**
- * @internal
- */
-export function fastGetParentIncludingDataObjects<T extends object = any>(
-  value: object,
-  useAtom: boolean
-): T | undefined {
-  return fastGetParentPathIncludingDataObjects(value, useAtom)?.parent
-}
-
 /**
  * Returns if a given object is a model interim data object (`$`).
  *

package/src/patch/patchRecorder.ts

@@ -108,36 +108,21 @@ export function internalPatchRecorder(
     deep: false,
   })
 
-  let onPatchesDisposer: OnPatchesDisposer
-
-  if (subtreeRoot) {
-    onPatchesDisposer = internalOnPatches(
-      subtreeRoot,
-      (p, invP) => {
-        if (recording && filter(p, invP)) {
-          events.push({
-            target: subtreeRoot,
-            patches: p,
-            inversePatches: invP,
-          })
-          opts?.onPatches?.(p, invP)
-        }
-      },
-      true
-    )
-  } else {
-    onPatchesDisposer = internalOnGlobalPatches((target, p, invP) => {
-      if (recording && filter(p, invP)) {
-        events.push({
-          target,
-          patches: p,
-          inversePatches: invP,
-        })
-        opts?.onPatches?.(p, invP)
-      }
-    }, true)
+  const record = (target: object, p: Patch[], invP: Patch[]) => {
+    if (recording && filter(p, invP)) {
+      events.push({
+        target,
+        patches: p,
+        inversePatches: invP,
+      })
+      opts?.onPatches?.(p, invP)
+    }
   }
 
+  const onPatchesDisposer: OnPatchesDisposer = subtreeRoot
+    ? internalOnPatches(subtreeRoot, (p, invP) => record(subtreeRoot, p, invP), true)
+    : internalOnGlobalPatches(record, true)
+
   return {
     get recording() {
       return recording

package/src/ref/core.ts

@@ -220,29 +220,16 @@ export function resolveId<T extends object>(
   return resolveRefIdByIndex(root, id, getId) as T | undefined
 }
 
+const createRefSet = () => observable.set<Ref<any>>(undefined, { deep: false })
+
+const createBackRefs = (): BackRefs<any> => ({ all: createRefSet(), byType: new WeakMap() })
+
 function getBackRefs<T extends object>(
   target: T,
   refType?: RefConstructor<T>
 ): ObservableSet<Ref<T>> {
-  let backRefs = objectBackRefs.get(target) as BackRefs<T> | undefined
-  if (!backRefs) {
-    backRefs = {
-      all: observable.set(undefined, { deep: false }),
-      byType: new WeakMap(),
-    }
-    objectBackRefs.set(target, backRefs)
-  }
-
-  if (refType) {
-    let byType = backRefs.byType.get(refType)
-    if (!byType) {
-      byType = observable.set(undefined, { deep: false })
-      backRefs.byType.set(refType, byType)
-    }
-    return byType
-  } else {
-    return backRefs.all
-  }
+  const backRefs: BackRefs<T> = getOrCreate(objectBackRefs, target, createBackRefs)
+  return refType ? getOrCreate(backRefs.byType, refType, createRefSet) : backRefs.all
 }
 
 /**

package/src/rootStore/rootStore.ts

@@ -84,9 +84,7 @@ export function isRootStore(node: object): boolean {
   assertTweakedObject(node, "node")
 
   const entry = getOrCreateRootStoreEntry(node)
-  if (!entry.atom) {
-    entry.atom = createAtom("rootStore")
-  }
+  entry.atom ??= createAtom("rootStore")
   entry.atom.reportObserved()
   return entry.is
 }

package/src/snapshot/SnapshotOf.ts

@@ -13,10 +13,8 @@ export type FrozenData<D> = {
 
 // snapshot out
 
-// infer is there just to cache type generation
-
 export type SnapshotOutOfObject<T> = {
-  [k in keyof T]: SnapshotOutOf<T[k]> extends infer R ? R : never
+  [k in keyof T]: SnapshotOutOf<T[k]>
 }
 
 export type SnapshotOutOfModel<M extends AnyModel> = ModelToSnapshot<M>
@@ -35,33 +33,22 @@ export interface SnapshotOutOfArraySet<V> {
   [modelIdKey]: string
 }
 
-export type SnapshotOutOf<T> =
-  T extends ObjectMap<infer V>
-    ? SnapshotOutOfObjectMap<V> extends infer R
-      ? R
-      : never
-    : T extends ArraySet<infer V>
-      ? SnapshotOutOfArraySet<V> extends infer R
-        ? R
-        : never
-      : T extends AnyModel
-        ? SnapshotOutOfModel<T> extends infer R
-          ? R
-          : never
-        : T extends Frozen<any>
-          ? SnapshotOutOfFrozen<T> extends infer R
-            ? R
-            : never
-          : T extends object
-            ? SnapshotOutOfObject<T> extends infer R
-              ? R
-              : never
-            : T
+export type SnapshotOutOf<T> = T extends object
+  ? T extends AnyModel
+    ? T extends ObjectMap<infer V>
+      ? SnapshotOutOfObjectMap<V>
+      : T extends ArraySet<infer V>
+        ? SnapshotOutOfArraySet<V>
+        : SnapshotOutOfModel<T>
+    : T extends Frozen<any>
+      ? SnapshotOutOfFrozen<T>
+      : SnapshotOutOfObject<T>
+  : T
 
 // snapshot in
 
 export type SnapshotInOfObject<T> = {
-  [k in keyof T]: SnapshotInOf<T[k]> extends infer R ? R : never
+  [k in keyof T]: SnapshotInOf<T[k]>
 }
 
 export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>
@@ -80,25 +67,14 @@ export interface SnapshotInOfArraySet<V> {
   [modelIdKey]: string
 }
 
-export type SnapshotInOf<T> =
-  T extends ObjectMap<infer V>
-    ? SnapshotInOfObjectMap<V> extends infer R
-      ? R
-      : never
-    : T extends ArraySet<infer V>
-      ? SnapshotInOfArraySet<V> extends infer R
-        ? R
-        : never
-      : T extends AnyModel
-        ? SnapshotInOfModel<T> extends infer R
-          ? R
-          : never
-        : T extends Frozen<any>
-          ? SnapshotInOfFrozen<T> extends infer R
-            ? R
-            : never
-          : T extends object
-            ? SnapshotInOfObject<T> extends infer R
-              ? R
-              : never
-            : T
+export type SnapshotInOf<T> = T extends object
+  ? T extends AnyModel
+    ? T extends ObjectMap<infer V>
+      ? SnapshotInOfObjectMap<V>
+      : T extends ArraySet<infer V>
+        ? SnapshotInOfArraySet<V>
+        : SnapshotInOfModel<T>
+    : T extends Frozen<any>
+      ? SnapshotInOfFrozen<T>
+      : SnapshotInOfObject<T>
+  : T

package/src/snapshot/applySnapshot.ts

@@ -33,7 +33,7 @@ import { SnapshotProcessingError } from "./SnapshotProcessingError"
  */
 export function applySnapshot<T extends object>(
   node: T,
-  snapshot: SnapshotInOf<T> | SnapshotOutOf<T>
+  snapshot: NoInfer<SnapshotInOf<T> | SnapshotOutOf<T>>
 ): void
 
 export function applySnapshot(node: object, snapshot: unknown): void {

package/src/snapshot/fromSnapshot.ts

@@ -1,8 +1,9 @@
 import { action, observable } from "mobx"
 import type { AnyModel } from "../model/BaseModel"
 import { isReservedModelKey } from "../model/metadata"
+import { isTweakedObject } from "../tweaker/core"
 import { resolveStandardTypeNoThrow, resolveTypeChecker } from "../types/resolveTypeChecker"
-import type { AnyType, TypeToData, TypeToSnapshotIn } from "../types/schemas"
+import type { AnyType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from "../types/schemas"
 import { isLateTypeChecker, TypeChecker } from "../types/TypeChecker"
 import { resolveCodecSupport } from "../types/utility/typesCodec"
 import { isMap, isPrimitive, isSet, nodeObservableOptions, setProtoProp } from "../utils"
@@ -60,7 +61,7 @@ export interface FromSnapshotContext {
  */
 export function fromSnapshot<TType extends AnyType>(
   type: TType,
-  snapshot: TypeToSnapshotIn<TType>,
+  snapshot: NoInfer<TypeToSnapshotIn<TType> | TypeToSnapshotOut<TType>>,
   options?: Partial<FromSnapshotOptions>
 ): TypeToData<TType>
 
@@ -122,7 +123,6 @@ const fromSnapshotAction = action(
   ): T => {
     const opts = {
       generateNewIds: false,
-      overrideRootModelId: undefined,
       ...options,
     }
 
@@ -172,6 +172,13 @@ export function internalFromSnapshot<T>(
     })
   }
 
+  if (isTweakedObject(sn, true)) {
+    throw new SnapshotProcessingError({
+      message: "a snapshot must not contain tree nodes (use getSnapshot to get their snapshots)",
+      actualSnapshot: sn,
+    })
+  }
+
   throw new SnapshotProcessingError({
     message: "unsupported snapshot",
     actualSnapshot: sn,

package/src/snapshot/getSnapshot.ts

@@ -23,7 +23,7 @@ import type { SnapshotOutOf } from "./SnapshotOf"
  */
 export function getSnapshot<T extends AnyType>(
   type: T,
-  nodeOrPrimitive: TypeToData<T>
+  nodeOrPrimitive: NoInfer<TypeToData<T>>
 ): TypeToSnapshotOut<T>
 
 /**

package/src/snapshot/internal.ts

@@ -113,8 +113,6 @@ export const setNewInternalSnapshot = action(
     }
 
     getOrCreateTreeNodeMetadata(value).snapshot = sn
-
-    sn.atom?.reportChanged()
   }
 )
 

package/src/snapshot/reconcileModelSnapshot.ts

@@ -156,7 +156,9 @@ function reconcileModelSnapshot(
         if (!isReservedModelKey(k)) {
           const v = processedSn[k]
 
-          const oldValue = data[k]
+          // an inherited member such as `toString` is no old value (but `__proto__`
+          // still reads the prototype, which is rejected as it is no tree node)
+          const oldValue = k === "__proto__" || hasOwnProp(data, k) ? data[k] : undefined
           // Non-null primitives need neither reconciliation nor detachment.
           // Nullish values must still pass through default handling below.
           if (v != null && isPrimitive(v)) {
@@ -216,10 +218,10 @@ function snapshotSlotsAreEqual(
   for (let i = 0; i < currentKeys.length; i++) {
     const key = currentKeys[i]
     // a matching key at the same index proves the key is an own property of
-    // the incoming snapshot without an Object.hasOwn call; canonical snapshots
+    // the incoming snapshot without an own-property check; canonical snapshots
     // keep key order, so the fallback is rare (never trust inherited values,
     // e.g. a crafted __proto__ chain, without an own-property proof)
-    if (incomingKeys[i] !== key && !Object.hasOwn(incomingSnapshot, key)) {
+    if (incomingKeys[i] !== key && !hasOwnProp(incomingSnapshot, key)) {
       return false
     }
     if (currentSnapshot[key] !== incomingSnapshot[key]) {