@jbrowse/mobx-state-tree 5.11.0 → 5.11.2

package/README.md

@@ -1,27 +1,228 @@
 # @jbrowse/mobx-state-tree
 
-Fork of mobx-state-tree v5.4.2 for use in jbrowse
-
-## Current list of changes
-
-- updated typescript
-- updated to import actual filepaths instead of node module resolution
-- reduced rollup config
-- removed process.env.NODE_ENV from code, instead exporting a setDevMode function
-- converted tests to vitest
-- remove unused dependencies
-- updated tslint to eslint and typescript-eslint
-- dual CJS/ESM build using main and module fields (pure ESM causes trouble when both are imported in vite)
-- added `types.resilient` - wraps a type so that instantiation errors are caught
-  and a fallback type is used instead of crashing the entire state tree. This is
-  useful for arrays or maps that may contain unknown or invalid entries (e.g.
-  plugin types that are not installed). It takes a primary type, a fallback type,
-  and a `createFallbackSnapshot` callback that receives the error and original
-  snapshot. Note: `isValidSnapshot` always returns success for resilient types,
-  meaning any value is considered a valid snapshot. Validation is deferred to
-  instantiation time, where failures are caught and routed to the fallback
-- removed NonEmptyObject annotation (also at upstream in post v5 versions)
-- replaced `unique symbol` phantom properties (`$emptyObject`, `$stateTreeNodeType`) with
+Fork of [mobx-state-tree](https://mobx-state-tree.js.org) v5.4.2 maintained for use in
+[JBrowse 2](https://jbrowse.org). All upstream types and APIs are available — this page
+documents only the additions and changes made in this fork.
+
+## Infrastructure changes
+
+- Updated TypeScript and import paths to use explicit file extensions
+- Replaced `process.env.NODE_ENV` with an exported `setDevMode()` function
+- Converted tests from Jest to Vitest
+- Replaced tslint with eslint + typescript-eslint
+- Dual CJS/ESM build (avoids issues when both are imported in the same Vite build)
+- Removed unused dependencies and the `NonEmptyObject` annotation
+- Replaced `unique symbol` phantom properties (`$emptyObject`, `$stateTreeNodeType`) with
   exported string-keyed brand interfaces (`$EmptyObjectBrand`, `$__mstStateTreeNodeType__`),
-  fixing tsgo TS4058/TS4023 errors when MST types propagate into exported function return types
-- add reflection api getChildType and getUnionSubtypes and getDefaultInstanceOrSnapshot
+  fixing tsgo TS4058/TS4023 errors when MST types appear in exported function return types
+
+## Error message changes
+
+Validation and conversion errors have been reworked to stay readable on large state
+trees. Upstream MST could throw error messages hundreds of kilobytes long because it
+expanded every union member's full structure and stringified entire snapshots unbounded.
+This fork keeps the errors short while making them more diagnosable.
+
+### Bounded conversion errors
+
+`typecheck()` / instantiation errors no longer dump unbounded output:
+
+- Stringified snapshots are depth-bound (nested objects past 3 levels collapse to `…`)
+- Each printed value is capped in length
+- At most 10 individual errors are reported, with a `(… and N more errors)` suffix
+
+### Scoped discriminated-union errors
+
+Take a union of view types discriminated by a literal `type` property:
+
+```ts
+const LinearGenomeView = types.model("LinearGenomeView", {
+  type: types.literal("LinearGenomeView"),
+  height: types.number,
+  assembly: types.string
+})
+const DotplotView = types.model("DotplotView", {
+  type: types.literal("DotplotView"),
+  height: types.number
+})
+const AnyView = types.union(LinearGenomeView, DotplotView)
+```
+
+Upstream MST listed every member's full structure on any failure. A single mistyped field
+produced output like this — each member's entire schema expanded inline, repeated for every
+member, often hundreds of kilobytes on a real config union:
+
+```
+No matching type for union(LinearGenomeView | DotplotView)
+(snapshot `{"type":"LinearGenomeView","height":"tall","assembly":"hg38"}` is not assignable
+to type: `({ type: ("LinearGenomeView" | snapshot like `"LinearGenomeView"`); height: number;
+assembly: string } | { type: ("DotplotView" | snapshot like `"DotplotView"`); height: number })`,
+expected an instance of `LinearGenomeView` or a snapshot like `{ type: ("LinearGenomeView" |
+snapshot like `"LinearGenomeView"`); height: number; assembly: string }` instead. … )
+```
+
+Now the error is scoped to the single member whose literal `type` matches the snapshot's
+discriminator, and reports only the property-level reasons it failed.
+
+`AnyView.create({ type: "LinearGenomeView", height: "tall", assembly: "hg38" })` throws:
+
+```
+[mobx-state-tree] Error while converting `{"type":"LinearGenomeView","height":"tall","assembly":"hg38"}` to `(LinearGenomeView | DotplotView)`:
+
+    at path "/height" value `"tall"` is not assignable to type: `number` (Value is not a number).
+```
+
+And in production builds (where full type-checking is skipped) a missing required field on a
+recognized member still names the discriminator and the offending path —
+`AnyView.create({ type: "LinearGenomeView", height: 100 })` throws:
+
+```
+[mobx-state-tree] No matching type for union (LinearGenomeView | DotplotView) for snapshot with type "LinearGenomeView":
+    at path "/assembly" value `undefined` is not assignable to type: `string` (Value is not a string).
+```
+
+Instead of a wall of text covering every union member, you get the discriminator that was
+seen plus the property-level reasons that one intended member rejected the snapshot (wrong
+field type, missing required field, etc.). The scoping drills through wrapped members
+(`optional`, `refinement`, `snapshotProcessor`, `late`) to find the underlying model, so
+real-world members like an `optional(model)` config schema are still matched correctly.
+When two members declare the same `type` literal (ambiguous), it falls back to the short
+message rather than guessing.
+
+## Added APIs
+
+### `types.resilient`
+
+Wraps a type so that if instantiation fails (e.g. because the snapshot is from an unknown
+plugin that is not installed), the error is caught and a fallback type is used instead of
+crashing the entire state tree.
+
+```ts
+const PluginWidget = types.resilient(
+  KnownWidget,
+  UnknownWidget,
+  (error, originalSnapshot) => ({ kind: "unknown", raw: originalSnapshot })
+)
+
+// Arrays of plugins stay alive even if one entry is unrecognized
+const Store = types.model({
+  widgets: types.array(PluginWidget)
+})
+```
+
+`types.resilient` takes three arguments:
+
+- `type` — the primary type to try first
+- `fallbackType` — the type to use when the primary fails
+- `createFallbackSnapshot(error, originalSnapshot)` — a callback that receives the caught
+  error and the original snapshot, and returns a valid snapshot for the fallback type
+
+**Important caveat:** `isValidSnapshot` always returns success for a resilient type. Any
+value is considered a valid snapshot — validation is deferred to instantiation time, where
+failures are caught and routed to the fallback.
+
+---
+
+### `types.stripDefault`
+
+Like `types.optional`, but omits the property key from the parent model's snapshot entirely
+when the value equals the default.
+
+#### Background: snapshots and `types.optional`
+
+In MST, a **snapshot** is the plain JSON representation of your model — what you'd get from
+`getSnapshot(model)` and what you'd pass to `Model.create(...)`. Snapshots are used for
+serialization, persistence, and undo/redo.
+
+`types.optional` lets you define a property with a default value so it can be omitted when
+creating a model:
+
+```ts
+const Settings = types.model({
+  theme: types.optional(types.string, "light")
+})
+
+const s = Settings.create() // theme is "light"
+getSnapshot(s) // { theme: "light" }
+```
+
+Even though `"light"` is just the default, it always appears in the snapshot. If you store
+or diff these snapshots, every instance carries that redundant data.
+
+#### What `types.stripDefault` does
+
+`types.stripDefault` works exactly like `types.optional` at runtime — the property gets its
+default when missing — but the key is **left out of the snapshot entirely** when the value
+equals the default:
+
+```ts
+const Settings = types.model({
+  theme: types.stripDefault(types.string, "light")
+})
+
+const s = Settings.create()
+getSnapshot(s) // {}  ← key omitted because value equals default
+
+s.theme = "dark"
+getSnapshot(s) // { theme: "dark" }
+
+s.theme = "light"
+getSnapshot(s) // {}  ← omitted again
+```
+
+#### Why this matters
+
+Without `stripDefault`, keeping defaults out of snapshots requires a manual
+`postProcessSnapshot` on every model. `stripDefault` handles this automatically per-property.
+
+This is especially useful when:
+
+- Snapshots are stored or synced and you want to minimize their size
+- You diff snapshots (e.g. for undo/redo or change detection) and want default values to
+  appear as "no change" rather than an explicit write
+- You have many optional fields and don't want boilerplate `postProcessSnapshot`
+
+#### How the default comparison works
+
+The comparison is done against the **normalized** default snapshot, not the raw value you
+passed in. MST instantiates the subtype with the default once, reads back its snapshot
+(which applies any nested model defaults and post-processing), and caches that as the
+reference. This means a complex nested default that gains extra fields at instantiation time
+will still compare correctly.
+
+---
+
+### Reflection API additions
+
+These utilities expose type metadata that is useful for building generic tooling (e.g.
+editors, inspectors, plugin systems) that need to introspect an MST type at runtime.
+
+**`getChildType(node, propertyName?)`** — returns the declared MST type of a child
+property on a model, array, or map instance. For arrays and maps the property name is
+ignored (all children share one element type).
+
+```ts
+const Box = types.model({ x: types.number, y: types.number })
+const box = Box.create({ x: 1, y: 2 })
+
+getChildType(box, "x").name // "number"
+```
+
+**`getUnionSubtypes(type)`** — given a `types.union` type, returns the array of its member
+types. Useful when you need to enumerate what a union can hold.
+
+```ts
+const Shape = types.union(Circle, Square, Triangle)
+
+getUnionSubtypes(Shape) // [Circle, Square, Triangle]
+```
+
+**`getDefaultInstanceOrSnapshot(optionalType)`** — returns the default value (or snapshot)
+declared on a `types.optional` or `types.stripDefault` type. Lets generic tooling read the
+default without having to create a model instance.
+
+```ts
+const t = types.optional(types.string, "hello")
+
+t.getDefaultInstanceOrSnapshot() // "hello"
+```

package/dist/index.d.ts

@@ -1284,52 +1284,6 @@ interface IAnyStateTreeNode extends STNValue<any, IAnyType> {
  */
 declare function isStateTreeNode<IT extends IAnyComplexType = IAnyComplexType>(value: any): value is STNValue<Instance<IT>, IT>;
 
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<R>(generator: () => IterableIterator<any>): () => Promise<R>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1>(generator: (a1: A1) => IterableIterator<any>): (a1: A1) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2>(generator: (a1: A1, a2: A2) => IterableIterator<any>): (a1: A1, a2: A2) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3>(generator: (a1: A1, a2: A2, a3: A3) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4>(generator: (a1: A1, a2: A2, a3: A3, a4: A4) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5, A6>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5, A6, A7>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5, A6, A7, A8>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => Promise<any>;
-
 /**
  * @hidden
  */
@@ -2185,5 +2139,5 @@ declare const types: {
     resilient: typeof resilient;
 };
 
-export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
+export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
 export type { $EmptyObjectBrand, CustomTypeOptions, IActionContext, IActionRecorder, IActionTrackingMiddleware2Call, IActionTrackingMiddleware2Hooks, IActionTrackingMiddlewareHooks, IAnyComplexType, IAnyModelType, IAnyStateTreeNode, IAnyType, IArrayType, IComplexType, IDisposer, IJsonPatch, IMSTArray, IMSTMap, IMapType, IMaybe, IMaybeIType, IMaybeNull, IMiddlewareEvent, IMiddlewareEventType, IMiddlewareHandler, IModelReflectionData, IModelReflectionPropertiesData, IModelType, IOptionalIType, IPatchRecorder, IReferenceType, IReversibleJsonPatch, ISerializedActionCall, ISimpleType, ISnapshotProcessor, ISnapshotProcessors, IStateTreeNode, IType, ITypeUnion, Instance, LivelinessMode, LivelynessMode, ModelActions, ModelCreationType, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPrimitive, ModelProperties, ModelPropertiesDeclaration, ModelPropertiesDeclarationToProperties, ModelSnapshotType, ModelSnapshotType2, OnReferenceInvalidated, OnReferenceInvalidatedEvent, OptionalDefaultValueOrFunction, ReferenceIdentifier, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, SnapshotIn, SnapshotOrInstance, SnapshotOut, TypeOfValue, TypeOrStateTreeNodeToStateTreeNode, UnionOptions, UnionStringArray, ValidOptionalValue, ValidOptionalValues, _CustomCSProcessor, _CustomJoin, _CustomOrOther, _NotCustomized };

package/dist/mobx-state-tree.cjs

@@ -1118,6 +1118,21 @@ class ScalarNode extends BaseNode {
 ScalarNode.prototype.die = mobx.action(ScalarNode.prototype.die);
 
 let nextNodeId = 1;
+var ObservableInstanceLifecycle;
+(function (ObservableInstanceLifecycle) {
+    // the actual observable instance has not been created yet
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["UNINITIALIZED"] = 0] = "UNINITIALIZED";
+    // the actual observable instance is being created
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["CREATING"] = 1] = "CREATING";
+    // the actual observable instance has been created
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["CREATED"] = 2] = "CREATED";
+})(ObservableInstanceLifecycle || (ObservableInstanceLifecycle = {}));
+var InternalEvents;
+(function (InternalEvents) {
+    InternalEvents["Dispose"] = "dispose";
+    InternalEvents["Patch"] = "patch";
+    InternalEvents["Snapshot"] = "snapshot";
+})(InternalEvents || (InternalEvents = {}));
 const snapshotReactionOptions = {
     onError(e) {
         throw e;
@@ -1149,7 +1164,7 @@ class ObjectNode extends BaseNode {
     _autoUnbox = true; // unboxing is disabled when reading child nodes
     _isRunningAction = false; // only relevant for root
     _hasSnapshotReaction = false;
-    _observableInstanceState = 0 /* ObservableInstanceLifecycle.UNINITIALIZED */;
+    _observableInstanceState = ObservableInstanceLifecycle.UNINITIALIZED;
     _childNodes;
     _initialSnapshot;
     _cachedInitialSnapshot;
@@ -1194,7 +1209,7 @@ class ObjectNode extends BaseNode {
     }
     createObservableInstanceIfNeeded(fireHooks = true) {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             this.createObservableInstance(fireHooks);
         }
     }
@@ -1205,7 +1220,7 @@ class ObjectNode extends BaseNode {
                 throw fail("assertion failed: the creation of the observable instance must be done on the initializing phase");
             }
         }
-        this._observableInstanceState = 1 /* ObservableInstanceLifecycle.CREATING */;
+        this._observableInstanceState = ObservableInstanceLifecycle.CREATING;
         // make sure the parent chain is created as well
         // array with parent chain from parent to child
         const parentChain = [];
@@ -1215,7 +1230,7 @@ class ObjectNode extends BaseNode {
         // this is done to avoid traversing the whole tree to the root when using
         // the same reference again
         while (parent?._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             parentChain.unshift(parent);
             parent = parent.parent;
         }
@@ -1240,7 +1255,7 @@ class ObjectNode extends BaseNode {
         finally {
             this._isRunningAction = false;
         }
-        this._observableInstanceState = 2 /* ObservableInstanceLifecycle.CREATED */;
+        this._observableInstanceState = ObservableInstanceLifecycle.CREATED;
         this._snapshotComputed.trackAndCompute();
         if (this.isRoot) {
             this._addSnapshotReaction();
@@ -1354,7 +1369,7 @@ class ObjectNode extends BaseNode {
         if (!this.isAlive) {
             return this._snapshotUponDeath;
         }
-        return this._observableInstanceState === 2 /* ObservableInstanceLifecycle.CREATED */
+        return this._observableInstanceState === ObservableInstanceLifecycle.CREATED
             ? this._getActualSnapshot()
             : this._getCachedInitialSnapshot();
     }
@@ -1417,7 +1432,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildNode(this, subpath)
                 : this._childNodes[subpath];
         }
@@ -1430,7 +1445,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildren(this)
                 : convertChildNodesToArray(this._childNodes);
         }
@@ -1516,7 +1531,7 @@ class ObjectNode extends BaseNode {
     }
     aboutToDie() {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             return;
         }
         this.getChildren().forEach(node => {
@@ -1525,8 +1540,8 @@ class ObjectNode extends BaseNode {
         // beforeDestroy should run before the disposers since else we could end up in a situation where
         // a disposer added with addDisposer at this stage (beforeDestroy) is actually never released
         this.baseAboutToDie();
-        this._internalEventsEmit("dispose" /* InternalEvents.Dispose */);
-        this._internalEventsClear("dispose" /* InternalEvents.Dispose */);
+        this._internalEventsEmit(InternalEvents.Dispose);
+        this._internalEventsClear(InternalEvents.Dispose);
     }
     finalizeDeath() {
         // invariant: not called directly but from "die"
@@ -1542,42 +1557,42 @@ class ObjectNode extends BaseNode {
     }
     onSnapshot(onChange) {
         this._addSnapshotReaction();
-        return this._internalEventsRegister("snapshot" /* InternalEvents.Snapshot */, onChange);
+        return this._internalEventsRegister(InternalEvents.Snapshot, onChange);
     }
     emitSnapshot(snapshot) {
-        this._internalEventsEmit("snapshot" /* InternalEvents.Snapshot */, snapshot);
+        this._internalEventsEmit(InternalEvents.Snapshot, snapshot);
     }
     onPatch(handler) {
-        return this._internalEventsRegister("patch" /* InternalEvents.Patch */, handler);
+        return this._internalEventsRegister(InternalEvents.Patch, handler);
     }
     emitPatch(basePatch, source) {
-        if (this._internalEventsHasSubscribers("patch" /* InternalEvents.Patch */)) {
+        if (this._internalEventsHasSubscribers(InternalEvents.Patch)) {
             const localizedPatch = {
                 ...basePatch,
-                path: `${source.path.substr(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
+                path: `${source.path.slice(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
             };
             const [patch, reversePatch] = splitPatch(localizedPatch);
-            this._internalEventsEmit("patch" /* InternalEvents.Patch */, patch, reversePatch);
+            this._internalEventsEmit(InternalEvents.Patch, patch, reversePatch);
         }
         if (this.parent) {
             this.parent.emitPatch(basePatch, source);
         }
     }
     hasDisposer(disposer) {
-        return this._internalEventsHas("dispose" /* InternalEvents.Dispose */, disposer);
+        return this._internalEventsHas(InternalEvents.Dispose, disposer);
     }
     addDisposer(disposer) {
         if (!this.hasDisposer(disposer)) {
-            this._internalEventsRegister("dispose" /* InternalEvents.Dispose */, disposer, true);
+            this._internalEventsRegister(InternalEvents.Dispose, disposer, true);
             return;
         }
         throw fail("cannot add a disposer when it is already registered for execution");
     }
     removeDisposer(disposer) {
-        if (!this._internalEventsHas("dispose" /* InternalEvents.Dispose */, disposer)) {
+        if (!this._internalEventsHas(InternalEvents.Dispose, disposer)) {
             throw fail("cannot remove a disposer which was never registered for execution");
         }
-        this._internalEventsUnregister("dispose" /* InternalEvents.Dispose */, disposer);
+        this._internalEventsUnregister(InternalEvents.Dispose, disposer);
     }
     removeMiddleware(middleware) {
         if (this.middlewares) {
@@ -2567,22 +2582,47 @@ function isActionContextThisOrChildOf(actionContext, parentOrThis) {
 }
 
 const MAX_STRINGIFY_DEPTH = 3;
+const MAX_STRINGIFY_ARRAY_ITEMS = 10;
+const MAX_STRINGIFY_OBJECT_KEYS = 20;
+const MAX_STRINGIFY_STRING_LENGTH = 100;
+// Recursively cap depth, array length, object key count, and string length so a
+// huge offending snapshot degrades into readable, bounded context instead of a
+// wall of text that then gets sliced mid-structure. The depth cap also bounds
+// recursion on circular structures.
+function truncateForStringify(value, depth) {
+    if (typeof value === "string") {
+        return value.length > MAX_STRINGIFY_STRING_LENGTH
+            ? `${value.substring(0, MAX_STRINGIFY_STRING_LENGTH)}… (${value.length - MAX_STRINGIFY_STRING_LENGTH} more characters)`
+            : value;
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (depth >= MAX_STRINGIFY_DEPTH) {
+        return Array.isArray(value) ? "[…]" : "{…}";
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_STRINGIFY_ARRAY_ITEMS)
+            .map(item => truncateForStringify(item, depth + 1));
+        if (value.length > MAX_STRINGIFY_ARRAY_ITEMS) {
+            items.push(`… ${value.length - MAX_STRINGIFY_ARRAY_ITEMS} more items`);
+        }
+        return items;
+    }
+    const keys = Object.keys(value);
+    const result = {};
+    for (const key of keys.slice(0, MAX_STRINGIFY_OBJECT_KEYS)) {
+        result[key] = truncateForStringify(value[key], depth + 1);
+    }
+    if (keys.length > MAX_STRINGIFY_OBJECT_KEYS) {
+        result["…"] = `${keys.length - MAX_STRINGIFY_OBJECT_KEYS} more keys`;
+    }
+    return result;
+}
 function safeStringify(value) {
     try {
-        const ancestors = [];
-        return JSON.stringify(value, function (_key, val) {
-            if (val !== null && typeof val === "object") {
-                while (ancestors.length > 0 &&
-                    ancestors[ancestors.length - 1] !== this) {
-                    ancestors.pop();
-                }
-                if (ancestors.length >= MAX_STRINGIFY_DEPTH) {
-                    return Array.isArray(val) ? "[…]" : "{…}";
-                }
-                ancestors.push(val);
-            }
-            return val;
-        });
+        return JSON.stringify(truncateForStringify(value, 0));
     }
     catch (e) {
         // istanbul ignore next
@@ -3013,31 +3053,6 @@ function convertChildNodesToArray(childNodes) {
     return result;
 }
 
-// based on: https://github.com/mobxjs/mobx-utils/blob/master/src/async-action.ts
-/*
-    All contents of this file are deprecated.
-
-    The term `process` has been replaced with `flow` to avoid conflicts with the
-    global `process` object.
-
-    Refer to `flow.ts` for any further changes to this implementation.
-*/
-const DEPRECATION_MESSAGE = "See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information. " +
-    "Note that the middleware event types starting with `process` now start with `flow`.";
-/**
- * @hidden
- *
- * @deprecated has been renamed to `flow()`.
- * See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information.
- * Note that the middleware event types starting with `process` now start with `flow`.
- *
- * @returns {Promise}
- */
-function process$1(asyncAction) {
-    deprecated("process", `\`process()\` has been renamed to \`flow()\`. ${DEPRECATION_MESSAGE}`);
-    return flow(asyncAction);
-}
-
 const plainObjectString = Object.toString();
 /**
  * @internal
@@ -3328,25 +3343,6 @@ class EventHandlers {
         }
     }
 }
-/**
- * @internal
- * @hidden
- */
-const deprecated = function (id, message) {
-    // skip if running production
-    if (!devMode()) {
-        return;
-    }
-    // warn if hasn't been warned before
-    if (deprecated.ids && !deprecated.ids.hasOwnProperty(id)) {
-        warnError(`Deprecation warning: ${message}`);
-    }
-    // mark as warned to avoid duplicate warn message
-    if (deprecated.ids) {
-        deprecated.ids[id] = true;
-    }
-};
-deprecated.ids = {};
 /**
  * @internal
  * @hidden
@@ -4299,9 +4295,9 @@ class ArrayType extends ComplexType {
         return node.storedValue.slice();
     }
     getChildNode(node, key) {
-        const index = Number(key);
-        if (index < node.storedValue.length) {
-            return node.storedValue[index];
+        const child = node.storedValue[Number(key)];
+        if (child) {
+            return child;
         }
         throw fail(`Not a child: ${key}`);
     }
@@ -4468,7 +4464,7 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
             // both are empty, end
             break;
         }
-        else if (!hasNewNode) {
+        else if (oldNode && !hasNewNode) {
             // new one does not exists
             nothingChanged = false;
             oldNodes.splice(i, 1);
@@ -5901,6 +5897,18 @@ function defaultSnapshotEquals(a, b) {
         a !== null &&
         typeof b === "object" &&
         b !== null) {
+        // Cheap structural short-circuit before the full stringify compare: a
+        // value of a different size can't equal the default, so the common strip
+        // case (non-empty value vs an empty `[]`/`{}` default) avoids stringifying
+        // a potentially large snapshot on every getSnapshot.
+        if (Array.isArray(a) !== Array.isArray(b)) {
+            return false;
+        }
+        const aSize = Array.isArray(a) ? a.length : Object.keys(a).length;
+        const bSize = Array.isArray(b) ? b.length : Object.keys(b).length;
+        if (aSize !== bSize) {
+            return false;
+        }
         return JSON.stringify(a) === JSON.stringify(b);
     }
     return false;
@@ -7056,7 +7064,6 @@ exports.joinJsonPath = joinJsonPath;
 exports.onAction = onAction;
 exports.onPatch = onPatch;
 exports.onSnapshot = onSnapshot;
-exports.process = process$1;
 exports.protect = protect;
 exports.recordActions = recordActions;
 exports.recordPatches = recordPatches;