@jbrowse/mobx-state-tree 5.5.0 → 5.6.0

package/dist/internal.d.ts

@@ -35,4 +35,5 @@ export * from "./types/utility-types/frozen.ts";
 export * from "./types/utility-types/reference.ts";
 export * from "./types/utility-types/identifier.ts";
 export * from "./types/utility-types/custom.ts";
+export * from "./types/utility-types/resilient.ts";
 export * from "./types/index.ts";

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,mCAAmC,CAAA;AACjD,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,oDAAoD,CAAA;AAClE,cAAc,kDAAkD,CAAA;AAChE,cAAc,4BAA4B,CAAA;AAC1C,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,4CAA4C,CAAA;AAC1D,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,uBAAuB,CAAA;AACrC,cAAc,kCAAkC,CAAA;AAChD,cAAc,qCAAqC,CAAA;AACnD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,mCAAmC,CAAA;AACjD,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,oDAAoD,CAAA;AAClE,cAAc,kDAAkD,CAAA;AAChE,cAAc,4BAA4B,CAAA;AAC1C,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,4CAA4C,CAAA;AAC1D,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,uBAAuB,CAAA;AACrC,cAAc,kCAAkC,CAAA;AAChD,cAAc,qCAAqC,CAAA;AACnD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,kBAAkB,CAAA"}

package/dist/mobx-state-tree.js

@@ -6638,6 +6638,122 @@ class CustomType extends SimpleType {
     }
 }
 
+class Resilient extends BaseType {
+    _subtype;
+    _fallbackType;
+    _createFallbackSnapshot;
+    get flags() {
+        return this._subtype.flags;
+    }
+    constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
+        super(`resilient(${_subtype.name})`);
+        this._subtype = _subtype;
+        this._fallbackType = _fallbackType;
+        this._createFallbackSnapshot = _createFallbackSnapshot;
+    }
+    describe() {
+        return `resilient(${this._subtype.describe()})`;
+    }
+    _instantiateFallback(parent, subpath, environment, originalSnapshot, originalError) {
+        let fallbackSnapshot;
+        try {
+            fallbackSnapshot = this._createFallbackSnapshot(originalError, originalSnapshot);
+        }
+        catch (e) {
+            throw fail(`resilient: createFallbackSnapshot threw while handling error for '${this._subtype.name}': ${originalError}. createFallbackSnapshot error: ${e}`);
+        }
+        try {
+            return this._fallbackType.instantiate(parent, subpath, environment, fallbackSnapshot);
+        }
+        catch (e) {
+            throw fail(`resilient: fallback type '${this._fallbackType.name}' failed to instantiate while handling error for '${this._subtype.name}': ${originalError}. Fallback error: ${e}`);
+        }
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        if (isStateTreeNode(initialValue)) {
+            return this._subtype.instantiate(parent, subpath, environment, initialValue);
+        }
+        try {
+            return this._subtype.instantiate(parent, subpath, environment, initialValue);
+        }
+        catch (e) {
+            return this._instantiateFallback(parent, subpath, environment, initialValue, e);
+        }
+    }
+    reconcile(current, newValue, parent, subpath) {
+        if (isStateTreeNode(newValue)) {
+            return this._subtype.reconcile(current, newValue, parent, subpath);
+        }
+        if (this._fallbackType.isAssignableFrom(current.type)) {
+            try {
+                return this._subtype.instantiate(parent, subpath, undefined, newValue);
+            }
+            catch (e) {
+                return this._fallbackType.reconcile(current, this._createFallbackSnapshot(e, newValue), parent, subpath);
+            }
+        }
+        try {
+            return this._subtype.reconcile(current, newValue, parent, subpath);
+        }
+        catch (e) {
+            current.die();
+            return this._instantiateFallback(parent, subpath, undefined, newValue, e);
+        }
+    }
+    isValidSnapshot(_value, _context) {
+        return typeCheckSuccess();
+    }
+    is(thing) {
+        if (isType(thing)) {
+            return (this._subtype.isAssignableFrom(thing) ||
+                this._fallbackType.isAssignableFrom(thing));
+        }
+        try {
+            if (this._subtype.is(thing)) {
+                return true;
+            }
+        }
+        catch (_e) {
+            // subtype.is() may throw (e.g. union dispatcher)
+        }
+        try {
+            return this._fallbackType.is(thing);
+        }
+        catch (_e) {
+            return false;
+        }
+    }
+    isAssignableFrom(type) {
+        return (this._subtype.isAssignableFrom(type) ||
+            this._fallbackType.isAssignableFrom(type));
+    }
+    getSubTypes() {
+        return [this._subtype, this._fallbackType];
+    }
+    getSnapshot(node) {
+        return node.snapshot;
+    }
+}
+/**
+ * `types.resilient` - Wraps a type so that instantiation errors are caught
+ * and a fallback type is used instead. This is useful for loading data that
+ * may contain unknown or invalid subtrees (e.g., plugin types that are not
+ * installed) without crashing the entire state tree.
+ *
+ * The `createFallbackSnapshot` callback receives the caught error and the
+ * original snapshot, and must return a valid snapshot for the fallback type.
+ *
+ * @param type The type to wrap.
+ * @param fallbackType The fallback type to use when instantiation fails.
+ * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.
+ * @returns A resilient type.
+ */
+function resilient(type, fallbackType, createFallbackSnapshot) {
+    assertIsType(type, 1);
+    assertIsType(fallbackType, 2);
+    return new Resilient(type, fallbackType, createFallbackSnapshot);
+}
+
 // we import the types to re-export them inside types.
 const types = {
     enumeration,
@@ -6668,7 +6784,8 @@ const types = {
     lazy,
     undefined: undefinedType,
     null: nullType,
-    snapshotProcessor
+    snapshotProcessor,
+    resilient
 };
 
 exports.addDisposer = addDisposer;

package/dist/mobx-state-tree.module.js

@@ -6636,6 +6636,122 @@ class CustomType extends SimpleType {
     }
 }
 
