mobx-keystone 1.24.0 → 1.25.0

package/dist/types/modelShared/BaseModelShared.d.ts

@@ -2,7 +2,7 @@ import { AnyDataModel } from '../dataModel/BaseDataModel';
 import { AnyModel } from '../model/BaseModel';
 import { modelTypeKey } from '../model/metadata';
 import { Flatten, IsNeverType } from '../utils/types';
-import { ModelPropsToSnapshotCreationData, ModelPropsToSnapshotData, ModelPropsToTransformedCreationData, ModelPropsToTransformedData, ModelPropsToUntransformedCreationData } from './prop';
+import { ModelProps, ModelPropsToSnapshotCreationData, ModelPropsToSnapshotData, ModelPropsToTransformedCreationData, ModelPropsToTransformedData, ModelPropsToUntransformedCreationData } from './prop';
 /**
  * @ignore
  */
@@ -27,6 +27,12 @@ export interface ModelClass<M extends AnyModel | AnyDataModel> {
  * Extracts the instance type of an abstract model class.
  */
 export type AbstractModelClass<M extends AnyModel | AnyDataModel> = abstract new (initialData: any) => M;
+/**
+ * @ignore
+ */
+export interface ModelWithProps {
+    [propsTypeSymbol]: ModelProps;
+}
 /**
  * The props of a model.
  */

package/dist/types/modelShared/prop.d.ts

@@ -7,6 +7,11 @@ import { Flatten, IsNeverType, IsOptionalValue } from '../utils/types';
 export declare const noDefaultValue: unique symbol;
 type SetterMode = boolean | "assign";
 export type ModelPropSetterValueTransform<T> = (value: T) => T;
+/** @ignore */
+export interface FullModelPropTransform {
+    transform: (original: unknown, model: object, propName: PropertyKey, setOriginalValue: (newOriginalValue: unknown) => void) => unknown;
+    untransform: (transformed: unknown, model: object, propName: PropertyKey) => unknown;
+}
 /**
  * A model property.
  */

package/dist/types/types/TypeChecker.d.ts

@@ -1,4 +1,78 @@
+import { Path } from '../parent/pathTypes';
 import { AnyStandardType } from './schemas';
+import { TypeCheckError } from './TypeCheckError';
+type CheckFunction = (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null;
+/** @ignore */
+export type SnapshotProcessor = (snapshot: any) => unknown;
+/**
+ * A lazily discovered snapshot-processor node. Dependencies are deliberately
+ * TypeCheckers rather than processors so recursive graphs can be discovered
+ * before any processor body is compiled.
+ *
+ * @ignore
+ */
+export interface SnapshotProcessorPlan {
+    readonly intrinsic?: boolean;
+    readonly getDependencies: () => ReadonlyArray<TypeChecker>;
+    readonly compile: (dependencyProcessors: ReadonlyArray<SnapshotProcessor | undefined>) => SnapshotProcessor | undefined;
+}
+type SnapshotProcessorSource = SnapshotProcessor | SnapshotProcessorPlan | undefined;
+type SnapshotProcessorDirection = "from" | "to";
+/** @ignore */
+export declare class SnapshotProcessorPlanNode {
+    private readonly owner;
+    private readonly direction;
+    private readonly source;
+    private presence;
+    private dependencies;
+    private discovering;
+    private compiling;
+    private compiled;
+    private compiledProcessor;
+    private forwardingProcessor;
+    constructor(owner: TypeChecker | undefined, direction: SnapshotProcessorDirection, source: SnapshotProcessorSource);
+    resolve(): SnapshotProcessor | undefined;
+    private discover;
+    private compile;
+    private compileForDependency;
+}
+/**
+ * @ignore
+ */
+export declare enum TypeCheckerBaseType {
+    Object = "object",
+    Array = "array",
+    Primitive = "primitive",
+    Any = "any"
+}
+/**
+ * @ignore
+ */
+export declare class TypeChecker {
+    unchecked: boolean;
+    skipCheck: boolean;
+    readonly baseType: TypeCheckerBaseType;
+    private readonly _check;
+    readonly getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string;
+    readonly typeInfoGen: TypeInfoGen;
+    readonly snapshotType: (sn: unknown) => TypeChecker | null;
+    private readonly fromSnapshotProcessorSource;
+    private readonly toSnapshotProcessorSource;
+    private fromSnapshotProcessorPlanNode;
+    private toSnapshotProcessorPlanNode;
+    check(value: any, path: Path, typeCheckedValue: any): TypeCheckError | null;
+    private _cachedTypeInfoGen;
+    get typeInfo(): TypeInfo;
+    constructor(baseType: TypeCheckerBaseType, _check: CheckFunction | null, getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string, typeInfoGen: TypeInfoGen, snapshotType: (sn: unknown) => TypeChecker | null, fromSnapshotProcessor: SnapshotProcessorSource, toSnapshotProcessor: SnapshotProcessorSource);
+    getSnapshotProcessorPlanNode(direction: SnapshotProcessorDirection): SnapshotProcessorPlanNode;
+    private resolveSnapshotProcessor;
+    getFromSnapshotProcessor(): SnapshotProcessor | undefined;
+    getToSnapshotProcessor(): SnapshotProcessor | undefined;
+    fromSnapshotProcessor: (sn: any) => unknown;
+    private readonly _toSnapshotProcessorCache;
+    invalidateSnapshotProcessorCachedResult(obj: object): void;
+    toSnapshotProcessor: (sn: any) => unknown;
+}
 /**
  * Type info base class.
  */
@@ -7,3 +81,8 @@ export declare class TypeInfo {
     readonly thisType: AnyStandardType;
     constructor(thisType: AnyStandardType);
 }
+/**
+ * @ignore
+ */
+export type TypeInfoGen = (t: AnyStandardType) => TypeInfo;
+export {};

package/dist/types/types/schemas.d.ts

@@ -3,6 +3,7 @@ import { AnyDataModel } from '../dataModel/BaseDataModel';
 import { AnyModel } from '../model/BaseModel';
 import { ModelClass } from '../modelShared/BaseModelShared';
 import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
+import { IsOptionalValue } from '../utils/types';
 export interface Type<Name, Data> {
     /** @ignore */
     $$type: Name;
@@ -36,6 +37,20 @@ export interface ObjectOfTypes {
     /** @ignore */
     [k: string]: AnyType;
 }
+/**
+ * Name of the properties of an object that can be set to undefined, any or unknown.
+ * @ignore
+ */
+export type UndefinablePropsNames<T> = {
+    [K in keyof T]: IsOptionalValue<T[K], K, never>;
+}[keyof T];
+/**
+ * Computes the optional keys for an object type schema.
+ * @ignore
+ */
+export type ObjectOptionalKeys<S> = UndefinablePropsNames<{
+    [k in keyof S]: TypeToDataOpt<S[k]> extends infer R ? R : never;
+}>;
 type ObjectData<S> = O.Optional<{
     [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never;
 }, ObjectOptionalKeys<S>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "1.24.0",
+  "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",
@@ -54,7 +54,8 @@
     "quick-build": "tsc",
     "quick-build-tests": "tsc -p test",
     "copy-root-files": "shx cp ../../README.md . && shx cp ../../LICENSE . && shx cp ../../CHANGELOG.md .",
-    "build": "pnpm run quick-build && pnpm run copy-root-files && shx rm -rf dist && vite build && shx cp dist/mobx-keystone.esm.mjs dist/mobx-keystone.esm.js",
+    "build": "pnpm run quick-build && pnpm run copy-root-files && shx rm -rf dist && vite build && pnpm run check-declarations && shx cp dist/mobx-keystone.esm.mjs dist/mobx-keystone.esm.js",
+    "check-declarations": "tsc -p scripts/tsconfig.check-declarations.json",
     "test": "vitest run",
     "test:ci": "vitest run --coverage",
     "test:perf": "pnpm run build && pnpm run test:perf:run",
@@ -68,15 +69,15 @@
   "devDependencies": {
     "@babel/core": "^8.0.1",
     "@babel/plugin-proposal-decorators": "^8.0.2",
-    "@babel/plugin-transform-class-static-block": "^8.0.1",
     "@babel/plugin-transform-class-properties": "^8.0.1",
+    "@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.15.43",
+    "@swc/core": "^1.16.2",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^26.1.1",
+    "@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",
@@ -86,9 +87,9 @@
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.20",
     "typescript": "^7.0.2",
-    "vite": "^8.1.4",
-    "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/modelShared/BaseModelShared.ts

@@ -49,7 +49,7 @@ export type AbstractModelClass<M extends AnyModel | AnyDataModel> = abstract new
 ) => M
 
 /**
- * @internal
+ * @ignore
  */
 export interface ModelWithProps {
   [propsTypeSymbol]: ModelProps

package/src/modelShared/prop.ts

@@ -14,7 +14,7 @@ type SetterMode = boolean | "assign"
 
 export type ModelPropSetterValueTransform<T> = (value: T) => T
 
-/** @internal */
+/** @ignore */
 export interface FullModelPropTransform {
   transform: (
     original: unknown,

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