mobx-keystone 2.0.0 → 2.1.0

package/src/tweaker/tweak.ts

@@ -1,15 +1,28 @@
-import { action } from "mobx"
+import { action, isObservableArray, isObservableObject } from "mobx"
 import { isDataModel } from "../dataModel/utils"
+import { Frozen } from "../frozen/Frozen"
 import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig"
+import { getModelMetadata } from "../model/getModelMetadata"
+import { isModel } from "../model/utils"
 import { getObjectChildren } from "../parent/coreObjectChildren"
 import { fastGetParent, type ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
+import { fastIsRootStoreNoAtom } from "../rootStore/rootStore"
 import { unsetInternalSnapshot } from "../snapshot/internal"
 import type { AnyStandardType, TypeToData } from "../types/schemas"
 import { typeCheck } from "../types/typeCheck"
-import { failure, inDevMode, isMap, isObject, isPrimitive, isSet } from "../utils"
+import {
+  failure,
+  inDevMode,
+  isArray,
+  isMap,
+  isObject,
+  isPlainObject,
+  isPrimitive,
+  isSet,
+} from "../utils"
 import { getSafeErrorValuePreview } from "../utils/errorDiagnostics"
-import { isTweakedObject, runTweakedObjectUntweakers } from "./core"
+import { deactivateHandlers, isTweakedObject } from "./core"
 import { registerDefaultTweakers } from "./registerDefaultTweakers"
 import { treeNodeMetadata } from "./treeNodeMetadata"
 
@@ -100,9 +113,7 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
 
   // unsupported (must go before plain object tweaker)
   if (isDataModel(value)) {
-    throw failure(
-      "data models are not directly supported. you may insert the data in the tree instead ('$' property)."
-    )
+    throw dataModelsNotSupportedError()
   }
 
   registerDefaultTweakers()
@@ -116,17 +127,23 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
     }
   }
 
