mobx-keystone 1.25.0 → 2.0.0

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

package/src/treeUtils/sandbox.ts

@@ -7,7 +7,6 @@ import { createContext } from "../context"
 import { getParentToChildPath, resolvePath } from "../parent/path"
 import { applyPatches } from "../patch/applyPatches"
 import { onPatches } from "../patch/emitPatch"
-import type { Patch } from "../patch/Patch"
 import { type PatchRecorder, patchRecorder } from "../patch/patchRecorder"
 import {
   fastIsRootStoreNoAtom,
@@ -78,11 +77,6 @@ export class SandboxManager {
    */
   private allowWrite: ReadonlyMiddlewareReturn["allowWrite"]
 
-  /**
-   * Whether changes made in the sandbox are currently being committed to the original subtree.
-   */
-  private isCommitting = false
-
   private readonly subtreeRoot: object
 
   /**
@@ -127,11 +121,9 @@ export class SandboxManager {
       if (this.withSandboxPatchRecorder) {
         throw failure("original subtree must not change while 'withSandbox' executes")
       }
-      if (!this.isCommitting) {
-        this.allowWrite(() => {
-          applyPatches(this.subtreeRootClone, patches)
-        })
-      }
+      this.allowWrite(() => {
+        applyPatches(this.subtreeRootClone, patches)
+      })
     })
 
     const { allowWrite, dispose: disposeReadonlyMW } = readonlyMiddleware(this.subtreeRootClone)
@@ -232,26 +224,38 @@ export class SandboxManager {
       }
       if (commit) {
         if (!isNestedWithSandboxCall) {
-          const patches: Patch[] = []
-          const len = recorder.events.length
-          for (let i = 0; i < len; i++) {
-            patches.push(...recorder.events[i].patches)
-          }
-
-          const isCommitting = this.isCommitting
-          this.isCommitting = true
-          try {
-            applyPatches(this.subtreeRoot, patches)
-          } finally {
-            this.isCommitting = isCommitting
-          }
+          const events = recorder.events
+          // The clone already holds these changes, so revert them and let the regular
+          // patch sync mirror the original's final state back in. That way anything a
+          // listener changes on the original during the commit reaches the clone too,
+          // at a cost proportional to the changes rather than to the tree size.
+          // Both halves run in a single action so that observers of the sandbox never
+          // see the reverted intermediate state.
+          runInAction(() => {
+            this.allowWrite(() => {
+              for (let i = events.length - 1; i >= 0; i--) {
+                applyPatches(this.subtreeRootClone, events[i].inversePatches, true)
+              }
+            })
+            applyPatches(
+              this.subtreeRoot,
+              events.map((event) => event.patches)
+            )
+          })
         }
       } else {
         this.allowWrite(() => {
           runInAction(() => {
-            let i = recorder.events.length
-            while (i-- > numRecorderEvents) {
-              applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)
+            const wasRecording = recorder.recording
+            recorder.recording = false
+            try {
+              let i = recorder.events.length
+              while (i-- > numRecorderEvents) {
+                applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)
+              }
+              recorder.events.splice(numRecorderEvents)
+            } finally {
+              recorder.recording = wasRecording
             }
           })
         })

package/src/tweaker/core.ts

@@ -28,10 +28,8 @@ export function setTweakedObjectUntweakers(
  * @internal
  */
 export function isTweakedObject(value: unknown, canBeDataObject: boolean): value is object {
-  if (!canBeDataObject && hasDataObjectParent(value as object)) {
-    return false
-  }
-  return treeNodeMetadata.get(value as object)?.tweaked === true
+  const metadata = treeNodeMetadata.get(value as object)
+  return metadata?.tweaked === true && (canBeDataObject || metadata.dataObjectParent === undefined)
 }
 
 /**

package/src/tweaker/tweak.ts

@@ -8,6 +8,7 @@ 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 { getSafeErrorValuePreview } from "../utils/errorDiagnostics"
 import { isTweakedObject, runTweakedObjectUntweakers } from "./core"
 import { registerDefaultTweakers } from "./registerDefaultTweakers"
 import { treeNodeMetadata } from "./treeNodeMetadata"
@@ -126,7 +127,7 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
   }
 
   throw failure(
-    `tweak can only work over models, observable objects/arrays, or primitives, but got ${value} instead`
+    `tweak can only work over models, observable objects/arrays, or primitives, but got ${getSafeErrorValuePreview(value)} instead`
   )
 }
 

package/src/tweaker/tweakArray.ts

@@ -13,7 +13,13 @@ import { emitArraySpliceDeepChange, emitArrayUpdateDeepChange } from "../deepCha
 import { getGlobalConfig } from "../globalConfig"
 import type { ParentPath } from "../parent/path"
 import { reindexArrayChildren, setParent } from "../parent/setParent"
-import { hasPatchListenersFor, InternalPatchRecorder } from "../patch/emitPatch"
+import {
+  beginPatchEmission,
+  emitPatches,
+  endPatchEmission,
+  hasPatchListenersFor,
+  InternalPatchRecorder,
+} from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
 import {
   flushInternalSnapshot,
@@ -23,11 +29,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 { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker, tweak } from "./tweak"
-import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
+import {
+  isTypeCheckingAfterChangeEnabled,
+  recordTypeCheckingBatchChange,
+  runTypeCheckingAfterChange,
+} from "./typeChecking"
 
 /**
  * @internal
@@ -138,8 +153,23 @@ function mutateSet(k: number, v: unknown, sn: unknown[]) {
   sn[k] = 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[]) {
-  sn.splice(index, removedCount, ...addedItems)
+  if (addedItems.length < maxSpreadableItems) {
+    sn.splice(index, removedCount, ...addedItems)
+    return
+  }
+
+  // Splice the tail in a single pass instead of spreading the added items as
+  // arguments, which would overflow the engine's limit. copyWithin handles overlap.
+  const oldLength = sn.length
+  const newLength = oldLength - removedCount + addedItems.length
+  if (newLength > oldLength) sn.length = newLength
+  sn.copyWithin(index + addedItems.length, index + removedCount, oldLength)
+  for (let i = 0; i < addedItems.length; i++) sn[index + i] = addedItems[i]
+  sn.length = newLength
 }
 
 const patchRecorder = new InternalPatchRecorder()
@@ -149,24 +179,12 @@ function arrayDidChange(change: IArrayDidChange) {
 
   patchRecorder.reset()
 
-  switch (change.type) {
-    case "splice":
-      emitArraySpliceDeepChange(arr, arr, change.index as number, change.added, change.removed)
-      break
-
-    case "update":
-      emitArrayUpdateDeepChange(arr, arr, change.index as number, change.newValue, change.oldValue)
-
-      break
-
-    default:
-      break
-  }
-
   if (runningWithoutSnapshotOrPatches) {
     return
   }
 
+  recordTypeCheckingBatchChange(change)
+
   const oldSnapshot = getInternalSnapshot(arr as Array<unknown>)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(arr)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
@@ -196,8 +214,53 @@ function arrayDidChange(change: IArrayDidChange) {
   runTypeCheckingAfterChange(arr, patchRecorder)
   if (mutate) {
     updateInternalSnapshot(arr, mutate)
-    patchRecorder.emit(arr)
   }
+  // Listeners may mutate another node and reuse the shared recorder.
+  // Keep this change's patches before publishing the validated deep change.
+  const { patches, invPatches } = patchRecorder
+  patchRecorder.reset()
+
+  // Reserve chronological patch notifications, then finish deep-change delivery
+  // before publishing them. Reentrant edits append behind this mutation.
+  // Every step below runs even when an earlier one throws, so a failing patch recorder
+  // cannot keep the mutation from reaching the deep change and public patch listeners,
+  // and no failure is lost to a later one.
+  beginPatchEmission()
+  let delayedError: DelayedError
+  try {
+    emitPatches(arr, patches, invPatches)
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    switch (change.type) {
+      case "splice":
+        emitArraySpliceDeepChange(arr, arr, change.index as number, change.added, change.removed)
+        break
+
+      case "update":
+        emitArrayUpdateDeepChange(
+          arr,
+          arr,
+          change.index as number,
+          change.newValue,
+          change.oldValue
+        )
+
+        break
+
+      default:
+        break
+    }
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    endPatchEmission()
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  throwDelayedError(delayedError)
 }
 
 const undefinedInsideArrayErrorMsg =
@@ -317,10 +380,10 @@ function arrayDidChangeSplice(
     }
 
     if (patches && readdPatches && readdPatches.length > 0) {
-      patches.push(...readdPatches)
+      for (const patch of readdPatches) patches.push(patch)
     }
     if (invPatches && readdInvPatches && readdInvPatches.length > 0) {
-      invPatches.push(...readdInvPatches)
+      for (const patch of readdInvPatches) invPatches.push(patch)
     }
     // We need to reverse once since inverse patches are applied in reverse.
     // Repeated unshift calls here would make a large splice quadratic.