mobx-keystone 1.22.0 → 1.23.0

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)

package/src/snapshot/internal.ts

@@ -1,7 +1,9 @@
 import { action, createAtom, type IAtom } from "mobx"
-import { fastGetParentPath, type ParentPath } from "../parent/path"
+import { fastGetParentPath } from "../parent/path"
+import type { PathElement } from "../parent/pathTypes"
+import { getOrCreateTreeNodeMetadata, treeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { invalidateCachedToSnapshotProcessorResult } from "../types/TypeChecker"
-import { clonePlainObject, isPrimitive, setOwnProp } from "../utils"
+import { clonePlainObject, failure, inDevMode, isPrimitive, setProtoProp } from "../utils"
 import type { PrimitiveValue } from "../utils/types"
 
 /**
@@ -9,18 +11,31 @@ import type { PrimitiveValue } from "../utils/types"
  */
 export type SnapshotTransformFn = (sn: unknown) => unknown
 
-interface SnapshotData {
+/** @internal */
+export interface SnapshotData {
   untransformed: any
   readonly transformFn: SnapshotTransformFn | undefined
   transformed: any
   atom: IAtom | undefined
+  // Source of truth for copy-on-write of this snapshot's untransformed data.
+  untransformedFrozen: boolean
+  dirtyChild: object | undefined
+  dirtyChildSnapshot: SnapshotData | undefined
+  dirtyChildPath: PathElement | undefined
+  additionalDirtyChildren: Map<object, DirtyChild> | undefined
+  isUnset: boolean
 }
 
-const snapshots = new WeakMap<object, SnapshotData>()
+interface DirtyChild {
+  readonly snapshot: SnapshotData
+  readonly path: PathElement
+}
 
-// true if it has been accessed publicly and therefore should be cloned
-// rather than modified in place
-const frozenState = new WeakMap<object, boolean>()
+// `false` means the generic freezer must traverse this raw value; `true` means
+// it is frozen; a SnapshotData value means it is mutable and its frozen state
+// must be reflected back into that owner. `undefined` is either external /
+// untracked data or a fused frozen clone, whose owner tracks its state directly.
+const snapshotStates = new WeakMap<object, boolean | SnapshotData>()
 
 /**
  * @internal
@@ -28,43 +43,33 @@ const frozenState = new WeakMap<object, boolean>()
 export function getInternalSnapshot<T extends object>(
   value: T
 ): Readonly<SnapshotData> | undefined {
-  return snapshots.get(value)
-}
-
-interface InternalSnapshotParent {
-  parentSnapshot: SnapshotData | undefined
-  parentPath: ParentPath<any>
-}
-
-function getInternalSnapshotParent(
-  sn: Readonly<SnapshotData> | undefined,
-  parentPath: ParentPath<any> | undefined
-): InternalSnapshotParent | undefined {
-  if (!(parentPath && sn)) {
-    return undefined
-  }
-
-  const parentSn = getInternalSnapshot(parentPath.parent)
-  if (!parentSn) {
-    return undefined
-  }
-
-  return {
-    parentSnapshot: parentSn,
-    parentPath: parentPath,
-  }
+  return treeNodeMetadata.get(value)?.snapshot
 }
 
 /**
  * @internal
  */
 export const unsetInternalSnapshot = action("unsetInternalSnapshot", (value: any) => {
-  const oldSn = getInternalSnapshot(value)
+  const metadata = treeNodeMetadata.get(value)
+  if (!metadata) {
+    return
+  }
+
+  const oldSn = metadata.snapshot
+  if (!oldSn) {
+    return
+  }
 
-  if (oldSn) {
-    snapshots.delete(value)
-    oldSn.atom?.reportChanged()
+  if (inDevMode && oldSn.dirtyChild !== undefined) {
+    throw failure("assertion failed: cannot unset an internal snapshot with dirty children")
   }
+  oldSn.isUnset = true
+  if (snapshotStates.get(oldSn.untransformed) === oldSn) {
+    // Preserve the former frozen-state tracking after dropping the owner.
+    snapshotStates.set(oldSn.untransformed, false)
+  }
+  metadata.snapshot = undefined
+  oldSn.atom?.reportChanged()
 })
 
 /**
@@ -85,15 +90,21 @@ export const setNewInternalSnapshot = action(
       transformFn,
       transformed,
       atom: undefined, // will be created when first observed
+      untransformedFrozen: markAsFrozen,
+      dirtyChild: undefined,
+      dirtyChildSnapshot: undefined,
+      dirtyChildPath: undefined,
+      additionalDirtyChildren: undefined,
+      isUnset: false,
     }
 
-    frozenState.set(untransformed, markAsFrozen)
+    snapshotStates.set(untransformed, markAsFrozen ? true : sn)
 
     if (transformed !== undefined && transformed !== untransformed) {
-      frozenState.set(transformed, markAsFrozen)
+      snapshotStates.set(transformed, markAsFrozen)
     }
 
-    snapshots.set(value, sn)
+    getOrCreateTreeNodeMetadata(value).snapshot = sn
 
     sn.atom?.reportChanged()
   }
@@ -101,61 +112,205 @@ export const setNewInternalSnapshot = action(
 
 type MutateInternalSnapshotFn<T> = (prevSn: T) => void
 
-function updateParentSnapshots(value: any, sn: SnapshotData): void {
-  // also update parent(s) snapshot(s) if needed
-  const parent = getInternalSnapshotParent(sn, fastGetParentPath(value, false))
-  if (!parent) {
-    return
+function makeSnapshotMutable(sn: SnapshotData): any {
+  let untransformed = sn.untransformed
+  if (sn.untransformedFrozen) {
+    untransformed = Array.isArray(untransformed)
+      ? untransformed.slice()
+      : clonePlainObject(untransformed)
+  } else {
+    invalidateCachedToSnapshotProcessorResult(untransformed)
+  }
+  return untransformed
+}
+
+function setSnapshotData(sn: SnapshotData, untransformed: any, freezeIfCloned = false): void {
+  // `makeSnapshotMutable` returns a new container exactly when this snapshot
+  // was frozen. All callers obtain `untransformed` through that helper.
+  const wasFrozen = untransformed !== sn.untransformed
+  const transformed = sn.transformFn ? sn.transformFn(untransformed) : untransformed
+
+  sn.untransformed = untransformed
+  sn.transformed = transformed
+
+  const keepFrozen = freezeIfCloned && wasFrozen && !sn.transformFn
+  sn.untransformedFrozen = keepFrozen
+  if (wasFrozen && !keepFrozen) {
+    snapshotStates.set(untransformed, sn)
+  }
+  if (
+    sn.transformFn &&
+    transformed !== undefined &&
+    (!wasFrozen || transformed !== untransformed)
+  ) {
+    snapshotStates.set(transformed, false)
+  }
+}
+
+function updateOwnSnapshot<T>(sn: SnapshotData, mutate: MutateInternalSnapshotFn<T>): void {
+  const untransformed = makeSnapshotMutable(sn)
+  mutate(untransformed)
+  setSnapshotData(sn, untransformed)
+  sn.atom?.reportChanged()
+}
+
+function updateParentSlot(parentSn: SnapshotData, path: PathElement, value: any): void {
+  const untransformed = makeSnapshotMutable(parentSn)
+  if (path === "__proto__") {
+    setProtoProp(untransformed, value)
+  } else {
+    untransformed[path] = value
   }
+  setSnapshotData(parentSn, untransformed)
+  parentSn.atom?.reportChanged()
+}
 
-  const { parentSnapshot, parentPath } = parent
-  // might be false in the cases where the parent has not yet been created
-  if (!parentSnapshot) {
+function flushDirtyChild(
+  node: object,
+  untransformed: any,
+  child: object,
+  childSn: SnapshotData,
+  childPath: PathElement,
+  freezeAfterFlush: boolean,
+  freezeClonedContainer: boolean
+): void {
+  if (childSn.isUnset) {
     return
   }
 
-  const path = parentPath.path
+  if (inDevMode) {
+    const currentParentPath = fastGetParentPath(child, false)
+    if (currentParentPath?.parent !== node || currentParentPath.path !== childPath) {
+      throw failure("assertion failed: dirty child parent path changed before flush")
+    }
+  }
+
+  const childIsFrozen = flushDirtyChildren(child, childSn, freezeAfterFlush)
+  if (freezeClonedContainer && !childIsFrozen) {
+    freezeInternalSnapshot(childSn.transformed)
+  }
+  // The overwhelmingly common snapshot path is a normal property or array
+  // index. Keep the `__proto__` safe-definition behavior for the exceptional
+  // key without paying its helper call on every observed ancestor flush.
+  if (childPath === "__proto__") {
+    setProtoProp(untransformed, childSn.transformed)
+  } else {
+    untransformed[childPath] = childSn.transformed
+  }
+}
+
+function flushDirtyChildren(node: object, sn: SnapshotData, freezeAfterFlush: boolean): boolean {
+  const dirtyChild = sn.dirtyChild
+  const dirtyChildSnapshot = sn.dirtyChildSnapshot
+  const dirtyChildPath = sn.dirtyChildPath
+  if (!dirtyChild || !dirtyChildSnapshot || dirtyChildPath === undefined) {
+    return false
+  }
 
-  // patches for parent changes should not be emitted
-  updateInternalSnapshot(parentPath.parent, (objOrArray: any) => {
-    setOwnProp(objOrArray, path, sn.transformed)
+  const additionalDirtyChildren = sn.additionalDirtyChildren
+  sn.dirtyChild = undefined
+  sn.dirtyChildSnapshot = undefined
+  sn.dirtyChildPath = undefined
+  sn.additionalDirtyChildren = undefined
+  const untransformed = makeSnapshotMutable(sn)
+  const freezeClonedContainer =
+    freezeAfterFlush && untransformed !== sn.untransformed && !sn.transformFn
+
+  flushDirtyChild(
+    node,
+    untransformed,
+    dirtyChild,
+    dirtyChildSnapshot,
+    dirtyChildPath,
+    freezeAfterFlush,
+    freezeClonedContainer
+  )
+  additionalDirtyChildren?.forEach((dirtyChild, child) => {
+    flushDirtyChild(
+      node,
+      untransformed,
+      child,
+      dirtyChild.snapshot,
+      dirtyChild.path,
+      freezeAfterFlush,
+      freezeClonedContainer
+    )
   })
+
+  setSnapshotData(sn, untransformed, freezeClonedContainer)
+  return freezeClonedContainer
 }
 
 /**
+ * Flushes any pending descendant snapshot updates for a node.
+ *
  * @internal
  */
-export const updateInternalSnapshot = action(
-  "updateInternalSnapshot",
-  <T extends object>(value: any, mutate: MutateInternalSnapshotFn<T>): void => {
-    const sn = getInternalSnapshot(value)! as SnapshotData
+export function flushInternalSnapshot(value: object, freezeAfterFlush: boolean): void {
+  const sn = treeNodeMetadata.get(value)?.snapshot
+  if (sn) {
+    flushDirtyChildren(value, sn, freezeAfterFlush)
+  }
+}
+
+function updateAncestorSnapshots(value: object, sn: SnapshotData): void {
+  let child = value
+  let childSn = sn
 
-    let untransformed = sn.untransformed
-    const snFrozen = frozenState.get(untransformed)!
-    if (snFrozen) {
-      if (Array.isArray(untransformed)) {
-        untransformed = untransformed.slice()
-      } else {
-        untransformed = clonePlainObject(untransformed)
-      }
-    } else {
-      // the processor cached result is no longer valid since we will
-      // mutate the object
-      invalidateCachedToSnapshotProcessorResult(untransformed)
+  while (true) {
+    const parentPath = fastGetParentPath(child, false)
+    if (!parentPath) {
+      return
     }
 
-    mutate(untransformed)
+    const parentSn = treeNodeMetadata.get(parentPath.parent)?.snapshot
+    if (!parentSn) {
+      return
+    }
 
-    sn.untransformed = untransformed
-    sn.transformed = sn.transformFn ? sn.transformFn(untransformed) : untransformed
+    if (parentSn.transformFn) {
+      // Model output snapshot processors are part of the public mutation
+      // contract. Keep their invocation eager, flushing any plain segment below
+      // this model before recomputing it.
+      flushDirtyChildren(child, childSn, false)
+      flushDirtyChildren(parentPath.parent, parentSn, false)
+      updateParentSlot(parentSn, parentPath.path, childSn.transformed)
+      child = parentPath.parent
+      childSn = parentSn
+      continue
+    }
 
-    frozenState.set(sn.untransformed, false)
-    if (sn.transformed !== undefined) {
-      frozenState.set(sn.transformed, false)
+    const wasDirty = parentSn.dirtyChild !== undefined
+    if (!wasDirty) {
+      parentSn.dirtyChild = child
+      parentSn.dirtyChildSnapshot = childSn
+      parentSn.dirtyChildPath = parentPath.path
+    } else if (parentSn.dirtyChild !== child) {
+      ;(parentSn.additionalDirtyChildren ??= new Map()).set(child, {
+        snapshot: childSn,
+        path: parentPath.path,
+      })
+    }
+    parentSn.atom?.reportChanged()
+    if (wasDirty) {
+      return
     }
 
-    sn.atom?.reportChanged()
-    updateParentSnapshots(value, sn)
+    child = parentPath.parent
+    childSn = parentSn
+  }
+}
+
+/**
+ * @internal
+ */
+export const updateInternalSnapshot = action(
+  "updateInternalSnapshot",
+  <T extends object>(value: any, mutate: MutateInternalSnapshotFn<T>): void => {
+    const sn = getInternalSnapshot(value)! as SnapshotData
+    flushDirtyChildren(value, sn, false)
+    updateOwnSnapshot(sn, mutate)
+    updateAncestorSnapshots(value, sn)
   }
 )
 
@@ -179,12 +334,12 @@ export const refreshInternalSnapshot = action("refreshInternalSnapshot", (value:
 
   // transformed snapshots created by internal transforms must be tracked as mutable
   // until they are exposed through getSnapshot / freezeInternalSnapshot.
-  if (frozenState.get(newTransformed) === undefined) {
-    frozenState.set(newTransformed, false)
+  if (snapshotStates.get(newTransformed) === undefined) {
+    snapshotStates.set(newTransformed, false)
   }
 
   sn.atom?.reportChanged()
-  updateParentSnapshots(value, sn)
+  updateAncestorSnapshots(value, sn)
 })
 
 /**
@@ -205,10 +360,12 @@ export function freezeInternalSnapshot<T extends PrimitiveValue | object>(data:
     return data
   }
 
-  // this might be undefined if the data comes from example from transforms
-  const isFrozen = frozenState.get(data)
+  // `undefined` means external/untracked data (for example, from a transform).
+  // For a tracked frozen value, all reachable tracked descendants were frozen
+  // first, so returning early here preserves snapshot immutability.
+  const state = snapshotStates.get(data)
 
-  if (isFrozen === undefined || isFrozen) {
+  if (state === undefined || state === true) {
     // already frozen or an external data (e.g. from a transform)
     return data
   }
@@ -224,7 +381,11 @@ export function freezeInternalSnapshot<T extends PrimitiveValue | object>(data:
     }
   }
 
-  frozenState.set(data, true)
+  snapshotStates.set(data, true)
+
+  if (typeof state === "object" && state.untransformed === data) {
+    state.untransformedFrozen = true
+  }
 
   return data
 }

package/src/snapshot/modelInitialData.ts

@@ -0,0 +1,41 @@
+interface ModelInitialDataSnapshot {
+  readonly snapshot: Record<string, unknown>
+  readonly allValuesPrimitive: boolean
+  reusable: boolean
+}
+
+const modelInitialDataSnapshots = new WeakMap<object, ModelInitialDataSnapshot>()
+
+/**
+ * @internal
+ */
+export function setModelInitialDataSnapshot(
+  data: object,
+  snapshot: Record<string, unknown>,
+  allValuesPrimitive: boolean
+): void {
+  modelInitialDataSnapshots.set(data, {
+    snapshot,
+    allValuesPrimitive,
+    reusable: true,
+  })
+}
+
+/**
+ * @internal
+ */
+export function invalidateModelInitialDataSnapshot(data: object): void {
+  const initialDataSnapshot = modelInitialDataSnapshots.get(data)
+  if (initialDataSnapshot) {
+    initialDataSnapshot.reusable = false
+  }
+}
+
+/**
+ * @internal
+ */
+export function takeModelInitialDataSnapshot(data: object): ModelInitialDataSnapshot | undefined {
+  const initialDataSnapshot = modelInitialDataSnapshots.get(data)
+  modelInitialDataSnapshots.delete(data)
+  return initialDataSnapshot
+}

package/src/snapshot/reconcileArraySnapshot.ts

@@ -1,4 +1,7 @@
-import { runTypeCheckingAfterChange } from "../tweaker/typeChecking"
+import {
+  isTypeCheckingAfterChangeEnabled,
+  runTypeCheckingAfterChange,
+} from "../tweaker/typeChecking"
 import { withoutTypeChecking } from "../tweaker/withoutTypeChecking"
 import { isArray } from "../utils"
 import { withErrorPathSegment } from "../utils/errorDiagnostics"
@@ -20,7 +23,8 @@ function reconcileArraySnapshot(
     return fromSnapshot(sn)
   }
 
-  const snapshotBeforeChanges = getSnapshot(value)
+  const typeCheckingAfterChangeEnabled = isTypeCheckingAfterChangeEnabled()
+  const snapshotBeforeChanges = typeCheckingAfterChangeEnabled ? getSnapshot(value) : undefined
 
   withoutTypeChecking(() => {
     // remove excess items
@@ -52,7 +56,9 @@ function reconcileArraySnapshot(
     }
   })
 
-  runTypeCheckingAfterChange(value, undefined, snapshotBeforeChanges)
+  if (typeCheckingAfterChangeEnabled) {
+    runTypeCheckingAfterChange(value, undefined, snapshotBeforeChanges)
+  }
 
   return value
 }