mobx-keystone 1.25.0 → 2.1.0

package/src/snapshot/SnapshotOf.ts

@@ -69,13 +69,13 @@ export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>
 export interface SnapshotInOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {}
 
 export interface SnapshotInOfObjectMap<V> {
-  items?: { [k: string]: SnapshotOutOf<V> }
+  items?: { [k: string]: SnapshotInOf<V> }
   [modelTypeKey]?: string
   [modelIdKey]: string
 }
 
 export interface SnapshotInOfArraySet<V> {
-  items?: SnapshotOutOf<V>[]
+  items?: SnapshotInOf<V>[]
   [modelTypeKey]?: string
   [modelIdKey]: string
 }

package/src/snapshot/applySnapshot.ts

@@ -13,6 +13,7 @@ import {
   getModelNotRegisteredErrorMessage,
   modelInfoByClass,
 } from "../modelShared/modelInfo"
+import { withChangeBatch } from "../tweaker/changeRollback"
 import { assertTweakedObject } from "../tweaker/core"
 import { assertIsObject, inDevMode, isArray, isMap, isPlainObject, isSet, lazy } from "../utils"
 import { runWithErrorDiagnosticsContext } from "../utils/errorDiagnostics"
@@ -24,6 +25,7 @@ import { SnapshotProcessingError } from "./SnapshotProcessingError"
 
 /**
  * Applies a full snapshot over an object, reconciling it with the current contents of the object.
+ * If it throws, the changes it made are rolled back (errors thrown by listeners do not roll them back).
  *
  * @template T Object type.
  * @param node Target object (model object, object or array).
@@ -52,27 +54,33 @@ export function internalApplySnapshot<T extends object>(
 ): void {
   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 reconcile = () =>
+    withChangeBatch(() => {
+      // 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)
+      const modelPool = new ModelPool(obj)
+      let ret: unknown
+      try {
+        ret = reconcileSnapshot(obj, sn, modelPool, undefined)
+      } finally {
+        modelPool.release()
+      }
 
-    if (inDevMode) {
-      if (ret !== obj) {
-        throw new SnapshotProcessingError({
-          message: "assertion failed: reconciled object has to be the same",
-          actualSnapshot: sn,
-        })
+      if (inDevMode) {
+        if (ret !== obj) {
+          throw new SnapshotProcessingError({
+            message: "assertion failed: reconciled object has to be the same",
+            actualSnapshot: sn,
+          })
+        }
       }
-    }
-  }
+    })
 
   if (isArray(sn)) {
     if (!isArray(obj)) {
@@ -129,7 +137,7 @@ export function internalApplySnapshot<T extends object>(
     }
 
     const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-    if (modelIdPropertyName) {
+    if (modelIdPropertyName !== undefined) {
       const id = (sn as any)[modelIdPropertyName]
       if (obj[modelIdKey] !== id) {
         // different id, no reconciliation possible

package/src/snapshot/clone.ts

@@ -24,8 +24,7 @@ export function clone<T extends object>(node: T, options?: Partial<CloneOptions>
   assertTweakedObject(node, "node")
 
   const opts = {
-    generateNewIds: true,
-    ...options,
+    generateNewIds: options?.generateNewIds ?? true,
   }
 
   const sn = getSnapshot(node)

package/src/snapshot/cloneTreeValue.ts

@@ -10,8 +10,7 @@ import { fromSnapshot } from "./fromSnapshot"
  */
 export function cloneTreeValue<T>(value: T, options?: Partial<CloneOptions>): T {
   const cloneOptions: CloneOptions = {
-    generateNewIds: true,
-    ...options,
+    generateNewIds: options?.generateNewIds ?? true,
   }
 
   if (isPrimitive(value)) {

package/src/snapshot/fromModelSnapshot.ts

@@ -5,6 +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 { hasOwnProp } from "../utils"
 import { getCurrentErrorDiagnosticsContext } from "../utils/errorDiagnostics"
 import { type FromSnapshotContext, registerSnapshotter } from "./fromSnapshot"
 import type { SnapshotInOfModel } from "./SnapshotOf"
@@ -14,7 +15,7 @@ import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPrio
 function fromModelSnapshot(sn: SnapshotInOfModel<AnyModel>, ctx: FromSnapshotContext): AnyModel {
   const type = sn[modelTypeKey]
 
-  if (!type) {
+  if (type === undefined) {
     throw new SnapshotProcessingError({
       message: `a model snapshot must contain a type key (${modelTypeKey}), but none was found`,
       actualSnapshot: sn,
@@ -30,7 +31,10 @@ function fromModelSnapshot(sn: SnapshotInOfModel<AnyModel>, ctx: FromSnapshotCon
   }
 
   const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-  if (modelIdPropertyName && sn[modelIdPropertyName] === undefined) {
+  if (
+    modelIdPropertyName !== undefined &&
+    (!hasOwnProp(sn, modelIdPropertyName) || sn[modelIdPropertyName] === undefined)
+  ) {
     throw new SnapshotProcessingError({
       message: `a model snapshot of type '${type}' must contain an id key (${modelIdPropertyName}), but none was found`,
       actualSnapshot: sn,

package/src/snapshot/fromPlainObjectSnapshot.ts

@@ -1,13 +1,8 @@
 import { observable } from "mobx"
 import { tweakPlainObject } from "../tweaker/tweakPlainObject"
-import { isPlainObject, setProtoProp } from "../utils"
+import { isPlainObject, nodeObservableOptions, setProtoProp } from "../utils"
 import { getCurrentErrorDiagnosticsContext } from "../utils/errorDiagnostics"
-import {
-  type FromSnapshotContext,
-  internalFromSnapshot,
-  observableOptions,
-  registerSnapshotter,
-} from "./fromSnapshot"
+import { type FromSnapshotContext, internalFromSnapshot, registerSnapshotter } from "./fromSnapshot"
 import type { SnapshotInOfObject } from "./SnapshotOf"
 import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
 
@@ -37,7 +32,7 @@ function fromPlainObjectSnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotC
     }
   }
   return tweakPlainObject(
-    observable.object(plainObj, undefined, observableOptions),
+    observable.object(plainObj, undefined, nodeObservableOptions),
     undefined,
     undefined,
     true,

package/src/snapshot/fromSnapshot.ts

@@ -5,7 +5,7 @@ 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, setProtoProp } from "../utils"
+import { isMap, isPrimitive, isSet, nodeObservableOptions, setProtoProp } from "../utils"
 import {
   getCurrentErrorDiagnosticsContext,
   runWithErrorDiagnosticsContext,
@@ -210,13 +210,9 @@ function snapshotToInitialData(
       }
     }
   }
-  const observableInitialData = observable.object(initialData, undefined, observableOptions)
+  const observableInitialData = observable.object(initialData, undefined, nodeObservableOptions)
   if (allValuesPrimitive) {
     setModelInitialDataSnapshot(observableInitialData, initialData)
   }
   return observableInitialData
 }
-
-export const observableOptions = {
-  deep: false,
-}

package/src/snapshot/internal.ts

@@ -19,6 +19,10 @@ export interface SnapshotData {
   atom: IAtom | undefined
   // Source of truth for copy-on-write of this snapshot's untransformed data.
   untransformedFrozen: boolean
+  // When defined while `untransformed` is not frozen, every value in it except
+  // (possibly) these is already frozen, so freezing it only needs to visit them.
+  // Values listed here may no longer be in `untransformed`.
+  unfrozenValues: object[] | undefined
   dirtyChild: object | undefined
   dirtyChildSnapshot: SnapshotData | undefined
   dirtyChildPath: PathElement | undefined
@@ -31,10 +35,13 @@ interface DirtyChild {
   readonly path: PathElement
 }
 
-// `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.
+// `false` means the generic freezer must traverse this raw value; `true` means it
+// is frozen; a SnapshotData value means it is mutable and owned by that snapshot,
+// which is where its frozen state must be reflected back. Both the untransformed
+// and the transformed value of a snapshot point to their owner, so freezing can
+// reach descendants that are only shared through processor wrappers. `undefined`
+// is either external / untracked data or a fused frozen clone, whose owner tracks
+// its state directly.
 const snapshotStates = new WeakMap<object, boolean | SnapshotData>()
 
 /**
@@ -91,6 +98,7 @@ export const setNewInternalSnapshot = action(
       transformed,
       atom: undefined, // will be created when first observed
       untransformedFrozen: markAsFrozen,
+      unfrozenValues: undefined,
       dirtyChild: undefined,
       dirtyChildSnapshot: undefined,
       dirtyChildPath: undefined,
@@ -101,7 +109,7 @@ export const setNewInternalSnapshot = action(
     snapshotStates.set(untransformed, markAsFrozen ? true : sn)
 
     if (transformed !== undefined && transformed !== untransformed) {
-      snapshotStates.set(transformed, markAsFrozen)
+      snapshotStates.set(transformed, markAsFrozen ? true : sn)
     }
 
     getOrCreateTreeNodeMetadata(value).snapshot = sn
@@ -110,7 +118,10 @@ export const setNewInternalSnapshot = action(
   }
 )
 
-type MutateInternalSnapshotFn<T> = (prevSn: T) => void
+/**
+ * Mutates a snapshot container in place and returns the values it wrote.
+ */
+type MutateInternalSnapshotFn<T> = (prevSn: T) => readonly unknown[]
 
 function makeSnapshotMutable(sn: SnapshotData): any {
   let untransformed = sn.untransformed
@@ -124,7 +135,39 @@ function makeSnapshotMutable(sn: SnapshotData): any {
   return untransformed
 }
 
-function setSnapshotData(sn: SnapshotData, untransformed: any, freezeIfCloned = false): void {
+function trackUnfrozenValues(
+  sn: SnapshotData,
+  untransformed: any,
+  wasFrozen: boolean,
+  writtenValues: readonly unknown[]
+): void {
+  // a cloned frozen container starts with only frozen values
+  let unfrozenValues = wasFrozen ? [] : sn.unfrozenValues
+  if (unfrozenValues === undefined) {
+    return
+  }
+  for (let i = 0; i < writtenValues.length; i++) {
+    const value = writtenValues[i]
+    if (!isPrimitive(value)) {
+      unfrozenValues.push(value)
+    }
+  }
+  const size = Array.isArray(untransformed)
+    ? untransformed.length
+    : Object.keys(untransformed).length
+  if (unfrozenValues.length > size) {
+    // cheaper to visit the whole container again
+    unfrozenValues = undefined
+  }
+  sn.unfrozenValues = unfrozenValues
+}
+
+function setSnapshotData(
+  sn: SnapshotData,
+  untransformed: any,
+  writtenValues: readonly unknown[],
+  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
@@ -135,6 +178,11 @@ function setSnapshotData(sn: SnapshotData, untransformed: any, freezeIfCloned =
 
   const keepFrozen = freezeIfCloned && wasFrozen && !sn.transformFn
   sn.untransformedFrozen = keepFrozen
+  if (keepFrozen) {
+    sn.unfrozenValues = undefined
+  } else {
+    trackUnfrozenValues(sn, untransformed, wasFrozen, writtenValues)
+  }
   if (wasFrozen && !keepFrozen) {
     snapshotStates.set(untransformed, sn)
   }
@@ -143,14 +191,14 @@ function setSnapshotData(sn: SnapshotData, untransformed: any, freezeIfCloned =
     transformed !== undefined &&
     (!wasFrozen || transformed !== untransformed)
   ) {
-    snapshotStates.set(transformed, false)
+    snapshotStates.set(transformed, sn)
   }
 }
 
 function updateOwnSnapshot<T>(sn: SnapshotData, mutate: MutateInternalSnapshotFn<T>): void {
   const untransformed = makeSnapshotMutable(sn)
-  mutate(untransformed)
-  setSnapshotData(sn, untransformed)
+  const writtenValues = mutate(untransformed)
+  setSnapshotData(sn, untransformed, writtenValues)
   sn.atom?.reportChanged()
 }
 
@@ -161,7 +209,7 @@ function updateParentSlot(parentSn: SnapshotData, path: PathElement, value: any)
   } else {
     untransformed[path] = value
   }
-  setSnapshotData(parentSn, untransformed)
+  setSnapshotData(parentSn, untransformed, [value])
   parentSn.atom?.reportChanged()
 }
 
@@ -172,7 +220,8 @@ function flushDirtyChild(
   childSn: SnapshotData,
   childPath: PathElement,
   freezeAfterFlush: boolean,
-  freezeClonedContainer: boolean
+  freezeClonedContainer: boolean,
+  writtenValues: unknown[]
 ): void {
   if (childSn.isUnset) {
     return
@@ -197,6 +246,7 @@ function flushDirtyChild(
   } else {
     untransformed[childPath] = childSn.transformed
   }
+  writtenValues.push(childSn.transformed)
 }
 
 function flushDirtyChildren(node: object, sn: SnapshotData, freezeAfterFlush: boolean): boolean {
@@ -215,6 +265,7 @@ function flushDirtyChildren(node: object, sn: SnapshotData, freezeAfterFlush: bo
   const untransformed = makeSnapshotMutable(sn)
   const freezeClonedContainer =
     freezeAfterFlush && untransformed !== sn.untransformed && !sn.transformFn
+  const writtenValues: unknown[] = []
 
   flushDirtyChild(
     node,
@@ -223,7 +274,8 @@ function flushDirtyChildren(node: object, sn: SnapshotData, freezeAfterFlush: bo
     dirtyChildSnapshot,
     dirtyChildPath,
     freezeAfterFlush,
-    freezeClonedContainer
+    freezeClonedContainer,
+    writtenValues
   )
   additionalDirtyChildren?.forEach((dirtyChild, child) => {
     flushDirtyChild(
@@ -233,11 +285,12 @@ function flushDirtyChildren(node: object, sn: SnapshotData, freezeAfterFlush: bo
       dirtyChild.snapshot,
       dirtyChild.path,
       freezeAfterFlush,
-      freezeClonedContainer
+      freezeClonedContainer,
+      writtenValues
     )
   })
 
-  setSnapshotData(sn, untransformed, freezeClonedContainer)
+  setSnapshotData(sn, untransformed, writtenValues, freezeClonedContainer)
   return freezeClonedContainer
 }
 
@@ -335,7 +388,7 @@ 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 (snapshotStates.get(newTransformed) === undefined) {
-    snapshotStates.set(newTransformed, false)
+    snapshotStates.set(newTransformed, sn)
   }
 
   sn.atom?.reportChanged()
@@ -370,7 +423,23 @@ export function freezeInternalSnapshot<T extends PrimitiveValue | object>(data:
     return data
   }
 
-  if (Array.isArray(data)) {
+  const owner = state === false ? undefined : state
+
+  // Processors can create untracked wrappers around tracked descendants, and the
+  // freezer stops at those (their state is `undefined`). Freeze the source of the
+  // transformed value as well, so shared descendants that the transformed
+  // traversal cannot reach still switch to copy-on-write.
+  if (owner !== undefined && owner.untransformed !== data) {
+    freezeInternalSnapshot(owner.untransformed)
+  }
+
+  const unfrozenValues =
+    owner !== undefined && owner.untransformed === data ? owner.unfrozenValues : undefined
+  if (unfrozenValues !== undefined) {
+    for (let i = 0; i < unfrozenValues.length; i++) {
+      freezeInternalSnapshot(unfrozenValues[i])
+    }
+  } else if (Array.isArray(data)) {
     for (let i = 0; i < data.length; i++) {
       freezeInternalSnapshot(data[i])
     }
@@ -383,8 +452,9 @@ export function freezeInternalSnapshot<T extends PrimitiveValue | object>(data:
 
   snapshotStates.set(data, true)
 
-  if (typeof state === "object" && state.untransformed === data) {
-    state.untransformedFrozen = true
+  if (owner !== undefined && owner.untransformed === data) {
+    owner.untransformedFrozen = true
+    owner.unfrozenValues = undefined
   }
 
   return data

package/src/snapshot/onSnapshot.ts

@@ -31,9 +31,20 @@ export function onSnapshot<T extends object>(
   assertTweakedObject(node, "node")
 
   let currentSnapshot = getSnapshot(node)
+  let firstTrackingRun = true
 
   return reaction(
-    () => getSnapshot(nodeFn()),
+    () => {
+      const snapshot = getSnapshot(nodeFn())
+      // Registration inside an action defers the first tracking run until the
+      // action ends. Its snapshot, rather than the earlier registration state,
+      // is the baseline for the first notification.
+      if (firstTrackingRun) {
+        firstTrackingRun = false
+        currentSnapshot = snapshot
+      }
+      return snapshot
+    },
     (newSnapshot) => {
       const prevSn = currentSnapshot
       currentSnapshot = newSnapshot

package/src/snapshot/reconcileModelSnapshot.ts

@@ -17,7 +17,7 @@ import {
   runTypeCheckingAfterChange,
 } from "../tweaker/typeChecking"
 import { withoutTypeChecking } from "../tweaker/withoutTypeChecking"
-import { isArray, isPrimitive } from "../utils"
+import { hasOwnProp, isArray, isPrimitive } from "../utils"
 import { withErrorModelTrailEntry, withErrorPathSegment } from "../utils/errorDiagnostics"
 import type { ModelPool } from "../utils/ModelPool"
 import { setIfDifferent } from "../utils/setIfDifferent"
@@ -58,15 +58,15 @@ function reconcileModelSnapshot(
   }
 
   const modelIdPropertyName = getModelIdPropertyName(modelClass)
-  const incomingModelId = modelIdPropertyName ? sn[modelIdPropertyName] : undefined
+  const incomingModelId = modelIdPropertyName !== undefined ? sn[modelIdPropertyName] : undefined
   const positionalModelMatches =
     isModel(value) &&
     value[modelTypeKey] === type &&
-    (!modelIdPropertyName || value[modelIdKey] === incomingModelId)
+    (modelIdPropertyName === undefined || value[modelIdKey] === incomingModelId)
 
   // The positional model is already the desired instance in the common
   // stable-update case. Only moved identified models need a pool lookup.
-  if (!positionalModelMatches && modelIdPropertyName) {
+  if (!positionalModelMatches && modelIdPropertyName !== undefined) {
     const modelInPool = modelPool.findModelByTypeAndId(type, incomingModelId)
     if (modelInPool) {
       value = modelInPool
@@ -92,7 +92,7 @@ function reconcileModelSnapshot(
     }
 
     const modelProps = getInternalModelClassPropsInfo(modelClass)
-    if (modelIdPropertyName) {
+    if (modelIdPropertyName !== undefined) {
       if (value[modelIdKey] !== incomingModelId) {
         // different id, no reconciliation possible
         return fromSnapshot<AnyModel>(sn)
@@ -134,7 +134,7 @@ function reconcileModelSnapshot(
       const dataKeysLen = dataKeys.length
       for (let i = 0; i < dataKeysLen; i++) {
         const k = dataKeys[i]
-        if (!(k in processedSn)) {
+        if (!hasOwnProp(processedSn, k)) {
           // use default value if applicable
           const modelProp = modelProps[k] as AnyModelProp | undefined
           const defaultValue = modelProp

package/src/snapshot/reconcilePlainObjectSnapshot.ts

@@ -1,10 +1,11 @@
 import { isObservableObject, remove } from "mobx"
+import { isModel } from "../model/utils"
 import {
   isTypeCheckingAfterChangeEnabled,
   runTypeCheckingAfterChange,
 } from "../tweaker/typeChecking"
 import { withoutTypeChecking } from "../tweaker/withoutTypeChecking"
-import { isPlainObject } from "../utils"
+import { hasOwnProp, isPlainObject } from "../utils"
 import { withErrorPathSegment } from "../utils/errorDiagnostics"
 import type { ModelPool } from "../utils/ModelPool"
 import { setIfDifferent } from "../utils/setIfDifferent"
@@ -19,8 +20,8 @@ function reconcilePlainObjectSnapshot(
   sn: SnapshotInOfObject<any>,
   modelPool: ModelPool
 ): object {
-  // plain obj
-  if (!(isPlainObject(value) || isObservableObject(value))) {
+  // Observable models carry instance state and must be replaced, not edited as plain objects.
+  if (isModel(value) || !(isPlainObject(value) || isObservableObject(value))) {
     // no reconciliation possible
     return fromSnapshot(sn)
   }
@@ -35,7 +36,7 @@ function reconcilePlainObjectSnapshot(
     const plainObjKeysLen = plainObjKeys.length
     for (let i = 0; i < plainObjKeysLen; i++) {
       const k = plainObjKeys[i]
-      if (!(k in sn)) {
+      if (!hasOwnProp(sn, k)) {
         remove(plainObj, k)
       }
     }

package/src/standardActions/arrayActions.ts

@@ -26,7 +26,7 @@ export const arrayActions = {
 
   concat: standaloneAction(
     `${namespace}::concat`,
-    <T>(array: T[], ...items: ConcatArray<T>[]): T[] => {
+    <T>(array: T[], ...items: (T | ConcatArray<T>)[]): T[] => {
       return array.concat(...items)
     }
   ),
@@ -89,9 +89,19 @@ export const arrayActions = {
   swap: standaloneAction(
     `${namespace}::swap`,
     <T>(array: T[], index1: number, index2: number): boolean => {
-      if (index1 < 0 || index2 < 0 || index1 >= array.length || index2 >= array.length) {
+      if (
+        !Number.isInteger(index1) ||
+        !Number.isInteger(index2) ||
+        index1 < 0 ||
+        index2 < 0 ||
+        index1 >= array.length ||
+        index2 >= array.length
+      ) {
         return false
       }
+      if (index1 === index2) {
+        return true
+      }
       if (index2 < index1) {
         ;[index1, index2] = [index2, index1]
       }

package/src/standardActions/objectActions.ts

@@ -1,4 +1,5 @@
 import { isObservable, remove } from "mobx"
+import { isModel } from "../model/utils"
 import { toTreeNode } from "../tweaker/tweak"
 import { assertIsObject, namespace as ns } from "../utils"
 import type { AnyFunction } from "../utils/AnyFunction"
@@ -11,7 +12,7 @@ export const objectActions = {
   set: standaloneAction(
     `${namespace}::set`,
     <T extends object, K extends keyof T>(target: T, key: K, value: T[K]): void => {
-      if (isObservable(target)) {
+      if (isObservable(target) && !isModel(target)) {
         setIfDifferent(target, key, value)
       } else {
         target[key] = value
@@ -25,7 +26,7 @@ export const objectActions = {
       assertIsObject(partialObject, "partialObject")
       const keys = Object.keys(partialObject)
 
-      if (isObservable(target)) {
+      if (isObservable(target) && !isModel(target)) {
         for (const key of keys) {
           const newValue = (partialObject as any)[key]
           setIfDifferent(target, key, newValue)

package/src/transforms/ImmutableDate.ts

@@ -31,6 +31,10 @@ const errMessage = "this Date object is immutable"
 export class ImmutableDate extends Date {
   // disable mutable methods
 
+  setYear(): never {
+    throw failure(errMessage)
+  }
+
   setTime(): any {
     throw failure(errMessage)
   }

package/src/transforms/asMap.ts

@@ -1,4 +1,5 @@
 import type { ModelPropTransform } from "../modelShared/prop"
+import { setProtoProp } from "../utils"
 import { asMap } from "../wrappers/asMap"
 
 const _objectToMapTransform: ModelPropTransform<Record<string, unknown>, Map<string, unknown>> = {
@@ -11,7 +12,8 @@ const _objectToMapTransform: ModelPropTransform<Record<string, unknown>, Map<str
 
     const obj: Record<string, unknown> = {}
     map.forEach((v, k) => {
-      obj[k] = v
+      if (k === "__proto__") setProtoProp(obj, v)
+      else obj[k] = v
     })
 
     return obj

package/src/treeUtils/deepEquals.ts

@@ -29,21 +29,23 @@ export function deepEquals(a: any, b: any): boolean {
     return true
   }
 
-  // use snapshots to compare if possible
-  // since snapshots use structural sharing it is more likely
-  // to speed up comparisons
-  if (isTreeNode(a)) {
-    a = getSnapshot(a)
-  } else if (isObservable(a)) {
-    a = toJS(a, toJSOptions)
-  }
-  if (isTreeNode(b)) {
-    b = getSnapshot(b)
-  } else if (isObservable(b)) {
-    b = toJS(b, toJSOptions)
+  const aIsObject = a !== null && typeof a === "object"
+  const bIsObject = b !== null && typeof b === "object"
+  if (!aIsObject && !bIsObject) {
+    // Strict equality already handled all equal primitives except NaN.
+    return Number.isNaN(a) && Number.isNaN(b)
   }
 
-  return fastDeepEqual(a, b)
+  return fastDeepEqual(aIsObject ? comparisonValue(a) : a, bIsObject ? comparisonValue(b) : b)
+}
+
+function comparisonValue(value: object): unknown {
+  if (isTreeNode(value)) {
+    // Snapshots preserve structural sharing. Model $ objects are deliberately
+    // handled as observable objects rather than standalone tree nodes.
+    return getSnapshot(value)
+  }
+  return isObservable(value) ? toJS(value, toJSOptions) : value
 }
 
 const toJSOptions =

package/src/treeUtils/draft.ts

@@ -38,6 +38,10 @@ export class Draft<T extends object> {
    */
   @mobxAction
   commitByPath(path: Path): void {
+    if (path.length === 0) {
+      this.commit()
+      return
+    }
     const draftTarget = resolvePath(this.data, path)
     if (!draftTarget.resolved) {
       throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`)
@@ -76,6 +80,10 @@ export class Draft<T extends object> {
    */
   @mobxAction
   resetByPath(path: Path): void {
+    if (path.length === 0) {
+      this.reset()
+      return
+    }
     const originalTarget = resolvePath(this.originalData, path)
     if (!originalTarget.resolved) {
       throw failure(`path ${JSON.stringify(path)} could not be resolved in original object`)