+class Resilient extends BaseType {
+    _subtype;
+    _fallbackType;
+    _createFallbackSnapshot;
+    get flags() {
+        return this._subtype.flags;
+    }
+    constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
+        super(`resilient(${_subtype.name})`);
+        this._subtype = _subtype;
+        this._fallbackType = _fallbackType;
+        this._createFallbackSnapshot = _createFallbackSnapshot;
+    }
+    describe() {
+        return `resilient(${this._subtype.describe()})`;
+    }
+    _instantiateFallback(parent, subpath, environment, originalSnapshot, originalError) {
+        let fallbackSnapshot;
+        try {
+            fallbackSnapshot = this._createFallbackSnapshot(originalError, originalSnapshot);
+        }
+        catch (e) {
+            throw fail(`resilient: createFallbackSnapshot threw while handling error for '${this._subtype.name}': ${originalError}. createFallbackSnapshot error: ${e}`);
+        }
+        try {
+            return this._fallbackType.instantiate(parent, subpath, environment, fallbackSnapshot);
+        }
+        catch (e) {
+            throw fail(`resilient: fallback type '${this._fallbackType.name}' failed to instantiate while handling error for '${this._subtype.name}': ${originalError}. Fallback error: ${e}`);
+        }
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        if (isStateTreeNode(initialValue)) {
+            return this._subtype.instantiate(parent, subpath, environment, initialValue);
+        }
+        try {
+            return this._subtype.instantiate(parent, subpath, environment, initialValue);
+        }
+        catch (e) {
+            return this._instantiateFallback(parent, subpath, environment, initialValue, e);
+        }
+    }
+    reconcile(current, newValue, parent, subpath) {
+        if (isStateTreeNode(newValue)) {
+            return this._subtype.reconcile(current, newValue, parent, subpath);
+        }
+        if (this._fallbackType.isAssignableFrom(current.type)) {
+            try {
+                return this._subtype.instantiate(parent, subpath, undefined, newValue);
+            }
+            catch (e) {
+                return this._fallbackType.reconcile(current, this._createFallbackSnapshot(e, newValue), parent, subpath);
+            }
+        }
+        try {
+            return this._subtype.reconcile(current, newValue, parent, subpath);
+        }
+        catch (e) {
+            current.die();
+            return this._instantiateFallback(parent, subpath, undefined, newValue, e);
+        }
+    }
+    isValidSnapshot(_value, _context) {
+        return typeCheckSuccess();
+    }
+    is(thing) {
+        if (isType(thing)) {
+            return (this._subtype.isAssignableFrom(thing) ||
+                this._fallbackType.isAssignableFrom(thing));
+        }
+        try {
+            if (this._subtype.is(thing)) {
+                return true;
+            }
+        }
+        catch (_e) {
+            // subtype.is() may throw (e.g. union dispatcher)
+        }
+        try {
+            return this._fallbackType.is(thing);
+        }
+        catch (_e) {
+            return false;
+        }
+    }
+    isAssignableFrom(type) {
+        return (this._subtype.isAssignableFrom(type) ||
+            this._fallbackType.isAssignableFrom(type));
+    }
+    getSubTypes() {
+        return [this._subtype, this._fallbackType];
+    }
+    getSnapshot(node) {
+        return node.snapshot;
+    }
+}
+/**
+ * `types.resilient` - Wraps a type so that instantiation errors are caught
+ * and a fallback type is used instead. This is useful for loading data that
+ * may contain unknown or invalid subtrees (e.g., plugin types that are not
+ * installed) without crashing the entire state tree.
+ *
+ * The `createFallbackSnapshot` callback receives the caught error and the
+ * original snapshot, and must return a valid snapshot for the fallback type.
+ *
+ * @param type The type to wrap.
+ * @param fallbackType The fallback type to use when instantiation fails.
+ * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.
+ * @returns A resilient type.
+ */
+function resilient(type, fallbackType, createFallbackSnapshot) {
+    assertIsType(type, 1);
+    assertIsType(fallbackType, 2);
+    return new Resilient(type, fallbackType, createFallbackSnapshot);
+}
+
 // we import the types to re-export them inside types.
 const types = {
     enumeration,
@@ -6666,7 +6782,8 @@ const types = {
     lazy,
     undefined: undefinedType,
     null: nullType,
-    snapshotProcessor
+    snapshotProcessor,
+    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, 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$1 as process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };

package/dist/mobx-state-tree.umd.js

@@ -6640,6 +6640,122 @@
         }
     }
 
