mobx-keystone 1.22.0 → 1.24.0

package/src/ref/Ref.ts

@@ -1,10 +1,9 @@
-import { computed } from "mobx"
 import { Model } from "../model/Model"
 import { modelTypeKey } from "../model/metadata"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import { tProp } from "../types/tProp"
-import { failure } from "../utils"
+import { failure, mobxComputed } from "../utils"
 
 /**
  * A reference model base type.
@@ -21,7 +20,7 @@ export abstract class Ref<T extends object> extends Model({
   /**
    * The object this reference points to, or `undefined` if the reference is currently invalid.
    */
-  @computed
+  @mobxComputed
   get maybeCurrent(): T | undefined {
     return this.resolve()
   }
@@ -29,7 +28,7 @@ export abstract class Ref<T extends object> extends Model({
   /**
    * If the reference is currently valid.
    */
-  @computed
+  @mobxComputed
   get isValid(): boolean {
     return !!this.maybeCurrent
   }
@@ -37,7 +36,7 @@ export abstract class Ref<T extends object> extends Model({
   /**
    * The object this reference points to, or throws if invalid.
    */
-  @computed
+  @mobxComputed
   get current(): T {
     const current = this.maybeCurrent
 

package/src/ref/core.ts

@@ -9,7 +9,7 @@ import {
 import { fastGetRoot } from "../parent/path"
 import { type ComputedWalkTreeAggregate, computedWalkTreeAggregate } from "../parent/walkTree"
 import { assertTweakedObject } from "../tweaker/core"
-import { assertIsObject, failure } from "../utils"
+import { assertIsObject, failure, mobxAction } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import { Ref, type RefConstructor } from "./Ref"
 
@@ -103,7 +103,7 @@ export function internalCustomRef<T extends object>(
       return true
     }
 
-    @action
+    @mobxAction
     forceUpdateBackRefs() {
       const currentTarget = this.maybeCurrent
       if (!this.startTracking(currentTarget)) {

package/src/snapshot/fromArraySnapshot.ts

@@ -1,6 +1,6 @@
 import { tweakArray } from "../tweaker/tweakArray"
 import { isArray } from "../utils"
-import { withErrorPathSegment } from "../utils/errorDiagnostics"
+import { getCurrentErrorDiagnosticsContext } from "../utils/errorDiagnostics"
 import { type FromSnapshotContext, internalFromSnapshot, registerSnapshotter } from "./fromSnapshot"
 import type { SnapshotInOfObject } from "./SnapshotOf"
 import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
@@ -8,8 +8,17 @@ import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPrio
 function fromArraySnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): any[] {
   const ln = sn.length
   const arr: any[] = new Array(ln)
+  // Hydration visits every slot. Keep this direct stack use rather than
+  // withErrorPathSegment: it avoids one callback closure per item and has a
+  // measured production hydration win.
+  const errorDiagnosticsContext = getCurrentErrorDiagnosticsContext()
   for (let i = 0; i < ln; i++) {
-    arr[i] = withErrorPathSegment(i, () => internalFromSnapshot(sn[i], ctx))
+    errorDiagnosticsContext?.pushPath(i)
+    try {
+      arr[i] = internalFromSnapshot(sn[i], ctx)
+    } finally {
+      errorDiagnosticsContext?.popPath()
+    }
   }
   return tweakArray(arr, undefined, true)
 }

package/src/snapshot/fromModelSnapshot.ts

@@ -5,7 +5,7 @@ import { modelTypeKey } from "../model/metadata"
 import { getModelOrSnapshotTypeAndId, getSnapshotModelType } from "../model/utils"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"
-import { withErrorModelTrailEntry } from "../utils/errorDiagnostics"
+import { getCurrentErrorDiagnosticsContext } from "../utils/errorDiagnostics"
 import { type FromSnapshotContext, registerSnapshotter } from "./fromSnapshot"
 import type { SnapshotInOfModel } from "./SnapshotOf"
 import { SnapshotProcessingError } from "./SnapshotProcessingError"
@@ -40,7 +40,12 @@ function fromModelSnapshot(sn: SnapshotInOfModel<AnyModel>, ctx: FromSnapshotCon
   const modelTypeAndId = getModelOrSnapshotTypeAndId(sn)
   const modelId = modelTypeAndId?.modelId
 
-  return withErrorModelTrailEntry(type, modelId, () => {
+  // Hydration constructs every model. Keep this direct stack use rather than
+  // withErrorModelTrailEntry: it avoids one callback closure per model and
+  // has a measured production hydration win.
+  const errorDiagnosticsContext = getCurrentErrorDiagnosticsContext()
+  errorDiagnosticsContext?.pushModelTrail(type, modelId)
+  try {
     return new (modelInfo.class as any)(undefined, {
       snapshotInitialData: {
         unprocessedSnapshot: sn,
@@ -54,7 +59,9 @@ function fromModelSnapshot(sn: SnapshotInOfModel<AnyModel>, ctx: FromSnapshotCon
       },
       generateNewIds: ctx.options.generateNewIds,
     } satisfies ModelConstructorOptions)
-  })
+  } finally {
+    errorDiagnosticsContext?.popModelTrail()
+  }
 }
 
 /**

package/src/snapshot/fromPlainObjectSnapshot.ts

@@ -1,7 +1,7 @@
 import { observable } from "mobx"
 import { tweakPlainObject } from "../tweaker/tweakPlainObject"
-import { isPlainObject, setOwnProp } from "../utils"
-import { withErrorPathSegment } from "../utils/errorDiagnostics"
+import { isPlainObject, setProtoProp } from "../utils"
+import { getCurrentErrorDiagnosticsContext } from "../utils/errorDiagnostics"
 import {
   type FromSnapshotContext,
   internalFromSnapshot,
@@ -13,17 +13,28 @@ import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPrio
 
 function fromPlainObjectSnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): object {
   const plainObj: Record<string, unknown> = {}
+  // Hydration visits every property. Keep this direct stack use rather than
+  // withErrorPathSegment: it avoids one callback closure per property and has
+  // a measured production hydration win.
+  const errorDiagnosticsContext = getCurrentErrorDiagnosticsContext()
 
   const snKeys = Object.keys(sn)
   const snKeysLen = snKeys.length
   for (let i = 0; i < snKeysLen; i++) {
     const k = snKeys[i]
     const v = sn[k]
-    setOwnProp(
-      plainObj,
-      k,
-      withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
-    )
+    errorDiagnosticsContext?.pushPath(k)
+    let snapshotValue: unknown
+    try {
+      snapshotValue = internalFromSnapshot(v, ctx)
+    } finally {
+      errorDiagnosticsContext?.popPath()
+    }
+    if (k === "__proto__") {
+      setProtoProp(plainObj, snapshotValue)
+    } else {
+      plainObj[k] = snapshotValue
+    }
   }
   return tweakPlainObject(
     observable.object(plainObj, undefined, observableOptions),

package/src/snapshot/fromSnapshot.ts

@@ -5,8 +5,12 @@ import { resolveStandardTypeNoThrow, resolveTypeChecker } from "../types/resolve
 import type { AnyType, TypeToData, TypeToSnapshotIn } from "../types/schemas"
 import { isLateTypeChecker, TypeChecker } from "../types/TypeChecker"
 import { resolveCodecSupport } from "../types/utility/typesCodec"
-import { isMap, isPrimitive, isSet, setOwnProp } from "../utils"
-import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
+import { isMap, isPrimitive, isSet, setProtoProp } from "../utils"
+import {
+  getCurrentErrorDiagnosticsContext,
+  runWithErrorDiagnosticsContext,
+} from "../utils/errorDiagnostics"
+import { setModelInitialDataSnapshot } from "./modelInitialData"
 import { registerDefaultSnapshotters } from "./registerDefaultSnapshotters"
 import type { SnapshotInOf, SnapshotInOfModel, SnapshotOutOf } from "./SnapshotOf"
 import { SnapshotProcessingError } from "./SnapshotProcessingError"
@@ -87,9 +91,8 @@ export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
 
       if (codecSupport.hasCodec) {
         unprocessedSnapshot = arg2
-        snapshot = resolveTypeChecker(codecSupport.storedType).fromSnapshotProcessor(
-          unprocessedSnapshot
-        )
+        const processor = resolveTypeChecker(codecSupport.storedType).getFromSnapshotProcessor()
+        snapshot = processor ? processor(unprocessedSnapshot) : unprocessedSnapshot
         options = arg3
         const storedValue = fromSnapshotAction(snapshot, unprocessedSnapshot, options)
         return codecSupport.adapter.toRuntime(storedValue)
@@ -97,7 +100,8 @@ export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
 
       const typeChecker = resolveTypeChecker(resolvedType)
       unprocessedSnapshot = arg2
-      snapshot = typeChecker.fromSnapshotProcessor(unprocessedSnapshot)
+      const processor = typeChecker.getFromSnapshotProcessor()
+      snapshot = processor ? processor(unprocessedSnapshot) : unprocessedSnapshot
       options = arg3
     } else {
       snapshot = arg1
@@ -179,6 +183,11 @@ function snapshotToInitialData(
   processedSn: SnapshotInOfModel<AnyModel>
 ): any {
   const initialData: Record<string, unknown> = {}
+  let allValuesPrimitive = true
+  // Model hydration visits every data slot. Keep this direct stack use rather
+  // than withErrorPathSegment: it avoids one callback closure per slot and
+  // has a measured production hydration win.
+  const errorDiagnosticsContext = getCurrentErrorDiagnosticsContext()
 
   const processedSnKeys = Object.keys(processedSn)
   const processedSnKeysLen = processedSnKeys.length
@@ -186,11 +195,24 @@ function snapshotToInitialData(
     const k = processedSnKeys[i]
     if (!isReservedModelKey(k)) {
       const v = processedSn[k]
-      const snapshotValue = withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
-      setOwnProp(initialData, k, snapshotValue)
+      errorDiagnosticsContext?.pushPath(k)
+      let snapshotValue: unknown
+      try {
+        snapshotValue = internalFromSnapshot(v, ctx)
+      } finally {
+        errorDiagnosticsContext?.popPath()
+      }
+      allValuesPrimitive &&= isPrimitive(snapshotValue)
+      if (k === "__proto__") {
+        setProtoProp(initialData, snapshotValue)
+      } else {
+        initialData[k] = snapshotValue
+      }
     }
   }
-  return observable.object(initialData, undefined, observableOptions)
+  const observableInitialData = observable.object(initialData, undefined, observableOptions)
+  setModelInitialDataSnapshot(observableInitialData, initialData, allValuesPrimitive)
+  return observableInitialData
 }
 
 export const observableOptions = {

package/src/snapshot/getSnapshot.ts

@@ -5,6 +5,7 @@ import type { AnyType, TypeToData, TypeToSnapshotOut } from "../types/schemas"
 import { resolveCodecSupport } from "../types/utility/typesCodec"
 import { failure, identityFn, isPrimitive } from "../utils"
 import {
+  flushInternalSnapshot,
   freezeInternalSnapshot,
   getInternalSnapshot,
   reportInternalSnapshotObserved,
@@ -48,16 +49,19 @@ export function getSnapshot(...args: [arg1: any] | [arg1: any, arg2: any]): any
       const storedValue = codecSupport.adapter.toStored(arg2)
 
       if (isPrimitive(storedValue)) {
-        return storedTypeChecker.toSnapshotProcessor(storedValue)
+        const processor = storedTypeChecker.getToSnapshotProcessor()
+        return processor ? processor(storedValue) : storedValue
       }
 
       const storedTree = isTweakedObject(storedValue, true)
         ? storedValue
         : toTreeNode(codecSupport.storedType, storedValue)
-      return storedTypeChecker.toSnapshotProcessor(getSnapshot(storedTree))
+      const storedSnapshot = getSnapshot(storedTree)
+      const processor = storedTypeChecker.getToSnapshotProcessor()
+      return processor ? processor(storedSnapshot) : storedSnapshot
     }
 
-    toSnapshotProcessor = resolveTypeChecker(arg1).toSnapshotProcessor
+    toSnapshotProcessor = resolveTypeChecker(arg1).getToSnapshotProcessor() ?? identityFn
     nodeOrPrimitive = arg2
   } else {
     nodeOrPrimitive = arg1
@@ -74,6 +78,7 @@ export function getSnapshot(...args: [arg1: any] | [arg1: any, arg2: any]): any
     throw failure("getSnapshot is not supported for this kind of object")
   }
 
+  flushInternalSnapshot(nodeOrPrimitive, true)
   freezeInternalSnapshot(snapshot.transformed)
   reportInternalSnapshotObserved(snapshot)
   return toSnapshotProcessor(snapshot.transformed)