-  // unsupported
+  throw unsupportedValueError(value)
+}
+
+function dataModelsNotSupportedError() {
+  return failure(
+    "data models are not directly supported. you may insert the data in the tree instead ('$' property)."
+  )
+}
+
+function unsupportedValueError(value: unknown) {
   if (isMap(value)) {
-    throw failure("maps are not directly supported. consider using 'ObjectMap' / 'asMap' instead.")
+    return failure("maps are not directly supported. consider using 'ObjectMap' / 'asMap' instead.")
   }
-
-  // unsupported
   if (isSet(value)) {
-    throw failure("sets are not directly supported. consider using 'ArraySet' / 'asSet' instead.")
+    return failure("sets are not directly supported. consider using 'ArraySet' / 'asSet' instead.")
   }
-
-  throw failure(
+  return failure(
     `tweak can only work over models, observable objects/arrays, or primitives, but got ${getSafeErrorValuePreview(value)} instead`
   )
 }
@@ -141,6 +158,154 @@ export function tweak<T>(value: T, parentPath: ParentPath<any> | undefined): T {
   return isPrimitive(value) ? value : tweakNonPrimitive(value, parentPath)
 }
 
+/**
+ * Tells whether a node that has a parent gets detached by the change being
+ * intercepted before the new values are attached.
+ * @internal
+ */
+export type IsDetachedByChange = (node: object, parentPath: ParentPath<any>) => boolean
+
+// nodes to be attached by the change being checked, since a node cannot be
+// attached twice
+const seenNodes = new Set<object>()
+
+/**
+ * Throws the error `tweak` or `setParent` would throw when attaching `values`
+ * (and whatever they contain) after the change being intercepted detaches its
+ * values, without changing anything. Interceptors call it before detaching, so
+ * a rejected change leaves the tree as it was.
+ * `prepareValue`, when given, replaces each value before it is checked.
+ * @internal
+ */
+export function assertCanAttach(
+  values: unknown[],
+  isDetachedByChange: IsDetachedByChange,
+  prepareValue?: (value: unknown) => unknown
+): void {
+  try {
+    for (let i = 0; i < values.length; i++) {
+      if (prepareValue) {
+        values[i] = prepareValue(values[i])
+      }
+      checkAttach(values[i], isDetachedByChange)
+    }
+  } finally {
+    seenNodes.clear()
+  }
+}
+
+/**
+ * `assertCanAttach` for a single value.
+ * @internal
+ */
+export function assertCanAttachValue(value: unknown, isDetachedByChange: IsDetachedByChange): void {
+  if (isPrimitive(value)) {
+    return
+  }
+  try {
+    checkAttach(value, isDetachedByChange)
+  } finally {
+    seenNodes.clear()
+  }
+}
+
+function checkAttach(value: unknown, isDetachedByChange: IsDetachedByChange): void {
+  if (isPrimitive(value)) {
+    return
+  }
+
+  // (one metadata lookup instead of one per helper)
+  const metadata = treeNodeMetadata.get(value)
+  if (metadata?.tweaked) {
+    if (metadata.dataObjectParent !== undefined) {
+      throw failure("value must be the model object instance instead of the '$' sub-object")
+    }
+    if (fastIsRootStoreNoAtom(value)) {
+      throw failure("root stores cannot be attached to any parents")
+    }
+    if (isModel(value) && getModelMetadata(value).valueType) {
+      // setParent clones it when it has a parent
+      return
+    }
+    const parentPath = metadata.parentPath
+    if (
+      parentPath &&
+      !isDetachedByChange(value, parentPath) &&
+      !isUntweakedByChange(parentPath.parent, isDetachedByChange)
+    ) {
+      throw failure("an object cannot be assigned a new parent when it already has one")
+    }
+    assertNotSeen(value)
+    return
+  }
+
+  // the values internalTweak accepts, most common first
+  if (isPlainObject(value)) {
+    if (isObservableObject(value)) {
+      // (it becomes the tree node itself)
+      assertNotSeen(value)
+    }
+    checkAttachProps(value, isDetachedByChange)
+    return
+  }
+  if (isArray(value)) {
+    if (isObservableArray(value)) {
+      assertNotSeen(value)
+    }
+    for (let i = 0; i < value.length; i++) {
+      checkAttach(value[i], isDetachedByChange)
+    }
+    return
+  }
+  // (data models, frozen values and models can be observable objects too)
+  if (isDataModel(value)) {
+    throw dataModelsNotSupportedError()
+  }
+  if (value instanceof Frozen || isModel(value)) {
+    return
+  }
+  if (isObservableObject(value)) {
+    assertNotSeen(value)
+    checkAttachProps(value as Record<string, unknown>, isDetachedByChange)
+    return
+  }
+  throw unsupportedValueError(value)
+}
+
+function checkAttachProps(obj: Record<string, unknown>, isDetachedByChange: IsDetachedByChange) {
+  const keys = Object.keys(obj)
+  for (let i = 0; i < keys.length; i++) {
+    checkAttach(obj[keys[i]], isDetachedByChange)
+  }
+}
+
+function assertNotSeen(value: object) {
+  if (seenNodes.has(value)) {
+    throw failure("an object cannot be assigned a new parent when it already has one")
+  }
+  seenNodes.add(value)
+}
+
+/**
+ * Detaching a plain object or array untweaks it, which detaches its children.
+ */
+function isUntweakedByChange(node: object, isDetachedByChange: IsDetachedByChange): boolean {
+  for (;;) {
+    const metadata = treeNodeMetadata.get(node)
+    if (!metadata?.handlersActive) {
+      return false
+    }
+    const parentPath = metadata.parentPath
+    if (!parentPath) {
+      return false
+    }
+    if (isDetachedByChange(node, parentPath)) {
+      return true
+    }
+    node = parentPath.parent
+  }
+}
+
 /**
  * @internal
  */
@@ -156,8 +321,7 @@ export function tryUntweak(value: any): (() => void) | undefined {
   }
 
   const metadata = treeNodeMetadata.get(value)
-  const untweaker = metadata?.untweaker
-  if (!untweaker) {
+  if (!metadata?.handlersActive) {
     return undefined
   }
 
@@ -177,14 +341,13 @@ export function tryUntweak(value: any): (() => void) | undefined {
   }
 
   return () => {
-    // post-untweaking, call the untweaker
-    runTweakedObjectUntweakers(untweaker)
+    // post-untweaking
+    deactivateHandlers(value, metadata)
 
     // Match the former independent-map ordering: the node stops being tweaked
     // before its snapshot is unset, but the shared record must stay alive until
     // snapshot cleanup has consumed it.
     metadata.tweaked = false
-    metadata.untweaker = undefined
     unsetInternalSnapshot(value)
     // These associations previously lived in independent WeakMaps and remain
     // valid across untweak/retweak, so keep their shared record when present.

package/src/tweaker/tweakArray.ts

@@ -11,7 +11,10 @@ import {
 import { assertCanWrite } from "../action/protection"
 import { emitArraySpliceDeepChange, emitArrayUpdateDeepChange } from "../deepChange/onDeepChange"
 import { getGlobalConfig } from "../globalConfig"
-import type { ParentPath } from "../parent/path"
+import { getModelMetadata } from "../model/getModelMetadata"
+import { isModel } from "../model/utils"
+import { getArrayPaths, setLazyArrayParentPath } from "../parent/arrayPaths"
+import { fastGetParentPath, type ParentPath } from "../parent/path"
 import { reindexArrayChildren, setParent } from "../parent/setParent"
 import {
   beginPatchEmission,
@@ -21,6 +24,7 @@ import {
   InternalPatchRecorder,
 } from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
+import { clone } from "../snapshot/clone"
 import {
   flushInternalSnapshot,
   freezeInternalSnapshot,
@@ -29,20 +33,20 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { failure, inDevMode, isArray, isPrimitive } from "../utils"
-import {
-  addDelayedError,
-  type DelayedError,
-  throwDelayedError,
-} from "../utils/forEachWithDelayedThrow"
-import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
+import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
+import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
+import { activateHandlers, areHandlersActive, runningWithoutSnapshotOrPatches } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
-import { registerTweaker, tweak } from "./tweak"
 import {
-  isTypeCheckingAfterChangeEnabled,
-  recordTypeCheckingBatchChange,
-  runTypeCheckingAfterChange,
-} from "./typeChecking"
+  assertCanAttach,
+  assertCanAttachValue,
+  type IsDetachedByChange,
+  registerTweaker,
+  tweak,
+} from "./tweak"
+import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**
  * @internal
@@ -139,27 +143,31 @@ export function tweakArray<T extends any[]>(
   }
   setNewInternalSnapshot(tweakedArr, untransformedSn, undefined)
 
-  const interceptDisposer = intercept(
-    tweakedArr,
-    interceptArrayMutation.bind(undefined, tweakedArr)
-  )
-  const observeDisposer = observe(tweakedArr, arrayDidChange)
-  setTweakedObjectUntweakers(tweakedArr, interceptDisposer, observeDisposer)
+  if (activateHandlers(tweakedArr)) {
+    intercept(tweakedArr, interceptArrayMutation.bind(undefined, tweakedArr))
+    observe(tweakedArr, arrayDidChange)
+  }
 
   return tweakedArr as any
 }
 
-function mutateSet(k: number, v: unknown, sn: unknown[]) {
+function mutateSet(k: number, v: unknown, sn: unknown[]): readonly unknown[] {
   sn[k] = v
+  return [v]
 }
 
 // Conservative bound below every engine's argument-count limit for spread calls.
 const maxSpreadableItems = 8192
 
-function mutateSplice(index: number, removedCount: number, addedItems: any[], sn: any[]) {
+function mutateSplice(
+  index: number,
+  removedCount: number,
+  addedItems: any[],
+  sn: any[]
+): readonly unknown[] {
   if (addedItems.length < maxSpreadableItems) {
     sn.splice(index, removedCount, ...addedItems)
-    return
+    return addedItems
   }
 
   // Splice the tail in a single pass instead of spreading the added items as
@@ -170,11 +178,18 @@ function mutateSplice(index: number, removedCount: number, addedItems: any[], sn
   sn.copyWithin(index + addedItems.length, index + removedCount, oldLength)
   for (let i = 0; i < addedItems.length; i++) sn[index + i] = addedItems[i]
   sn.length = newLength
+  return addedItems
 }
 
 const patchRecorder = new InternalPatchRecorder()
 
 function arrayDidChange(change: IArrayDidChange) {
+  if (!areHandlersActive(change.object)) {
+    // idle handler of an untweaked array
+    return
+  }
+  notifyTweakedChangeListeners(change)
+
   const arr = change.object
 
   patchRecorder.reset()
@@ -183,13 +198,11 @@ function arrayDidChange(change: IArrayDidChange) {
     return
   }
 
-  recordTypeCheckingBatchChange(change)
-
   const oldSnapshot = getInternalSnapshot(arr as Array<unknown>)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(arr)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
 
-  let mutate: ((sn: any[]) => void) | undefined
+  let mutate: ((sn: any[]) => readonly unknown[]) | undefined
   switch (change.type) {
     case "splice":
       mutate = arrayDidChangeSplice(
@@ -212,6 +225,8 @@ function arrayDidChange(change: IArrayDidChange) {
   }
 
   runTypeCheckingAfterChange(arr, patchRecorder)
+  // (after type checking, which undoes a rejected change, but before listeners)
+  recordChangeForRollback(change)
   if (mutate) {
     updateInternalSnapshot(arr, mutate)
   }
@@ -260,7 +275,7 @@ function arrayDidChange(change: IArrayDidChange) {
   } catch (error) {
     delayedError = addDelayedError(delayedError, error)
   }
-  throwDelayedError(delayedError)
+  throwDelayedListenerError(delayedError)
 }
 
 const undefinedInsideArrayErrorMsg =
@@ -473,6 +488,10 @@ function interceptArrayMutation(
   array: IObservableArray,
   change: IArrayWillChange | IArrayWillSplice
 ) {
+  if (!areHandlersActive(array)) {
+    // idle handler of an untweaked array
+    return change
+  }
   assertCanWrite()
 
   switch (change.type) {
@@ -509,9 +528,18 @@ function validateArrayMutationUpdate(change: IArrayWillChange) {
 function interceptArrayMutationUpdate(change: IArrayWillChange, array: IObservableArray) {
   // TODO: should be change.object, but mobx is bugged and doesn't send the proxy
   const oldVal = array[change.index]
+  if (change.newValue === oldVal) {
+    return
+  }
+  assertCanAttachValue(change.newValue, (node) => node === oldVal)
   tweak(oldVal, undefined) // set old prop obj parent to undefined
 
-  change.newValue = tweak(change.newValue, { parent: array, path: change.index })
+  const paths = getArrayPaths(array, 0)
+  const entry = paths?.set(change.index, change.newValue)
+  change.newValue = tweak(change.newValue, entry ?? { parent: array, path: change.index })
+  if (entry) {
+    setLazyArrayParentPath(entry, change.newValue)
+  }
 }
 
 function validateArrayMutationSplice(change: IArrayWillSplice) {
@@ -526,12 +554,65 @@ function validateArrayMutationSplice(change: IArrayWillSplice) {
   }
 }
 
+/**
+ * Checks the added items can be attached before the splice detaches anything,
+ * so a rejected splice leaves every item as it was. Value types that are added
+ * to the array at the index they already have get cloned here, since
+ * `setParent` cannot tell they are being added again (it clones them when they
+ * are added anywhere else).
+ */
+function checkAddedItems(change: IArrayWillSplice) {
+  const array = change.object
+  const added = change.added
+  const removedEnd = change.index + change.removedCount
+  const isDetachedByChange: IsDetachedByChange = (_node, parentPath) =>
+    parentPath.parent === array &&
+    (parentPath.path as number) >= change.index &&
+    (parentPath.path as number) < removedEnd
+
+  assertCanAttach(added, isDetachedByChange, (value) => {
+    if (!isPrimitive(value) && isModel(value) && getModelMetadata(value).valueType) {
+      const parentPath = fastGetParentPath(value, false)
+      if (parentPath?.parent === array && !isDetachedByChange(value, parentPath)) {
+        return clone(value, { generateNewIds: true })
+      }
+    }
+    return value
+  })
+}
+
 function interceptArrayMutationSplice(change: IArrayWillSplice) {
+  checkAddedItems(change)
+
+  const array = change.object
+  const oldNextIndex = change.index + change.removedCount
+  const paths =
+    change.removedCount !== change.added.length
+      ? getArrayPaths(array, array.length - oldNextIndex)
+      : getArrayPaths(array, 0)
+
   for (let i = 0; i < change.removedCount; i++) {
     const removedValue = change.object[change.index + i]
     tweak(removedValue, undefined)
   }
 
+  if (paths) {
+    const addedPaths = paths.createPaths(change.index, change.added)
+    for (let i = 0; i < change.added.length; i++) {
+      const addedPath = addedPaths[i]
+      change.added[i] = tweak(
+        change.added[i],
+        addedPath ?? { parent: array, path: change.index + i }
+      )
+      if (addedPath) {
+        setLazyArrayParentPath(addedPath, change.added[i])
+      }
+    }
+    // no reindexing: the items after the splice follow their chunks
+    paths.applySplice(change.index, change.removedCount, addedPaths)
+    return
+  }
+
   for (let i = 0; i < change.added.length; i++) {
     change.added[i] = tweak(change.added[i], {
       parent: change.object,
@@ -540,7 +621,6 @@ function interceptArrayMutationSplice(change: IArrayWillSplice) {
   }
 
   // we might also need to update the parent of the next indexes
-  const oldNextIndex = change.index + change.removedCount
   const newNextIndex = change.index + change.added.length
 
   if (oldNextIndex !== newNextIndex && oldNextIndex < change.object.length) {

package/src/tweaker/tweakPlainObject.ts

@@ -13,10 +13,12 @@ import {
   emitObjectUpdateDeepChange,
 } from "../deepChange/onDeepChange"
 import type { AnyModel } from "../model/BaseModel"
+import { getModelIdPropertyName } from "../model/getModelMetadata"
 import { modelTypeKey } from "../model/metadata"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"
 import { dataToModelNode } from "../parent/core"
+import { onModelIdChanged } from "../parent/coreObjectChildren"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
 import {
@@ -36,22 +38,16 @@ import {
 } from "../snapshot/internal"
 import { takeModelInitialDataSnapshot } from "../snapshot/modelInitialData"
 import { withoutCachedTypeChecking } from "../types/createCachedTypeCheck"
-import { failure, isPlainObject, isPrimitive, setProtoProp } from "../utils"
-import {
-  addDelayedError,
-  type DelayedError,
-  throwDelayedError,
-} from "../utils/forEachWithDelayedThrow"
+import { failure, isPlainObject, isPrimitive, nodeObservableOptions, setProtoProp } from "../utils"
+import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
 import { setIfDifferent } from "../utils/setIfDifferent"
-import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
+import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
+import { activateHandlers, runningWithoutSnapshotOrPatches } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
-import { markAsTweakedObject } from "./treeNodeMetadata"
-import { registerTweaker, tweak } from "./tweak"
-import {
-  isTypeCheckingAfterChangeEnabled,
-  recordTypeCheckingBatchChange,
-  runTypeCheckingAfterChange,
-} from "./typeChecking"
+import { markAsTweakedObject, treeNodeMetadata } from "./treeNodeMetadata"
+import { assertCanAttachValue, registerTweaker, tweak } from "./tweak"
+import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**
  * @internal
@@ -67,7 +63,7 @@ export function tweakPlainObject<T extends Record<string, any>>(
   const originalIsObservableObject = isObservableObject(originalObj)
   const tweakedObj = originalIsObservableObject
     ? originalObj
-    : observable.object({}, undefined, observableOptions)
+    : observable.object({}, undefined, nodeObservableOptions)
 
   // Mark it as tweaked before processing children. The cleanup functions are
   // installed after the MobX handlers have been registered.
@@ -150,38 +146,57 @@ export function tweakPlainObject<T extends Record<string, any>>(
     transformFn
   )
 
-  const interceptDisposer = intercept(tweakedObj, interceptObjectMutation)
-  const observeDisposer = observe(tweakedObj, objectDidChange)
-  setTweakedObjectUntweakers(tweakedObj, interceptDisposer, observeDisposer)
+  if (activateHandlers(tweakedObj)) {
+    intercept(tweakedObj, interceptObjectMutation)
+    observe(tweakedObj, objectDidChange)
+  }
 
   return tweakedObj as any
 }
 
-const observableOptions = {
-  deep: false,
-}
-
-function mutateSet(k: PropertyKey, v: unknown, sn: Record<PropertyKey, unknown>) {
+function mutateSet(
+  k: PropertyKey,
+  v: unknown,
+  sn: Record<PropertyKey, unknown>
+): readonly unknown[] {
   if (k === "__proto__") {
     setProtoProp(sn, v)
   } else {
     sn[k] = v
   }
+  return [v]
 }
 
-function mutateDelete(k: PropertyKey, sn: Record<PropertyKey, unknown>) {
+const noValues: readonly unknown[] = []
+
+function mutateDelete(k: PropertyKey, sn: Record<PropertyKey, unknown>): readonly unknown[] {
   delete sn[k]
+  return noValues
 }
 
 const patchRecorder = new InternalPatchRecorder()
 
 function objectDidChange(change: IObjectDidChange): void {
+  const obj = change.object
+  const metadata = treeNodeMetadata.get(obj)
+  if (!metadata?.handlersActive) {
+    // idle handler of an untweaked object
+    return
+  }
   if (typeof change.name !== "string") {
     throw failure("change.name is not a string")
   }
 
-  const obj = change.object
-  const actualNode = dataToModelNode(obj)
+  notifyTweakedChangeListeners(change)
+
+  const actualNode = metadata.dataObjectParent ?? obj
+
+  if (
+    actualNode !== obj &&
+    change.name === getModelIdPropertyName(actualNode.constructor as ModelClass<AnyModel>)
+  ) {
+    onModelIdChanged(actualNode)
+  }
 
   patchRecorder.reset()
 
@@ -189,13 +204,11 @@ function objectDidChange(change: IObjectDidChange): void {
     return
   }
 
-  recordTypeCheckingBatchChange(change)
-
   const oldUntransformedSn = getInternalSnapshot(actualNode)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(actualNode)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
 
-  let mutate: ((sn: any) => void) | undefined
+  let mutate: ((sn: any) => readonly unknown[]) | undefined
   switch (change.type) {
     case "add":
     case "update":
@@ -226,6 +239,8 @@ function objectDidChange(change: IObjectDidChange): void {
   } else {
     runTypeCheckingAfterChange(obj, patchRecorder)
   }
+  // (after type checking, which undoes a rejected change, but before listeners)
+  recordChangeForRollback(change)
   updateInternalSnapshot(actualNode, mutate)
 
   // Listeners may mutate another node and reuse the shared recorder.
@@ -270,7 +285,7 @@ function objectDidChange(change: IObjectDidChange): void {
   } catch (error) {
     delayedError = addDelayedError(delayedError, error)
   }
-  throwDelayedError(delayedError)
+  throwDelayedListenerError(delayedError)
 }
 
 function objectDidChangeRemove(
@@ -337,7 +352,14 @@ function objectDidChangeAddOrUpdate(
   return mutate
 }
 
+const noneDetached = () => false
+
 function interceptObjectMutation(change: IObjectWillChange) {
+  const metadata = treeNodeMetadata.get(change.object)
+  if (!metadata?.handlersActive) {
+    // idle handler of an untweaked object
+    return change
+  }
   assertCanWrite()
 
   if (typeof change.name === "symbol") {
@@ -347,10 +369,11 @@ function interceptObjectMutation(change: IObjectWillChange) {
   // This must happen before detach/reparent work below. It keeps the old value
   // available for inverse patches and folds a departing dirty child into its
   // parent snapshot while its parent path still exists.
-  flushInternalSnapshot(dataToModelNode(change.object), false)
+  flushInternalSnapshot(metadata.dataObjectParent ?? change.object, false)
 
   switch (change.type) {
     case "add":
+      assertCanAttachValue(change.newValue, noneDetached)
       change.newValue = tweak(change.newValue, {
         parent: change.object,
         path: String(change.name),
@@ -366,6 +389,8 @@ function interceptObjectMutation(change: IObjectWillChange) {
       const oldVal = change.object[change.name]
       const newVal = change.newValue
       if (newVal !== oldVal) {
+        // (first, so a value that cannot be attached leaves the old one in place)
+        assertCanAttachValue(newVal, (node) => node === oldVal)
         tweak(oldVal, undefined)
 
         change.newValue = tweak(newVal, {