+    class Resilient extends BaseType {
+        _subtype;
+        _fallbackType;
+        _createFallbackSnapshot;
+        get flags() {
+            return this._subtype.flags;
+        }
+        constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
+            super(`resilient(${_subtype.name})`);
+            this._subtype = _subtype;
+            this._fallbackType = _fallbackType;
+            this._createFallbackSnapshot = _createFallbackSnapshot;
+        }
+        describe() {
+            return `resilient(${this._subtype.describe()})`;
+        }
+        _instantiateFallback(parent, subpath, environment, originalSnapshot, originalError) {
+            let fallbackSnapshot;
+            try {
+                fallbackSnapshot = this._createFallbackSnapshot(originalError, originalSnapshot);
+            }
+            catch (e) {
+                throw fail(`resilient: createFallbackSnapshot threw while handling error for '${this._subtype.name}': ${originalError}. createFallbackSnapshot error: ${e}`);
+            }
+            try {
+                return this._fallbackType.instantiate(parent, subpath, environment, fallbackSnapshot);
+            }
+            catch (e) {
+                throw fail(`resilient: fallback type '${this._fallbackType.name}' failed to instantiate while handling error for '${this._subtype.name}': ${originalError}. Fallback error: ${e}`);
+            }
+        }
+        instantiate(parent, subpath, environment, initialValue) {
+            if (isStateTreeNode(initialValue)) {
+                return this._subtype.instantiate(parent, subpath, environment, initialValue);
+            }
+            try {
+                return this._subtype.instantiate(parent, subpath, environment, initialValue);
+            }
+            catch (e) {
+                return this._instantiateFallback(parent, subpath, environment, initialValue, e);
+            }
+        }
+        reconcile(current, newValue, parent, subpath) {
+            if (isStateTreeNode(newValue)) {
+                return this._subtype.reconcile(current, newValue, parent, subpath);
+            }
+            if (this._fallbackType.isAssignableFrom(current.type)) {
+                try {
+                    return this._subtype.instantiate(parent, subpath, undefined, newValue);
+                }
+                catch (e) {
+                    return this._fallbackType.reconcile(current, this._createFallbackSnapshot(e, newValue), parent, subpath);
+                }
+            }
+            try {
+                return this._subtype.reconcile(current, newValue, parent, subpath);
+            }
+            catch (e) {
+                current.die();
+                return this._instantiateFallback(parent, subpath, undefined, newValue, e);
+            }
+        }
+        isValidSnapshot(_value, _context) {
+            return typeCheckSuccess();
+        }
+        is(thing) {
+            if (isType(thing)) {
+                return (this._subtype.isAssignableFrom(thing) ||
+                    this._fallbackType.isAssignableFrom(thing));
+            }
+            try {
+                if (this._subtype.is(thing)) {
+                    return true;
+                }
+            }
+            catch (_e) {
+                // subtype.is() may throw (e.g. union dispatcher)
+            }
+            try {
+                return this._fallbackType.is(thing);
+            }
+            catch (_e) {
+                return false;
+            }
+        }
+        isAssignableFrom(type) {
+            return (this._subtype.isAssignableFrom(type) ||
+                this._fallbackType.isAssignableFrom(type));
+        }
+        getSubTypes() {
+            return [this._subtype, this._fallbackType];
+        }
+        getSnapshot(node) {
+            return node.snapshot;
+        }
+    }
+    /**
+     * `types.resilient` - Wraps a type so that instantiation errors are caught
+     * and a fallback type is used instead. This is useful for loading data that
+     * may contain unknown or invalid subtrees (e.g., plugin types that are not
+     * installed) without crashing the entire state tree.
+     *
+     * The `createFallbackSnapshot` callback receives the caught error and the
+     * original snapshot, and must return a valid snapshot for the fallback type.
+     *
+     * @param type The type to wrap.
+     * @param fallbackType The fallback type to use when instantiation fails.
+     * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.
+     * @returns A resilient type.
+     */
+    function resilient(type, fallbackType, createFallbackSnapshot) {
+        assertIsType(type, 1);
+        assertIsType(fallbackType, 2);
+        return new Resilient(type, fallbackType, createFallbackSnapshot);
+    }
+
     // we import the types to re-export them inside types.
     const types = {
         enumeration,
@@ -6670,7 +6786,8 @@
         lazy,
         undefined: undefinedType,
         null: nullType,
-        snapshotProcessor
+        snapshotProcessor,
+        resilient
     };
 
     exports.addDisposer = addDisposer;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import { array, compose, custom, enumeration, frozen, late, lazy, literal, map, maybe, maybeNull, model, optional, reference, refinement, safeReference, snapshotProcessor, union } from "../internal.ts";
