mobx-keystone 1.24.1 → 1.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -73,11 +73,11 @@
     "@babel/plugin-transform-class-static-block": "^8.0.1",
     "@babel/plugin-transform-typescript": "^8.0.1",
     "@babel/preset-env": "^8.0.2",
-    "@swc/core": "^1.16.0",
+    "@swc/core": "^1.16.2",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@typescript/typescript6": "^6.0.2",
-    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/coverage-v8": "^5.0.0",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
     "mobx-v6": "npm:mobx@^6.0.0",
@@ -87,9 +87,9 @@
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.20",
     "typescript": "^7.0.2",
-    "vite": "^8.2.1",
-    "vite-plugin-dts": "^5.0.3",
-    "vitest": "^4.1.10"
+    "vite": "^8.2.2",
+    "vite-plugin-dts": "^5.1.0",
+    "vitest": "^5.0.0"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/actionMiddlewares/undoMiddleware.ts

@@ -99,21 +99,16 @@ export interface UndoEventGroup {
 
 function toSingleEvents(
   event: UndoEventWithoutAttachedState,
-  reverse: boolean
-): ReadonlyArray<UndoSingleEvent> {
+  array: UndoSingleEvent[] = []
+): UndoSingleEvent[] {
   if (event.type === UndoEventType.Single) {
-    return [event]
+    array.push(event)
   } else {
-    const array: UndoSingleEvent[] = []
     for (const e of event.events) {
-      if (reverse) {
-        array.unshift(...toSingleEvents(e, true))
-      } else {
-        array.push(...toSingleEvents(e, false))
-      }
+      toSingleEvents(e, array)
     }
-    return array
   }
+  return array
 }
 
 /**
@@ -386,9 +381,11 @@ export class UndoManager {
     const event = this.undoQueue[this.undoQueue.length - 1]
 
     withoutUndo(() => {
-      toSingleEvents(event, true).forEach((e) => {
-        applyPatches(this.subtreeRoot, e.inversePatches, true)
-      })
+      toSingleEvents(event)
+        .reverse()
+        .forEach((e) => {
+          applyPatches(this.subtreeRoot, e.inversePatches, true)
+        })
 
       // restore the attached state before the operation was made
       if (event.attachedState?.beforeEvent) {
@@ -411,7 +408,7 @@ export class UndoManager {
     const event = this.redoQueue[this.redoQueue.length - 1]
 
     withoutUndo(() => {
-      toSingleEvents(event, false).forEach((e) => {
+      toSingleEvents(event).forEach((e) => {
         applyPatches(this.subtreeRoot, e.patches)
       })
 

package/src/model/BaseModel.ts

@@ -12,6 +12,7 @@ import type {
   ModelPropsToUntransformedData,
 } from "../modelShared/prop"
 import { getSnapshot } from "../snapshot/getSnapshot"
+import { setModelInitialDataSnapshot } from "../snapshot/modelInitialData"
 import type { SnapshotInOfModel, SnapshotOutOfModel } from "../snapshot/SnapshotOf"
 import { typesModel } from "../types/objectBased/typesModel"
 import type { TypeCheckError } from "../types/TypeCheckError"
@@ -146,11 +147,16 @@ export abstract class BaseModel<
       // plain new
       assertIsObject(initialData, "initialData")
 
-      internalNewModel(
-        this,
-        observable.object(initialData as any, undefined, { deep: false }),
-        modelClass!
-      )
+      // Empty input is filled by the constructor below. Track its primitive
+      // defaults directly instead of rereading observable fields for the snapshot.
+      const useInitialDataSnapshot = Reflect.ownKeys(initialData).length === 0
+      const observableInitialData = observable.object(initialData as any, undefined, {
+        deep: false,
+      })
+      if (useInitialDataSnapshot) {
+        setModelInitialDataSnapshot(observableInitialData, {})
+      }
+      internalNewModel(this, observableInitialData, modelClass!, useInitialDataSnapshot)
     }
   }
 

package/src/model/newModel.ts

@@ -19,7 +19,7 @@ import {
   hasGlobalPatchListeners,
 } from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
-import { invalidateModelInitialDataSnapshot } from "../snapshot/modelInitialData"
+import { updateModelInitialDataSnapshot } from "../snapshot/modelInitialData"
 import { tweakModel } from "../tweaker/tweakModel"
 import { tweakPlainObject } from "../tweaker/tweakPlainObject"
 import { failure, inDevMode, makePropReadonly } from "../utils"
@@ -38,7 +38,8 @@ export const internalNewModel = action(
   <M extends AnyModel>(
     origModelObj: M,
     initialData: ModelCreationData<M>,
-    modelClass: ModelClass<AnyModel>
+    modelClass: ModelClass<AnyModel>,
+    useInitialDataSnapshot: boolean
   ): void => {
     if (inDevMode) {
       assertIsModelClass(modelClass, "modelClass")
@@ -56,6 +57,9 @@ export const internalNewModel = action(
         id = (modelIdPropData._defaultFn as () => string)()
       }
       setIfDifferent(initialData, modelIdPropertyName, id)
+      if (useInitialDataSnapshot) {
+        updateModelInitialDataSnapshot(initialData, modelIdPropertyName, id)
+      }
     }
 
     const modelObj = origModelObj as O.Writable<M>
@@ -99,6 +103,9 @@ export const internalNewModel = action(
       if (changed) {
         // setIfDifferent not required
         set(initialData, k, newValue)
+        if (useInitialDataSnapshot) {
+          updateModelInitialDataSnapshot(initialData, k, newValue)
+        }
       }
     }
 
@@ -166,7 +173,7 @@ export const internalFromSnapshotModel = action(
       const valueChanged = setIfDifferentWithReturn(initialData, modelIdPropertyName, id)
 
       if (valueChanged) {
-        invalidateModelInitialDataSnapshot(initialData)
+        updateModelInitialDataSnapshot(initialData, modelIdPropertyName, id)
       }
 
       if (valueChanged && shouldEmitPatches) {
@@ -210,7 +217,7 @@ export const internalFromSnapshotModel = action(
       if (changed) {
         // setIfDifferent not required
         set(initialData, k, newValue)
-        invalidateModelInitialDataSnapshot(initialData)
+        updateModelInitialDataSnapshot(initialData, k, newValue)
 
         if (newValue !== initialValue) {
           if (shouldEmitPatches) {

package/src/parent/findParent.ts

@@ -19,8 +19,7 @@ export function findParent<T extends object = any>(
   predicate: (parentNode: object) => boolean,
   maxDepth = 0
 ): T | undefined {
-  const foundParentPath = findParentPath(child, predicate, maxDepth)
-  return foundParentPath ? foundParentPath.parent : undefined
+  return findParentInternal<T>(child, predicate, maxDepth)
 }
 
 /**
@@ -56,22 +55,28 @@ export function findParentPath<T extends object = any>(
   predicate: (parentNode: object) => boolean,
   maxDepth = 0
 ): FoundParentPath<T> | undefined {
-  assertTweakedObject(child, "child")
-
   const path: WritablePath = []
+  const parent = findParentInternal<T>(child, predicate, maxDepth, path)
+  return parent ? { parent, path: path.reverse() } : undefined
+}
+
+function findParentInternal<T extends object>(
+  child: object,
+  predicate: (parentNode: object) => boolean,
+  maxDepth: number,
+  path?: WritablePath
+): T | undefined {
+  assertTweakedObject(child, "child")
 
   let current: any = child
   let depth = 0
 
   let parentPath: ParentPath<any> | undefined
   while ((parentPath = fastGetParentPath(current, true))) {
-    path.unshift(parentPath.path)
+    path?.push(parentPath.path)
     current = parentPath.parent
     if (predicate(current)) {
-      return {
-        parent: current,
-        path,
-      }
+      return current
     }
 
     depth++

package/src/parent/onChildAttachedTo.ts

@@ -59,18 +59,7 @@ export function onChildAttachedTo(
     const t = target()
     assertTweakedObject(t, "target()")
 
-    const children = getChildrenObjects(t, getChildrenObjectOpts)
-
-    const set = new Set<object>()
-
-    const iter = children.values()
-    let cur = iter.next()
-    while (!cur.done) {
-      set.add(cur.value)
-      cur = iter.next()
-    }
-
-    return set
+    return new Set(getChildrenObjects(t, getChildrenObjectOpts))
   }
 
   const currentChildren = opts.fireForCurrentChildren ? new Set<object>() : getCurrentChildren()

package/src/parent/path.ts

@@ -175,10 +175,12 @@ export function fastGetRootPath<T extends object = any>(
   let parentPath: ParentPath<any> | undefined
   while ((parentPath = fastGetParentPath(root, useAtom))) {
     root = parentPath.parent
-    path.unshift(parentPath.path)
-    pathObjects.unshift(parentPath.parent)
+    path.push(parentPath.path)
+    pathObjects.push(parentPath.parent)
   }
 
+  path.reverse()
+  pathObjects.reverse()
   return { root, path, pathObjects } as RootPath<any>
 }
 
@@ -376,11 +378,11 @@ export function fastGetParentToChildPath(
   let current = toChild
   let parentPath: ParentPath<any> | undefined
   while ((parentPath = fastGetParentPath(current, useAtom))) {
-    path.unshift(parentPath.path)
+    path.push(parentPath.path)
 
     current = parentPath.parent
     if (current === fromParent) {
-      return path
+      return path.reverse()
     }
   }
   return undefined

package/src/parent/setParent.ts

@@ -19,6 +19,31 @@ import {
 import { addObjectChild, removeObjectChild } from "./coreObjectChildren"
 import { fastGetParentPath, fastGetRoot, type ParentPath } from "./path"
 
+/**
+ * Updates the unchanged tail of an array before a splice is applied. These
+ * children keep their parent, so neither attachment nor child-index work is
+ * needed. One action batches path notifications for the entire tail.
+ * @internal
+ */
+export const reindexArrayChildren = action(
+  "reindexArrayChildren",
+  (array: readonly unknown[], oldStart: number, newStart: number): void => {
+    for (let i = oldStart, j = newStart; i < array.length; i++, j++) {
+      const value = array[i]
+      if (isPrimitive(value)) {
+        continue
+      }
+      const metadata = treeNodeMetadata.get(value as object)
+      if (inDevMode && metadata?.parentPath?.parent !== array) {
+        throw failure("assertion failed: reindexed child must already belong to the array")
+      }
+      // Replace the path object: callers may have retained the previous path.
+      metadata!.parentPath = { parent: array, path: j }
+      reportParentPathChanged(value as object)
+    }
+  }
+)
+
 /**
  * @internal
  */
@@ -27,7 +52,6 @@ export const setParent = action(
   (
     value: any,
     parentPath: ParentPath<any> | undefined,
-    indexChangeAllowed: boolean,
     isDataObject: boolean,
     cloneIfApplicable: boolean
   ): any => {
@@ -36,11 +60,6 @@ export const setParent = action(
     }
 
     if (inDevMode) {
-      if (indexChangeAllowed && cloneIfApplicable) {
-        throw failure(
-          "assertion failed: 'indexChangeAllowed' and 'cloneIfApplicable' cannot be set at the same time"
-        )
-      }
       if (typeof value === "function" || typeof value === "symbol") {
         throw failure(`assertion failed: value cannot be a function or a symbol`)
       }
@@ -92,14 +111,7 @@ export const setParent = action(
     }
 
     if (oldParentPath && parentPath) {
-      if (oldParentPath.parent === parentPath.parent && indexChangeAllowed) {
-        // just changing the index
-        treeNodeMetadata.get(value)!.parentPath = parentPath
-        reportParentPathChanged(value)
-        return value
-      } else {
-        throw failure("an object cannot be assigned a new parent when it already has one")
-      }
+      throw failure("an object cannot be assigned a new parent when it already has one")
     }
 
     const postUntweaker = parentPath ? undefined : tryUntweak(value)

package/src/patch/applyPatches.ts

@@ -3,7 +3,6 @@ import { BuiltInAction } from "../action/builtInActions"
 import { ActionContextActionType } from "../action/context"
 import { wrapInAction } from "../action/wrapInAction"
 import { modelToDataNode } from "../parent/core"
-import type { PathElement } from "../parent/pathTypes"
 import type { Patch } from "../patch/Patch"
 import { reconcileSnapshot } from "../snapshot/reconcileSnapshot"
 import { assertTweakedObject } from "../tweaker/core"
@@ -84,7 +83,16 @@ const wrappedInternalApplyPatches = lazy(() =>
 )
 
 function applySinglePatch(obj: object, patch: Patch, modelPool: ModelPool): void {
-  const { target, prop } = pathArrayToObjectAndProp(obj, patch.path)
+  const path = patch.path
+  if (inDevMode && !isArray(path)) {
+    throw failure(`invalid path: ${path}`)
+  }
+
+  let target: any = modelToDataNode(obj)
+  for (let i = 0; i < path.length - 1; i++) {
+    target = modelToDataNode(target[path[i]])
+  }
+  const prop = path.length > 0 ? path[path.length - 1] : undefined
 
   if (isArray(target)) {
     switch (patch.op) {
@@ -157,31 +165,3 @@ function applySinglePatchWithPath(obj: object, patch: Patch, modelPool: ModelPoo
     applySinglePatch(obj, patch, modelPool)
   })
 }
-
-function pathArrayToObjectAndProp(
-  obj: object,
-  path: Patch["path"]
-): { target: any; prop?: PathElement } {
-  if (inDevMode) {
-    if (!isArray(path)) {
-      throw failure(`invalid path: ${path}`)
-    }
-  }
-
-  let target: any = modelToDataNode(obj)
-
-  if (path.length === 0) {
-    return {
-      target,
-    }
-  }
-
-  for (let i = 0; i <= path.length - 2; i++) {
-    target = modelToDataNode(target[path[i]])
-  }
-
-  return {
-    target,
-    prop: path[path.length - 1],
-  }
-}

package/src/snapshot/applySnapshot.ts

@@ -17,6 +17,7 @@ import { assertTweakedObject } from "../tweaker/core"
 import { assertIsObject, inDevMode, isArray, isMap, isPlainObject, isSet, lazy } from "../utils"
 import { runWithErrorDiagnosticsContext } from "../utils/errorDiagnostics"
 import { ModelPool } from "../utils/ModelPool"
+import { flushInternalSnapshot, getInternalSnapshot } from "./internal"
 import { reconcileSnapshot } from "./reconcileSnapshot"
 import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf"
 import { SnapshotProcessingError } from "./SnapshotProcessingError"
@@ -52,6 +53,14 @@ export function internalApplySnapshot<T extends object>(
   const obj = this
 
   const reconcile = () => {
+    // Avoid building a model pool (and its deep children traversal) when the
+    // node already holds this exact snapshot. Child updates may still await
+    // propagation within an action, so flush before trusting the reference.
+    flushInternalSnapshot(obj, false)
+    if (getInternalSnapshot(obj)?.transformed === sn) {
+      return
+    }
+
     const modelPool = new ModelPool(obj)
     const ret = reconcileSnapshot(obj, sn, modelPool, undefined)
 

package/src/snapshot/fromSnapshot.ts

@@ -211,7 +211,9 @@ function snapshotToInitialData(
     }
   }
   const observableInitialData = observable.object(initialData, undefined, observableOptions)
-  setModelInitialDataSnapshot(observableInitialData, initialData, allValuesPrimitive)
+  if (allValuesPrimitive) {
+    setModelInitialDataSnapshot(observableInitialData, initialData)
+  }
   return observableInitialData
 }
 

package/src/snapshot/modelInitialData.ts

@@ -1,40 +1,35 @@
-interface ModelInitialDataSnapshot {
-  readonly snapshot: Record<string, unknown>
-  readonly allValuesPrimitive: boolean
-  reusable: boolean
-}
+import { isPrimitive, setProtoProp } from "../utils"
 
-const modelInitialDataSnapshots = new WeakMap<object, ModelInitialDataSnapshot>()
+// Only primitive-only initial data can double as a snapshot without tweaking.
+const modelInitialDataSnapshots = new WeakMap<object, Record<string, unknown>>()
 
 /**
  * @internal
  */
-export function setModelInitialDataSnapshot(
-  data: object,
-  snapshot: Record<string, unknown>,
-  allValuesPrimitive: boolean
-): void {
-  modelInitialDataSnapshots.set(data, {
-    snapshot,
-    allValuesPrimitive,
-    reusable: true,
-  })
+export function setModelInitialDataSnapshot(data: object, snapshot: Record<string, unknown>): void {
+  modelInitialDataSnapshots.set(data, snapshot)
 }
 
 /**
  * @internal
  */
-export function invalidateModelInitialDataSnapshot(data: object): void {
+export function updateModelInitialDataSnapshot(data: object, key: string, value: unknown): void {
   const initialDataSnapshot = modelInitialDataSnapshots.get(data)
   if (initialDataSnapshot) {
-    initialDataSnapshot.reusable = false
+    if (!isPrimitive(value)) {
+      modelInitialDataSnapshots.delete(data)
+    } else if (key === "__proto__") {
+      setProtoProp(initialDataSnapshot, value)
+    } else {
+      initialDataSnapshot[key] = value
+    }
   }
 }
 
 /**
  * @internal
  */
-export function takeModelInitialDataSnapshot(data: object): ModelInitialDataSnapshot | undefined {
+export function takeModelInitialDataSnapshot(data: object): Record<string, unknown> | undefined {
   const initialDataSnapshot = modelInitialDataSnapshots.get(data)
   modelInitialDataSnapshots.delete(data)
   return initialDataSnapshot

package/src/snapshot/reconcileModelSnapshot.ts

@@ -1,4 +1,4 @@
-import { remove } from "mobx"
+import { remove, set } from "mobx"
 import type { AnyModel } from "../model/BaseModel"
 import { getModelIdPropertyName } from "../model/getModelMetadata"
 import { isReservedModelKey, modelIdKey, modelTypeKey } from "../model/metadata"
@@ -17,7 +17,7 @@ import {
   runTypeCheckingAfterChange,
 } from "../tweaker/typeChecking"
 import { withoutTypeChecking } from "../tweaker/withoutTypeChecking"
-import { isArray } from "../utils"
+import { isArray, isPrimitive } from "../utils"
 import { withErrorModelTrailEntry, withErrorPathSegment } from "../utils/errorDiagnostics"
 import type { ModelPool } from "../utils/ModelPool"
 import { setIfDifferent } from "../utils/setIfDifferent"
@@ -51,7 +51,7 @@ function reconcileModelSnapshot(
   // the canonical output snapshot. A successful canonical no-op therefore
   // cannot produce a diagnostic, so keep this hottest path outside the
   // model-trail bookkeeping and defer id metadata until needed. The
-  // positional value was already flushed by the getSnapshot call in
+  // positional value was already flushed by the internal snapshot read in
   // reconcileSnapshot, so its transformed snapshot is current.
   if (isCanonicalSnapshotNoOp(value, type, sn)) {
     return value
@@ -157,6 +157,14 @@ function reconcileModelSnapshot(
           const v = processedSn[k]
 
           const oldValue = data[k]
+          // Non-null primitives need neither reconciliation nor detachment.
+          // Nullish values must still pass through default handling below.
+          if (v != null && isPrimitive(v)) {
+            if (v !== oldValue) {
+              set(data, k, v)
+            }
+            continue
+          }
           let newValue = withErrorPathSegment(k, () =>
             reconcileSnapshot(oldValue, v, modelPool, modelObj)
           )

package/src/snapshot/reconcileSnapshot.ts

@@ -5,6 +5,7 @@ import { fastGetParentPathIncludingDataObjects } from "../parent"
 import { isMap, isPrimitive, isSet } from "../utils"
 import type { ModelPool } from "../utils/ModelPool"
 import { getSnapshot } from "./getSnapshot"
+import { flushInternalSnapshot, getInternalSnapshot } from "./internal"
 import { registerDefaultReconcilers } from "./registerDefaultReconcilers"
 import { SnapshotProcessingError } from "./SnapshotProcessingError"
 
@@ -28,10 +29,18 @@ export function reconcileSnapshot(value: any, sn: any, modelPool: ModelPool, par
     return sn
   }
 
-  // if the snapshot passed is exactly the same as the current one
-  // then it is already reconciled
-  if (getSnapshot(value) === sn) {
-    return value
+  // Unlike getSnapshot, this comparison never exposes the snapshot, so it needs
+  // neither freezing nor observation registration.
+  const currentSnapshot = getInternalSnapshot(value)
+  if (currentSnapshot) {
+    flushInternalSnapshot(value, false)
+    if (currentSnapshot.transformed === sn) {
+      return value
+    }
+  } else if (!isPrimitive(value)) {
+    // A non-primitive without an internal snapshot is not a valid reconciliation
+    // target (e.g. a non-node object); let getSnapshot raise the proper error.
+    getSnapshot(value)
   }
 
   registerDefaultReconcilers()

package/src/tweaker/tweak.ts

@@ -86,16 +86,11 @@ export function registerTweaker<T>(priority: number, tweaker: Tweaker<T>): void
 }
 
 function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T {
-  if (isPrimitive(value)) {
-    return value
-  }
-
   // already tweaked
   if (isTweakedObject(value, true)) {
     value = setParent(
       value,
       parentPath,
-      false, // indexChangeAllowed
       false, // isDataObject
       true // cloneIfApplicable
     )
@@ -135,10 +130,15 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
   )
 }
 
+const tweakNonPrimitive = action("tweak", internalTweak)
+
 /**
  * @internal
  */
-export const tweak = action("tweak", internalTweak)
+export function tweak<T>(value: T, parentPath: ParentPath<any> | undefined): T {
+  // Primitives need no tree bookkeeping or MobX action boundary.
+  return isPrimitive(value) ? value : tweakNonPrimitive(value, parentPath)
+}
 
 /**
  * @internal
@@ -169,7 +169,6 @@ export function tryUntweak(value: any): (() => void) | undefined {
     setParent(
       children[i], // value
       undefined, // parentPath
-      false, // indexChangeAllowed
       false, // isDataObject
       // no need to clone if unsetting the parent
       false // cloneIfApplicable

package/src/tweaker/tweakArray.ts

@@ -12,7 +12,7 @@ import { assertCanWrite } from "../action/protection"
 import { emitArraySpliceDeepChange, emitArrayUpdateDeepChange } from "../deepChange/onDeepChange"
 import { getGlobalConfig } from "../globalConfig"
 import type { ParentPath } from "../parent/path"
-import { setParent } from "../parent/setParent"
+import { reindexArrayChildren, setParent } from "../parent/setParent"
 import { hasPatchListenersFor, InternalPatchRecorder } from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
 import {
@@ -62,7 +62,6 @@ export function tweakArray<T extends any[]>(
   setParent(
     tweakedArr, // value
     parentPath,
-    false, // indexChangeAllowed
     false, // isDataObject
     // arrays shouldn't be cloned anyway
     false // cloneIfApplicable
@@ -97,7 +96,6 @@ export function tweakArray<T extends any[]>(
         setParent(
           tweakedValue, // value
           path, // parentPath
-          false, // indexChangeAllowed
           false, // isDataObject
           // the value is already a new value (the result of a fromSnapshot)
           false // cloneIfApplicable
@@ -482,20 +480,8 @@ function interceptArrayMutationSplice(change: IArrayWillSplice) {
   const oldNextIndex = change.index + change.removedCount
   const newNextIndex = change.index + change.added.length
 
-  if (oldNextIndex !== newNextIndex) {
-    for (let i = oldNextIndex, j = newNextIndex; i < change.object.length; i++, j++) {
-      setParent(
-        change.object[i], // value
-        {
-          parent: change.object,
-          path: j,
-        }, // parentPath
-        true, // indexChangeAllowed
-        false, // isDataObject
-        // just re-indexing
-        false // cloneIfApplicable
-      )
-    }
+  if (oldNextIndex !== newNextIndex && oldNextIndex < change.object.length) {
+    reindexArrayChildren(change.object, oldNextIndex, newNextIndex)
   }
 }
 

package/src/tweaker/tweakFrozen.ts

@@ -17,7 +17,6 @@ export function tweakFrozen<T extends Frozen<any>>(
   setParent(
     frozenObj, // value
     parentPath,
-    false, // indexChangeAllowed
     false, // isDataObject
     // a frozen is not a value-type
     false // cloneIfApplicable

package/src/tweaker/tweakModel.ts

@@ -13,7 +13,6 @@ export function tweakModel<T extends object>(value: T, parentPath: ParentPath<an
   setParent(
     value,
     parentPath,
-    false, // indexChangeAllowed
     false, // isDataObject
     true // cloneIfApplicable
   )