mobx-keystone 1.22.0 → 1.23.0

package/src/parent/coreObjectChildren.ts

@@ -1,13 +1,16 @@
 import { action, createAtom, type IAtom } from "mobx"
+import { addMutationBatchFinisher, isMutationBatchActive } from "../action/mutationBatch"
+import { getOrCreateTreeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { fastGetParent } from "./path"
 
 interface DeepObjectChildren {
   deep: Set<object>
 
-  extensionsData: Map<object, unknown>
+  extensionsData: Map<object, unknown> | undefined
 }
 
-interface ObjectChildrenData extends DeepObjectChildren {
+/** @internal */
+export interface ObjectChildrenData extends DeepObjectChildren {
   shallow: Set<object>
   shallowAtom: IAtom | undefined // will be created when first observed
 
@@ -15,10 +18,55 @@ interface ObjectChildrenData extends DeepObjectChildren {
   deepAtom: IAtom | undefined // will be created when first observed
 }
 
-const objectChildren = new WeakMap<object, ObjectChildrenData>()
+interface DeepChildrenInvalidationEntry {
+  readonly obj: ObjectChildrenData
+  rebuilt: boolean
+}
+
+interface DirectChildrenMutationEntry {
+  added: Set<object> | undefined
+  removed: Set<object> | undefined
+  invalidatedNodes: Set<object> | undefined
+}
+
+interface DeepChildrenMutationTransaction {
+  directMutations: Map<object, DirectChildrenMutationEntry> | undefined
+  invalidatedNodes: Map<object, DeepChildrenInvalidationEntry> | undefined
+}
+
+let currentDeepChildrenMutationTransaction: DeepChildrenMutationTransaction | undefined
+
+function getCurrentDeepChildrenMutationTransaction(): DeepChildrenMutationTransaction | undefined {
+  return currentDeepChildrenMutationTransaction
+}
+
+function getOrCreateDeepChildrenMutationTransaction(): DeepChildrenMutationTransaction | undefined {
+  if (!isMutationBatchActive()) {
+    return undefined
+  }
+
+  const currentTransaction = currentDeepChildrenMutationTransaction
+  if (currentTransaction) {
+    return currentTransaction
+  }
+
+  const transaction: DeepChildrenMutationTransaction = {
+    directMutations: undefined,
+    invalidatedNodes: undefined,
+  }
+  currentDeepChildrenMutationTransaction = transaction
+  addMutationBatchFinisher(() => {
+    if (currentDeepChildrenMutationTransaction === transaction) {
+      currentDeepChildrenMutationTransaction = undefined
+      finishDeepChildrenMutationTransaction(transaction)
+    }
+  })
+  return transaction
+}
 
 function getObjectChildrenObject(node: object) {
-  let obj = objectChildren.get(node)
+  const metadata = getOrCreateTreeNodeMetadata(node)
+  let obj = metadata.objectChildren
 
   if (!obj) {
     obj = {
@@ -31,7 +79,7 @@ function getObjectChildrenObject(node: object) {
 
       extensionsData: initExtensionsData(),
     }
-    objectChildren.set(node, obj)
+    metadata.objectChildren = obj
   }
 
   return obj
@@ -69,17 +117,36 @@ export function getDeepObjectChildren(node: object): DeepObjectChildren {
 
 function addNodeToDeepLists(node: any, data: DeepObjectChildren) {
   data.deep.add(node)
-  data.extensionsData.forEach((extensionData, dataSymbol) => {
+  data.extensionsData?.forEach((extensionData, dataSymbol) => {
     extensions.get(dataSymbol)!.addNode(node, extensionData)
   })
 }
 
 const updateDeepObjectChildren = action((node: object): DeepObjectChildren => {
+  return updateDeepObjectChildrenRecursive(node)
+})
+
+function updateDeepObjectChildrenRecursive(node: object): DeepObjectChildren {
   const obj = getObjectChildrenObject(node)
   if (!obj.deepDirty) {
     return obj
   }
 
+  const transaction = getCurrentDeepChildrenMutationTransaction()
+  if (transaction) {
+    const invalidatedNodes = (transaction.invalidatedNodes ??= new Map())
+    const invalidationEntry = invalidatedNodes.get(node)
+    if (invalidationEntry) {
+      invalidationEntry.rebuilt = true
+    } else {
+      // a node without an entry was dirty when first invalidated in this batch
+      // (or was dirtied before it); record the rebuild so a later net-zero
+      // completion cannot restore this mid-batch state as if the node had been
+      // clean since the batch started
+      invalidatedNodes.set(node, { obj, rebuilt: true })
+    }
+  }
+
   obj.deep = new Set()
   obj.extensionsData = initExtensionsData(obj.extensionsData)
 
@@ -88,7 +155,7 @@ const updateDeepObjectChildren = action((node: object): DeepObjectChildren => {
   while (!childrenIteratorResult.done) {
     addNodeToDeepLists(childrenIteratorResult.value, obj)
 
-    const childDeepChildren = updateDeepObjectChildren(childrenIteratorResult.value).deep
+    const childDeepChildren = updateDeepObjectChildrenRecursive(childrenIteratorResult.value).deep
     const childDeepChildrenIterator = childDeepChildren.values()
     let childDeepChildrenIteratorResult = childDeepChildrenIterator.next()
     while (!childDeepChildrenIteratorResult.done) {
@@ -103,35 +170,115 @@ const updateDeepObjectChildren = action((node: object): DeepObjectChildren => {
   obj.deepAtom?.reportChanged()
 
   return obj
-})
+}
 
 /**
+ * Must run inside the action-wrapped `setParent`, its only source caller.
+ *
  * @internal
  */
-export const addObjectChild = action((node: object, child: object) => {
+export function addObjectChild(node: object, child: object): void {
   const obj = getObjectChildrenObject(node)
-  obj.shallow.add(child)
-  obj.shallowAtom?.reportChanged()
+  const shallow = obj.shallow
+  const previousShallowSize = shallow.size
+  shallow.add(child)
+  if (shallow.size === previousShallowSize) {
+    return
+  }
 
-  invalidateDeepChildren(node, obj)
-})
+  onShallowChildrenChanged(node, obj, child, true)
+}
 
 /**
+ * Must run inside the action-wrapped `setParent`, its only source caller.
+ *
  * @internal
  */
-export const removeObjectChild = action((node: object, child: object) => {
+export function removeObjectChild(node: object, child: object): void {
   const obj = getObjectChildrenObject(node)
-  obj.shallow.delete(child)
+  if (!obj.shallow.delete(child)) {
+    return
+  }
+
+  onShallowChildrenChanged(node, obj, child, false)
+}
+
+function onShallowChildrenChanged(
+  node: object,
+  obj: ObjectChildrenData,
+  child: object,
+  added: boolean
+) {
   obj.shallowAtom?.reportChanged()
 
-  invalidateDeepChildren(node, obj)
-})
+  const transaction =
+    currentDeepChildrenMutationTransaction ??
+    (obj.deepDirty ? undefined : getOrCreateDeepChildrenMutationTransaction())
+  invalidateDeepChildren(
+    node,
+    obj,
+    transaction,
+    recordDirectChildrenMutation(transaction, node, child, added)
+  )
+}
+
+function recordDirectChildrenMutation(
+  transaction: DeepChildrenMutationTransaction | undefined,
+  node: object,
+  child: object,
+  added: boolean
+): DirectChildrenMutationEntry | undefined {
+  if (!transaction) {
+    return undefined
+  }
+
+  const directMutations = (transaction.directMutations ??= new Map())
+  let mutation = directMutations.get(node)
+  if (!mutation) {
+    mutation = {
+      added: undefined,
+      removed: undefined,
+      invalidatedNodes: undefined,
+    }
+    directMutations.set(node, mutation)
+  }
+
+  if (added) {
+    if (!mutation.removed?.delete(child)) {
+      ;(mutation.added ??= new Set()).add(child)
+    }
+  } else if (!mutation.added?.delete(child)) {
+    ;(mutation.removed ??= new Set()).add(child)
+  }
+
+  return mutation
+}
 
-function invalidateDeepChildren(node: object, obj: ObjectChildrenData) {
+function invalidateDeepChildren(
+  node: object,
+  obj: ObjectChildrenData,
+  transaction: DeepChildrenMutationTransaction | undefined,
+  mutation: DirectChildrenMutationEntry | undefined
+) {
   let currentNode: object | undefined = node
   let currentObj = obj
 
   while (currentNode) {
+    if (transaction) {
+      let entry = transaction.invalidatedNodes?.get(currentNode)
+      if (!entry && !currentObj.deepDirty) {
+        const invalidatedNodes = (transaction.invalidatedNodes ??= new Map())
+        entry = {
+          obj: currentObj,
+          rebuilt: false,
+        }
+        invalidatedNodes.set(currentNode, entry)
+      }
+      if (mutation && entry) {
+        ;(mutation.invalidatedNodes ??= new Set()).add(currentNode)
+      }
+    }
+
     currentObj.deepDirty = true
     currentObj.deepAtom?.reportChanged()
 
@@ -142,6 +289,51 @@ function invalidateDeepChildren(node: object, obj: ObjectChildrenData) {
   }
 }
 
+function finishDeepChildrenMutationTransaction(transaction: DeepChildrenMutationTransaction) {
+  const invalidatedNodes = transaction.invalidatedNodes
+  if (!invalidatedNodes) {
+    return
+  }
+
+  // when every mutated parent has net membership changes every invalidated
+  // node must stay dirty, so there is nothing to restore
+  let hasNetZeroMutation = false
+  transaction.directMutations?.forEach((mutation) => {
+    if ((mutation.added?.size ?? 0) === 0 && (mutation.removed?.size ?? 0) === 0) {
+      hasNetZeroMutation = true
+    }
+  })
+  if (!hasNetZeroMutation) {
+    return
+  }
+
+  let genuinelyChangedNodes: Set<object> | undefined
+  transaction.directMutations?.forEach((mutation, node) => {
+    if ((mutation.added?.size ?? 0) > 0 || (mutation.removed?.size ?? 0) > 0) {
+      const changedNodes = (genuinelyChangedNodes ??= new Set())
+      mutation.invalidatedNodes?.forEach((invalidatedNode) => {
+        changedNodes.add(invalidatedNode)
+      })
+
+      // a genuine membership change also dirties the node's ancestor chain as
+      // it stands now, which may differ from the chains recorded at mutation
+      // time (e.g. a subtree mutated while detached and then re-attached with
+      // a net-zero remove/add pair at its parent)
+      let currentNode: object | undefined = node
+      while (currentNode) {
+        changedNodes.add(currentNode)
+        currentNode = fastGetParent(currentNode, false)
+      }
+    }
+  })
+
+  invalidatedNodes.forEach((entry, node) => {
+    if (!genuinelyChangedNodes?.has(node) && !entry.rebuilt) {
+      entry.obj.deepDirty = false
+    }
+  })
+}
+
 const extensions = new Map<object, DeepObjectChildrenExtension<any>>()
 
 interface DeepObjectChildrenExtension<D> {
@@ -157,10 +349,12 @@ export function registerDeepObjectChildrenExtension<D>(extension: DeepObjectChil
   extensions.set(dataSymbol, extension)
 
   return (data: DeepObjectChildren): D => {
-    let extensionData = data.extensionsData.get(dataSymbol) as D | undefined
-    if (!data.extensionsData.has(dataSymbol)) {
+    let extensionsData = data.extensionsData
+    let extensionData = extensionsData?.get(dataSymbol) as D | undefined
+    if (!extensionsData?.has(dataSymbol)) {
+      extensionsData = data.extensionsData ??= new Map()
       extensionData = extension.initData()
-      data.extensionsData.set(dataSymbol, extensionData)
+      extensionsData.set(dataSymbol, extensionData)
       data.deep.forEach((node) => {
         extension.addNode(node, extensionData!)
       })
@@ -170,6 +364,10 @@ export function registerDeepObjectChildrenExtension<D>(extension: DeepObjectChil
 }
 
 function initExtensionsData(previousData?: ReadonlyMap<object, unknown>) {
+  if (previousData === undefined || previousData.size === 0) {
+    return undefined
+  }
+
   const extensionsData = new Map<object, unknown>()
 
   previousData?.forEach((_, dataSymbol) => {

package/src/parent/path.ts

@@ -1,12 +1,13 @@
 import { modelIdKey } from "../model/metadata"
 import { isModel } from "../model/utils"
 import { assertTweakedObject } from "../tweaker/core"
+import { treeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { hasOwnProp, isArray, isObject } from "../utils"
 import {
-  dataObjectParent,
   dataToModelNode,
+  getDataObjectParent,
+  hasDataObjectParent,
   modelToDataNode,
-  objectParents,
   reportParentPathObserved,
 } from "./core"
 import type { Path, PathElement, WritablePath } from "./pathTypes"
@@ -73,7 +74,7 @@ export function fastGetParentPath<T extends object = any>(
   if (useAtom) {
     reportParentPathObserved(value)
   }
-  return objectParents.get(value) as ParentPath<T> | undefined
+  return treeNodeMetadata.get(value)?.parentPath as ParentPath<T> | undefined
 }
 
 /**
@@ -83,7 +84,7 @@ export function fastGetParentPathIncludingDataObjects<T extends object = any>(
   value: object,
   useAtom: boolean
 ): ParentPath<T> | undefined {
-  const parentModel = dataObjectParent.get(value)
+  const parentModel = getDataObjectParent(value)
   if (parentModel) {
     return { parent: parentModel as T, path: "$" }
   }
@@ -144,7 +145,7 @@ export function isModelDataObject(value: object): boolean {
  * @internal
  */
 export function fastIsModelDataObject(value: object): boolean {
-  return dataObjectParent.has(value)
+  return hasDataObjectParent(value)
 }
 
 /**

package/src/parent/setParent.ts

@@ -7,14 +7,14 @@ import { attachToRootStore, detachFromRootStore } from "../rootStore/attachDetac
 import { fastIsRootStoreNoAtom } from "../rootStore/rootStore"
 import { clone } from "../snapshot/clone"
 import { isTweakedObject } from "../tweaker/core"
+import { treeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { tryUntweak } from "../tweaker/tweak"
 import { failure, inDevMode, isPrimitive } from "../utils"
 import {
-  dataObjectParent,
   dataToModelNode,
-  objectParents,
   parentPathEquals,
   reportParentPathChanged,
+  setDataObjectParent,
 } from "./core"
 import { addObjectChild, removeObjectChild } from "./coreObjectChildren"
 import { fastGetParentPath, fastGetRoot, type ParentPath } from "./path"
@@ -62,7 +62,7 @@ export const setParent = action(
     }
 
     if (isDataObject) {
-      dataObjectParent.set(value, parentPath!.parent)
+      setDataObjectParent(value, parentPath!.parent)
       // data object will proxy to use the actual parent model for child/parent stuff
       return value
     }
@@ -94,7 +94,7 @@ export const setParent = action(
     if (oldParentPath && parentPath) {
       if (oldParentPath.parent === parentPath.parent && indexChangeAllowed) {
         // just changing the index
-        objectParents.set(value, parentPath)
+        treeNodeMetadata.get(value)!.parentPath = parentPath
         reportParentPathChanged(value)
         return value
       } else {
@@ -119,7 +119,7 @@ export const setParent = action(
     }
 
     // attach to new
-    objectParents.set(value, parentPath)
+    treeNodeMetadata.get(value)!.parentPath = parentPath
     if (parentPath?.parent) {
       addObjectChild(parentPath.parent, value)
     }

package/src/patch/emitPatch.ts

@@ -1,5 +1,6 @@
 import { action, isAction } from "mobx"
-import { fastGetParentPath } from "../parent/path"
+import { dataToModelNode } from "../parent/core"
+import { fastGetParentPath, type ParentPath } from "../parent/path"
 import type { PathElement } from "../parent/pathTypes"
 import { freezeInternalSnapshot, getInternalSnapshot } from "../snapshot/internal"
 import { assertTweakedObject } from "../tweaker/core"
@@ -14,19 +15,27 @@ const emptyPatchArray: Patch[] = []
 export class InternalPatchRecorder {
   patches: Patch[] = emptyPatchArray
   invPatches: Patch[] = emptyPatchArray
+  hasChanges = false
 
   reset() {
     this.patches = emptyPatchArray
     this.invPatches = emptyPatchArray
+    this.hasChanges = false
   }
 
-  record(patches: Patch[], invPatches: Patch[]) {
-    this.patches = patches
-    this.invPatches = invPatches
+  record(patches: Patch[] | undefined, invPatches: Patch[] | undefined) {
+    this.patches = patches ?? emptyPatchArray
+    this.invPatches = invPatches ?? emptyPatchArray
+    // An effective change requires at least one forward or inverse patch. A no-op
+    // mutation (e.g. an equal-count splice where every value is identical) records
+    // empty arrays and must not trigger ancestor type checking.
+    this.hasChanges = this.patches.length > 0 || this.invPatches.length > 0
   }
 
   emit(obj: object) {
-    emitPatches(obj, this.patches, this.invPatches)
+    if (this.patches.length > 0) {
+      emitPatches(obj, this.patches, this.invPatches)
+    }
     this.reset()
   }
 }
@@ -35,9 +44,11 @@ export class InternalPatchRecorder {
  * @internal
  */
 export function emitPatches(obj: object, patches: Patch[], invPatches: Patch[]): void {
-  if (patches.length > 0 || invPatches.length > 0) {
+  if (patches.length > 0) {
     emitGlobalPatch(obj, patches, invPatches)
-    emitPatch(obj, patches, invPatches)
+    if (patchListenerCount > 0) {
+      emitPatch(obj, patches, invPatches)
+    }
   }
 }
 
@@ -62,6 +73,37 @@ export type OnPatchesDisposer = () => void
 
 const patchListeners = new WeakMap<object, OnPatchesListener[]>()
 const globalPatchListeners: OnGlobalPatchesListener[] = []
+let patchListenerCount = 0
+
+/**
+ * @internal
+ */
+export function hasGlobalPatchListeners(): boolean {
+  return globalPatchListeners.length > 0
+}
+
+/**
+ * @internal
+ */
+export function hasPatchListenersFor(target: object): boolean {
+  if (hasGlobalPatchListeners()) {
+    return true
+  }
+  if (patchListenerCount === 0) {
+    return false
+  }
+
+  let current: object | undefined = dataToModelNode(target)
+  while (current) {
+    if ((patchListeners.get(current)?.length ?? 0) > 0) {
+      return true
+    }
+
+    const parentPath: ParentPath<object> | undefined = fastGetParentPath(current, false)
+    current = parentPath?.parent
+  }
+  return false
+}
 
 /**
  * Adds a listener that will be called every time a patch is generated for the tree of the given target object.
@@ -85,8 +127,11 @@ export function onPatches(subtreeRoot: object, listener: OnPatchesListener): OnP
   }
 
   listenersForObject.push(listener)
+  patchListenerCount++
   return () => {
-    deleteFromArray(listenersForObject, listener)
+    if (deleteFromArray(listenersForObject, listener)) {
+      patchListenerCount--
+    }
   }
 }
 
@@ -117,11 +162,16 @@ function emitGlobalPatch(obj: object, patches: Patch[], inversePatches: Patch[])
   }
 }
 
+// `reversedPrefix` holds the path segments from the changed node up to (but not
+// including) the current target, in child-to-root order. The prefix to prepend to
+// a patch is that slice reversed (root-to-child); `prefixCount` is how many of the
+// leading entries are relevant for the current target.
 function emitPatchForTarget(
   obj: object,
   patches: Patch[],
   inversePatches: Patch[],
-  pathPrefix: PathElement[]
+  reversedPrefix: readonly PathElement[],
+  prefixCount: number
 ): void {
   const listenersForObject = patchListeners.get(obj)
 
@@ -129,11 +179,10 @@ function emitPatchForTarget(
     return
   }
 
-  const fixPath = (patchesArray: Patch[]) =>
-    pathPrefix.length > 0 ? patchesArray.map((p) => addPathToPatch(p, pathPrefix)) : patchesArray
-
-  const patchesWithPathPrefix = fixPath(patches)
-  const invPatchesWithPathPrefix = fixPath(inversePatches)
+  const patchesWithPathPrefix =
+    prefixCount > 0 ? prefixPatches(patches, reversedPrefix, prefixCount) : patches
+  const invPatchesWithPathPrefix =
+    prefixCount > 0 ? prefixPatches(inversePatches, reversedPrefix, prefixCount) : inversePatches
 
   for (let i = 0; i < listenersForObject.length; i++) {
     const listener = listenersForObject[i]
@@ -142,24 +191,57 @@ function emitPatchForTarget(
 }
 
 function emitPatch(obj: object, patches: Patch[], inversePatches: Patch[]): void {
-  const pathPrefix: PathElement[] = []
+  // Segments are pushed in child-to-root order (O(1) each) rather than unshifted
+  // at the front (O(depth) each), keeping the whole walk O(depth) instead of
+  // O(depth^2) on deep trees.
+  const reversedPrefix: PathElement[] = []
 
-  emitPatchForTarget(obj, patches, inversePatches, pathPrefix)
+  emitPatchForTarget(obj, patches, inversePatches, reversedPrefix, 0)
 
   // and also emit subtree listeners all the way to the root
   let parentPath = fastGetParentPath(obj, false)
   while (parentPath) {
-    pathPrefix.unshift(parentPath.path)
-    emitPatchForTarget(parentPath.parent, patches, inversePatches, pathPrefix)
+    reversedPrefix.push(parentPath.path)
+    emitPatchForTarget(
+      parentPath.parent,
+      patches,
+      inversePatches,
+      reversedPrefix,
+      reversedPrefix.length
+    )
 
     parentPath = fastGetParentPath(parentPath.parent, false)
   }
 }
 
-function addPathToPatch(patch: Patch, pathPrefix: readonly PathElement[]): Patch {
+function prefixPatches(
+  patchesArray: Patch[],
+  reversedPrefix: readonly PathElement[],
+  prefixCount: number
+): Patch[] {
+  const result = new Array<Patch>(patchesArray.length)
+  for (let i = 0; i < patchesArray.length; i++) {
+    result[i] = addPathToPatch(patchesArray[i], reversedPrefix, prefixCount)
+  }
+  return result
+}
+
+function addPathToPatch(
+  patch: Patch,
+  reversedPrefix: readonly PathElement[],
+  prefixCount: number
+): Patch {
+  const patchPath = patch.path
+  const newPath = new Array<PathElement>(prefixCount + patchPath.length)
+  for (let i = 0; i < prefixCount; i++) {
+    newPath[i] = reversedPrefix[prefixCount - 1 - i]
+  }
+  for (let j = 0; j < patchPath.length; j++) {
+    newPath[prefixCount + j] = patchPath[j]
+  }
   return {
     ...patch,
-    path: [...pathPrefix, ...patch.path],
+    path: newPath,
   }
 }
 

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()
+  }
 }
 
 /**