+import { array, compose, custom, enumeration, frozen, late, lazy, literal, map, maybe, maybeNull, model, optional, reference, refinement, safeReference, resilient, snapshotProcessor, union } from "../internal.ts";
 export declare const types: {
     enumeration: typeof enumeration;
     model: typeof model;
@@ -29,4 +29,5 @@ export declare const types: {
     undefined: import("../internal.ts").ISimpleType<undefined>;
     null: import("../internal.ts").ISimpleType<null>;
     snapshotProcessor: typeof snapshotProcessor;
+    resilient: typeof resilient;
 };

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,OAAO,EACL,aAAa,EACb,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,KAAK,EACL,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,GAAG,EACH,KAAK,EACL,SAAS,EACT,KAAK,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,EACT,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,MAAM,EACN,aAAa,EACb,KAAK,EACN,MAAM,gBAAgB,CAAA;AAEvB,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,WAAW;IACX,KAAK;IACL,OAAO;IACP,MAAM;IACN,SAAS;IACT,aAAa;IACb,KAAK;IACL,QAAQ;IACR,OAAO;IACP,KAAK;IACL,SAAS;IACT,UAAU;IACV,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,KAAK;IACL,MAAM;IACN,IAAI,EAAE,aAAa;IACnB,GAAG;IACH,KAAK;IACL,MAAM;IACN,UAAU;IACV,gBAAgB;IAChB,IAAI;IACJ,IAAI;IACJ,SAAS,EAAE,aAAa;IACxB,IAAI,EAAE,QAAQ;IACd,iBAAiB;CAClB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,OAAO,EACL,aAAa,EACb,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,KAAK,EACL,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,GAAG,EACH,KAAK,EACL,SAAS,EACT,KAAK,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,EACT,UAAU,EACV,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,MAAM,EACN,aAAa,EACb,KAAK,EACN,MAAM,gBAAgB,CAAA;AAEvB,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,WAAW;IACX,KAAK;IACL,OAAO;IACP,MAAM;IACN,SAAS;IACT,aAAa;IACb,KAAK;IACL,QAAQ;IACR,OAAO;IACP,KAAK;IACL,SAAS;IACT,UAAU;IACV,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,KAAK;IACL,MAAM;IACN,IAAI,EAAE,aAAa;IACnB,GAAG;IACH,KAAK;IACL,MAAM;IACN,UAAU;IACV,gBAAgB;IAChB,IAAI;IACJ,IAAI;IACJ,SAAS,EAAE,aAAa;IACxB,IAAI,EAAE,QAAQ;IACd,iBAAiB;IACjB,SAAS;CACV,CAAA"}

package/dist/types/utility-types/resilient.d.ts

@@ -0,0 +1,18 @@
+import { type IAnyType, type IType } from "../../internal.ts";
+export interface IResilientType<IT extends IAnyType, FT extends IAnyType> extends IType<IT["CreationType"] | FT["CreationType"], IT["SnapshotType"] | FT["SnapshotType"], IT["TypeWithoutSTN"] | FT["TypeWithoutSTN"]> {
+}
+/**
+ * `types.resilient` - Wraps a type so that instantiation errors are caught
+ * and a fallback type is used instead. This is useful for loading data that
+ * may contain unknown or invalid subtrees (e.g., plugin types that are not
+ * installed) without crashing the entire state tree.
+ *
+ * The `createFallbackSnapshot` callback receives the caught error and the
+ * original snapshot, and must return a valid snapshot for the fallback type.
+ *
+ * @param type The type to wrap.
+ * @param fallbackType The fallback type to use when instantiation fails.
+ * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.
+ * @returns A resilient type.
+ */
+export declare function resilient<IT extends IAnyType, FT extends IAnyType>(type: IT, fallbackType: FT, createFallbackSnapshot: (error: unknown, snapshot: any) => FT["CreationType"]): IResilientType<IT, FT>;

package/dist/types/utility-types/resilient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilient.js","sourceRoot":"","sources":["../../../src/types/utility-types/resilient.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/mobx-state-tree",
-  "version": "5.5.0",
+  "version": "5.6.0",
   "description": "Fork of mobx-state-tree starting from v5.4.2 for use in jbrowse 2",
   "types": "dist/index.d.ts",
   "main": "dist/mobx-state-tree.js",
@@ -31,21 +31,22 @@
     "dist/"
   ],
   "devDependencies": {
-    "@types/node": "^24.10.1",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.0",
     "concat": "^1.0.3",
     "cpr": "^3.0.1",
     "cross-env": "^10.1.0",
-    "eslint": "^9.39.1",
+    "eslint": "^10.0.1",
     "eslint-plugin-import": "^2.32.0",
     "mobx": "^6.15.0",
-    "prettier": "^3.7.3",
-    "rimraf": "^6.1.2",
-    "rollup": "^4.53.3",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.59.0",
     "rollup-plugin-replace": "^2.2.0",
     "spec.ts": "^1.1.3",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.0",
-    "vitest": "^4.0.14"
+    "typescript-eslint": "^8.56.0",
+    "vitest": "^4.0.18"
   },
   "peerDependencies": {
     "mobx": "^6.3.0"