mobx-keystone 1.24.1 → 2.0.0

package/src/ref/core.ts

@@ -88,10 +88,26 @@ export function internalCustomRef<T extends object>(
       trackedRefs.add(this as Ref<object>)
       this.internalForceUpdateBackRefs(initialTarget)
 
+      // MobX 4/5 do not pass the previous value to reaction effects.
+      // The reaction is usually created inside an action, so its first tracking run is deferred
+      // to the end of the batch and `initialTarget` may be stale by then; capture the value of
+      // that first run instead, since that is the one the effect will be compared against.
+      let previousTarget = initialTarget
+      let firstTrackingRun = true
       // according to mwestrate this won't leak as long as we don't keep the disposer around
       reaction(
-        () => this.maybeCurrent,
-        (newTarget, oldTarget) => {
+        () => {
+          const target = this.maybeCurrent
+          if (firstTrackingRun) {
+            firstTrackingRun = false
+            previousTarget = target
+            this.internalForceUpdateBackRefs(target)
+          }
+          return target
+        },
+        (newTarget) => {
+          const oldTarget = previousTarget
+          previousTarget = newTarget
           this.internalForceUpdateBackRefs(newTarget)
 
           if (onResolvedValueChange && newTarget !== oldTarget) {

package/src/rootStore/attachDetach.ts

@@ -4,9 +4,10 @@ import { HookAction } from "../action/hookActions"
 import { wrapInAction, wrapModelMethodInActionIfNeeded } from "../action/wrapInAction"
 import { type AnyModel, BaseModel } from "../model/BaseModel"
 import { WalkTreeMode, walkTree } from "../parent/walkTree"
+import { forEachWithDelayedThrow } from "../utils/forEachWithDelayedThrow"
 
 const onAttachedDisposers = new WeakMap<object, () => void>()
-const attachedToRootStore = new WeakSet<object>()
+const attachedToRootStore = new WeakMap<object, object>()
 
 /**
  * @internal
@@ -16,6 +17,7 @@ export const attachToRootStore = action(
   (rootStore: object, child: object): void => {
     // we use an array to ensure they will get called even if the actual hook modifies the tree
     const childrenToCall: AnyModel[] = []
+    const attachment = {}
 
     walkTree(
       child,
@@ -25,7 +27,7 @@ export const attachToRootStore = action(
         if (attachedToRootStore.has(ch)) {
           return
         }
-        attachedToRootStore.add(ch)
+        attachedToRootStore.set(ch, attachment)
 
         if (ch instanceof BaseModel && (ch as any).onAttachedToRootStore) {
           wrapModelMethodInActionIfNeeded(
@@ -40,15 +42,23 @@ export const attachToRootStore = action(
       WalkTreeMode.ParentFirst
     )
 
-    const childrenToCallLen = childrenToCall.length
-    for (let i = 0; i < childrenToCallLen; i++) {
-      const ch = childrenToCall[i]
+    forEachWithDelayedThrow(childrenToCall, (ch) => {
+      // An earlier hook may have detached or reattached this node already.
+      if (attachedToRootStore.get(ch) !== attachment) {
+        return
+      }
 
       const disposer = (ch as any).onAttachedToRootStore(rootStore)
       if (disposer) {
-        onAttachedDisposers.set(ch, disposer)
+        if (attachedToRootStore.get(ch) === attachment) {
+          onAttachedDisposers.set(ch, disposer)
+        } else {
+          // The hook detached or reattached this node before returning its cleanup.
+          // Dispose this attachment without overwriting a newer attachment's cleanup.
+          wrapDisposer(ch, disposer)()
+        }
       }
-    }
+    })
   }
 )
 
@@ -69,11 +79,7 @@ export const detachFromRootStore = action("detachFromRootStore", (child: object)
       const disposer = onAttachedDisposers.get(ch)
       if (disposer) {
         // wrap disposer in action
-        const disposerAction = wrapInAction({
-          nameOrNameFn: HookAction.OnAttachedToRootStoreDisposer,
-          fn: disposer,
-          actionType: ActionContextActionType.Sync,
-        }).bind(ch)
+        const disposerAction = wrapDisposer(ch, disposer)
         onAttachedDisposers.delete(ch)
 
         disposersToCall.push(disposerAction)
@@ -82,8 +88,13 @@ export const detachFromRootStore = action("detachFromRootStore", (child: object)
     WalkTreeMode.ChildrenFirst
   )
 
-  const disposersToCallLen = disposersToCall.length
-  for (let i = 0; i < disposersToCallLen; i++) {
-    disposersToCall[i]()
-  }
+  forEachWithDelayedThrow(disposersToCall, (dispose) => dispose())
 })
+
+function wrapDisposer(node: object, disposer: () => void): () => void {
+  return wrapInAction({
+    nameOrNameFn: HookAction.OnAttachedToRootStoreDisposer,
+    fn: disposer,
+    actionType: ActionContextActionType.Sync,
+  }).bind(node)
+}

package/src/rootStore/rootStore.ts

@@ -45,9 +45,11 @@ export const registerRootStore: <T extends object>(node: T) => T = action(
 
     entry.is = true
 
-    attachToRootStore(node, node)
-
-    entry.atom?.reportChanged()
+    try {
+      attachToRootStore(node, node)
+    } finally {
+      entry.atom?.reportChanged()
+    }
     return node
   }
 )
@@ -65,9 +67,11 @@ export const unregisterRootStore: (node: object) => void = action("unregisterRoo
   const entry = getOrCreateRootStoreEntry(node)
   entry.is = false
 
-  detachFromRootStore(node)
-
-  entry.atom?.reportChanged()
+  try {
+    detachFromRootStore(node)
+  } finally {
+    entry.atom?.reportChanged()
+  }
 })
 
 /**

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

@@ -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)
 
@@ -120,7 +129,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/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/internal.ts

@@ -31,10 +31,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>()
 
 /**
@@ -101,7 +104,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
@@ -143,7 +146,7 @@ function setSnapshotData(sn: SnapshotData, untransformed: any, freezeIfCloned =
     transformed !== undefined &&
     (!wasFrozen || transformed !== untransformed)
   ) {
-    snapshotStates.set(transformed, false)
+    snapshotStates.set(transformed, sn)
   }
 }
 
@@ -335,7 +338,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,6 +373,16 @@ export function freezeInternalSnapshot<T extends PrimitiveValue | object>(data:
     return 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)
+  }
+
   if (Array.isArray(data)) {
     for (let i = 0; i < data.length; i++) {
       freezeInternalSnapshot(data[i])
@@ -383,8 +396,8 @@ 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
   }
 
   return data

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/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

@@ -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 { hasOwnProp, isArray, isPrimitive } from "../utils"
 import { withErrorModelTrailEntry, withErrorPathSegment } from "../utils/errorDiagnostics"
 import type { ModelPool } from "../utils/ModelPool"
 import { setIfDifferent } from "../utils/setIfDifferent"
@@ -51,22 +51,22 @@ 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
   }
 
   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
@@ -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/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/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/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