mobx-keystone 1.23.0 → 1.24.1

package/dist/types/modelShared/BaseModelShared.d.ts

@@ -2,7 +2,7 @@ import { AnyDataModel } from '../dataModel/BaseDataModel';
 import { AnyModel } from '../model/BaseModel';
 import { modelTypeKey } from '../model/metadata';
 import { Flatten, IsNeverType } from '../utils/types';
-import { ModelPropsToSnapshotCreationData, ModelPropsToSnapshotData, ModelPropsToTransformedCreationData, ModelPropsToTransformedData, ModelPropsToUntransformedCreationData } from './prop';
+import { ModelProps, ModelPropsToSnapshotCreationData, ModelPropsToSnapshotData, ModelPropsToTransformedCreationData, ModelPropsToTransformedData, ModelPropsToUntransformedCreationData } from './prop';
 /**
  * @ignore
  */
@@ -27,6 +27,12 @@ export interface ModelClass<M extends AnyModel | AnyDataModel> {
  * Extracts the instance type of an abstract model class.
  */
 export type AbstractModelClass<M extends AnyModel | AnyDataModel> = abstract new (initialData: any) => M;
+/**
+ * @ignore
+ */
+export interface ModelWithProps {
+    [propsTypeSymbol]: ModelProps;
+}
 /**
  * The props of a model.
  */

package/dist/types/modelShared/modelDecorator.d.ts

@@ -9,7 +9,7 @@ import { AnyFunction } from '../utils/AnyFunction';
  * @param name Unique name for the model type. Note that this name must be unique for your whole
  * application, so it is usually a good idea to use some prefix unique to your application domain.
  */
-export declare const model: (name: string) => <MC extends ModelClass<AnyModel | AnyDataModel>>(clazz: MC, ...args: any[]) => MC;
+export declare const model: (name: string) => <MC extends ModelClass<AnyModel | AnyDataModel>>(clazz: MC, _context?: ClassDecoratorContext<MC>) => MC;
 /**
  * Marks a class (which MUST inherit from the `Model` abstract class)
  * as a model and decorates some of its methods/properties.

package/dist/types/modelShared/prop.d.ts

@@ -7,6 +7,11 @@ import { Flatten, IsNeverType, IsOptionalValue } from '../utils/types';
 export declare const noDefaultValue: unique symbol;
 type SetterMode = boolean | "assign";
 export type ModelPropSetterValueTransform<T> = (value: T) => T;
+/** @ignore */
+export interface FullModelPropTransform {
+    transform: (original: unknown, model: object, propName: PropertyKey, setOriginalValue: (newOriginalValue: unknown) => void) => unknown;
+    untransform: (transformed: unknown, model: object, propName: PropertyKey) => unknown;
+}
 /**
  * A model property.
  */

package/dist/types/types/TypeChecker.d.ts

@@ -1,4 +1,78 @@
+import { Path } from '../parent/pathTypes';
 import { AnyStandardType } from './schemas';
+import { TypeCheckError } from './TypeCheckError';
+type CheckFunction = (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null;
+/** @ignore */
+export type SnapshotProcessor = (snapshot: any) => unknown;
+/**
+ * A lazily discovered snapshot-processor node. Dependencies are deliberately
+ * TypeCheckers rather than processors so recursive graphs can be discovered
+ * before any processor body is compiled.
+ *
+ * @ignore
+ */
+export interface SnapshotProcessorPlan {
+    readonly intrinsic?: boolean;
+    readonly getDependencies: () => ReadonlyArray<TypeChecker>;
+    readonly compile: (dependencyProcessors: ReadonlyArray<SnapshotProcessor | undefined>) => SnapshotProcessor | undefined;
+}
+type SnapshotProcessorSource = SnapshotProcessor | SnapshotProcessorPlan | undefined;
+type SnapshotProcessorDirection = "from" | "to";
+/** @ignore */
+export declare class SnapshotProcessorPlanNode {
+    private readonly owner;
+    private readonly direction;
+    private readonly source;
+    private presence;
+    private dependencies;
+    private discovering;
+    private compiling;
+    private compiled;
+    private compiledProcessor;
+    private forwardingProcessor;
+    constructor(owner: TypeChecker | undefined, direction: SnapshotProcessorDirection, source: SnapshotProcessorSource);
+    resolve(): SnapshotProcessor | undefined;
+    private discover;
+    private compile;
+    private compileForDependency;
+}
+/**
+ * @ignore
+ */
+export declare enum TypeCheckerBaseType {
+    Object = "object",
+    Array = "array",
+    Primitive = "primitive",
+    Any = "any"
+}
+/**
+ * @ignore
+ */
+export declare class TypeChecker {
+    unchecked: boolean;
+    skipCheck: boolean;
+    readonly baseType: TypeCheckerBaseType;
+    private readonly _check;
+    readonly getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string;
+    readonly typeInfoGen: TypeInfoGen;
+    readonly snapshotType: (sn: unknown) => TypeChecker | null;
+    private readonly fromSnapshotProcessorSource;
+    private readonly toSnapshotProcessorSource;
+    private fromSnapshotProcessorPlanNode;
+    private toSnapshotProcessorPlanNode;
+    check(value: any, path: Path, typeCheckedValue: any): TypeCheckError | null;
+    private _cachedTypeInfoGen;
+    get typeInfo(): TypeInfo;
+    constructor(baseType: TypeCheckerBaseType, _check: CheckFunction | null, getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string, typeInfoGen: TypeInfoGen, snapshotType: (sn: unknown) => TypeChecker | null, fromSnapshotProcessor: SnapshotProcessorSource, toSnapshotProcessor: SnapshotProcessorSource);
+    getSnapshotProcessorPlanNode(direction: SnapshotProcessorDirection): SnapshotProcessorPlanNode;
+    private resolveSnapshotProcessor;
+    getFromSnapshotProcessor(): SnapshotProcessor | undefined;
+    getToSnapshotProcessor(): SnapshotProcessor | undefined;
+    fromSnapshotProcessor: (sn: any) => unknown;
+    private readonly _toSnapshotProcessorCache;
+    invalidateSnapshotProcessorCachedResult(obj: object): void;
+    toSnapshotProcessor: (sn: any) => unknown;
+}
 /**
  * Type info base class.
  */
@@ -7,3 +81,8 @@ export declare class TypeInfo {
     readonly thisType: AnyStandardType;
     constructor(thisType: AnyStandardType);
 }
+/**
+ * @ignore
+ */
+export type TypeInfoGen = (t: AnyStandardType) => TypeInfo;
+export {};

package/dist/types/types/schemas.d.ts

@@ -3,6 +3,7 @@ import { AnyDataModel } from '../dataModel/BaseDataModel';
 import { AnyModel } from '../model/BaseModel';
 import { ModelClass } from '../modelShared/BaseModelShared';
 import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
+import { IsOptionalValue } from '../utils/types';
 export interface Type<Name, Data> {
     /** @ignore */
     $$type: Name;
@@ -36,6 +37,20 @@ export interface ObjectOfTypes {
     /** @ignore */
     [k: string]: AnyType;
 }
+/**
+ * Name of the properties of an object that can be set to undefined, any or unknown.
+ * @ignore
+ */
+export type UndefinablePropsNames<T> = {
+    [K in keyof T]: IsOptionalValue<T[K], K, never>;
+}[keyof T];
+/**
+ * Computes the optional keys for an object type schema.
+ * @ignore
+ */
+export type ObjectOptionalKeys<S> = UndefinablePropsNames<{
+    [k in keyof S]: TypeToDataOpt<S[k]> extends infer R ? R : never;
+}>;
 type ObjectData<S> = O.Optional<{
     [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never;
 }, ObjectOptionalKeys<S>>;

package/dist/types/utils/index.d.ts

@@ -4,3 +4,27 @@
 export declare class MobxKeystoneError extends Error {
     constructor(msg: string);
 }
+/**
+ * MobX method action decorator compatible with both legacy decorators and
+ * MobX 7's standard decorator API.
+ *
+ * This is a decorator compatibility helper, not a replacement for other
+ * `action` overloads such as `action(fn)`. Field decorators are not supported.
+ *
+ * @hidden
+ */
+export declare function mobxAction<This, Args extends unknown[], Return>(value: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>): (this: This, ...args: Args) => Return;
+export declare function mobxAction<This, Args extends unknown[], Return>(target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Return>): TypedPropertyDescriptor<(this: This, ...args: Args) => Return> | void;
+/**
+ * MobX getter computed decorator compatible with both legacy decorators and
+ * MobX 7's standard decorator API.
+ *
+ * This is a decorator compatibility helper, not a replacement for other
+ * `computed` overloads. Field decorators and decorator options are not supported.
+ * Under MobX 7's legacy decorator transform the getter is backed by a computed
+ * value, but is not registered as a computed property for MobX introspection.
+ *
+ * @hidden
+ */
+export declare function mobxComputed<This, Value>(value: (this: This) => Value, context: ClassGetterDecoratorContext<This, Value>): ((this: This) => Value) | void;
+export declare function mobxComputed<Value>(target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Value>): TypedPropertyDescriptor<Value> | void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "1.23.0",
+  "version": "1.24.1",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -54,7 +54,8 @@
     "quick-build": "tsc",
     "quick-build-tests": "tsc -p test",
     "copy-root-files": "shx cp ../../README.md . && shx cp ../../LICENSE . && shx cp ../../CHANGELOG.md .",
-    "build": "pnpm run quick-build && pnpm run copy-root-files && shx rm -rf dist && vite build && shx cp dist/mobx-keystone.esm.mjs dist/mobx-keystone.esm.js",
+    "build": "pnpm run quick-build && pnpm run copy-root-files && shx rm -rf dist && vite build && pnpm run check-declarations && shx cp dist/mobx-keystone.esm.mjs dist/mobx-keystone.esm.js",
+    "check-declarations": "tsc -p scripts/tsconfig.check-declarations.json",
     "test": "vitest run",
     "test:ci": "vitest run --coverage",
     "test:perf": "pnpm run build && pnpm run test:perf:run",
@@ -63,27 +64,30 @@
     "build-docs": "shx rm -rf api-docs && node --import ./scripts/typedoc-typescript6-register.mjs ./node_modules/typedoc/dist/cli.js --options ./typedocconfig.js src/index.ts && shx rm -rf ../../apps/site/generated-static/api && shx mkdir -p ../../apps/site/generated-static/api && shx cp -R ./api-docs/* ../../apps/site/generated-static/api"
   },
   "peerDependencies": {
-    "mobx": "^6.0.0 || ^5.0.0 || ^4.0.0"
+    "mobx": "^7.0.0 || ^6.0.0 || ^5.0.0 || ^4.0.0"
   },
   "devDependencies": {
     "@babel/core": "^8.0.1",
     "@babel/plugin-proposal-decorators": "^8.0.2",
     "@babel/plugin-transform-class-properties": "^8.0.1",
+    "@babel/plugin-transform-class-static-block": "^8.0.1",
     "@babel/plugin-transform-typescript": "^8.0.1",
     "@babel/preset-env": "^8.0.2",
-    "@swc/core": "^1.15.43",
+    "@swc/core": "^1.16.0",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.2.0",
     "@typescript/typescript6": "^6.0.2",
     "@vitest/coverage-v8": "^4.1.10",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
+    "mobx-v6": "npm:mobx@^6.0.0",
+    "mobx-v7": "npm:mobx@^7.0.0",
     "shx": "^0.4.0",
     "spec.ts": "^1.1.3",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.20",
     "typescript": "^7.0.2",
-    "vite": "^8.1.4",
+    "vite": "^8.2.1",
     "vite-plugin-dts": "^5.0.3",
     "vitest": "^4.1.10"
   },

package/src/actionMiddlewares/undoMiddleware.ts

@@ -1,4 +1,3 @@
-import { action, computed } from "mobx"
 import type { ActionMiddlewareDisposer } from "../action/middleware"
 import { modelAction } from "../action/modelAction"
 import { Model } from "../model/Model"
@@ -10,7 +9,14 @@ import { assertTweakedObject } from "../tweaker/core"
 import { typesArray } from "../types/arrayBased/typesArray"
 import { tProp } from "../types/tProp"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
-import { failure, getMobxVersion, mobx6, namespace } from "../utils"
+import {
+  failure,
+  getMobxVersion,
+  makeObservableCompat,
+  mobxAction,
+  mobxComputed,
+  namespace,
+} from "../utils"
 import { actionTrackingMiddleware, type SimpleActionContext } from "./actionTrackingMiddleware"
 
 /**
@@ -306,7 +312,7 @@ export class UndoManager {
    * The undo stack, where the first operation to undo will be the last of the array.
    * Do not manipulate this array directly.
    */
-  @computed
+  @mobxComputed
   get undoQueue(): ReadonlyArray<UndoEvent> {
     return this.store.undoEvents
   }
@@ -315,7 +321,7 @@ export class UndoManager {
    * The redo stack, where the first operation to redo will be the last of the array.
    * Do not manipulate this array directly.
    */
-  @computed
+  @mobxComputed
   get redoQueue(): ReadonlyArray<UndoEvent> {
     return this.store.redoEvents
   }
@@ -323,7 +329,7 @@ export class UndoManager {
   /**
    * The number of undo actions available.
    */
-  @computed
+  @mobxComputed
   get undoLevels() {
     return this.undoQueue.length
   }
@@ -331,7 +337,7 @@ export class UndoManager {
   /**
    * If undo can be performed (if there is at least one undo action available).
    */
-  @computed
+  @mobxComputed
   get canUndo() {
     return this.undoLevels > 0
   }
@@ -339,7 +345,7 @@ export class UndoManager {
   /**
    * Clears the undo queue.
    */
-  @action
+  @mobxAction
   clearUndo() {
     this.store._clearUndo()
   }
@@ -347,7 +353,7 @@ export class UndoManager {
   /**
    * The number of redo actions available.
    */
-  @computed
+  @mobxComputed
   get redoLevels() {
     return this.redoQueue.length
   }
@@ -355,7 +361,7 @@ export class UndoManager {
   /**
    * If redo can be performed (if there is at least one redo action available)
    */
-  @computed
+  @mobxComputed
   get canRedo() {
     return this.redoLevels > 0
   }
@@ -363,7 +369,7 @@ export class UndoManager {
   /**
    * Clears the redo queue.
    */
-  @action
+  @mobxAction
   clearRedo() {
     this.store._clearRedo()
   }
@@ -372,7 +378,7 @@ export class UndoManager {
    * Undoes the last action.
    * Will throw if there is no action to undo.
    */
-  @action
+  @mobxAction
   undo() {
     if (!this.canUndo) {
       throw failure("nothing to undo")
@@ -397,7 +403,7 @@ export class UndoManager {
    * Redoes the previous action.
    * Will throw if there is no action to redo.
    */
-  @action
+  @mobxAction
   redo() {
     if (!this.canRedo) {
       throw failure("nothing to redo")
@@ -619,7 +625,7 @@ export class UndoManager {
     this.options = options
 
     if (getMobxVersion() >= 6) {
-      mobx6.makeObservable(this)
+      makeObservableCompat(this)
     }
 
     this.store = store ?? new UndoStore({})

package/src/modelShared/BaseModelShared.ts

@@ -49,7 +49,7 @@ export type AbstractModelClass<M extends AnyModel | AnyDataModel> = abstract new
 ) => M
 
 /**
- * @internal
+ * @ignore
  */
 export interface ModelWithProps {
   [propsTypeSymbol]: ModelProps

package/src/modelShared/modelDecorator.ts

@@ -15,10 +15,11 @@ import {
 } from "../modelShared/modelSymbols"
 import { refreshInternalSnapshot } from "../snapshot/internal"
 import {
+  addLateInitializationFunction,
   failure,
   getMobxVersion,
   logWarning,
-  mobx6,
+  makeObservableCompat,
   runAfterNewSymbol,
   runBeforeOnInitSymbol,
   runLateInitializationFunctions,
@@ -34,11 +35,11 @@ import type { AnyFunction } from "../utils/AnyFunction"
  */
 export const model =
   (name: string) =>
-  <MC extends ModelClass<AnyModel | AnyDataModel>>(clazz: MC, ...args: any[]): MC => {
-    const ctx = typeof args[1] === "object" ? (args[1] as ClassDecoratorContext) : undefined
-
-    return internalModel(name, clazz, ctx?.addInitializer) as any
-  }
+  <MC extends ModelClass<AnyModel | AnyDataModel>>(
+    clazz: MC,
+    _context?: ClassDecoratorContext<MC>
+  ): MC =>
+    internalModel(name, clazz) as any
 
 const afterClassInitializationData = new WeakMap<
   ModelClass<AnyModel | AnyDataModel>,
@@ -56,14 +57,14 @@ const runAfterClassInitialization = (
 
   const tag = afterClassInitializationData.get(target)!
 
-  // compatibility with mobx 6
+  // compatibility with mobx 6 and 7
   if (tag.needsMakeObservable) {
     // we know it can be done and shouldn't fail
-    mobx6.makeObservable(instance)
+    makeObservableCompat(instance)
   } else if (tag.needsMakeObservable === undefined) {
     if (getMobxVersion() >= 6) {
       try {
-        mobx6.makeObservable(instance)
+        makeObservableCompat(instance)
         tag.needsMakeObservable = true
       } catch (e) {
         const err = e as Error
@@ -121,8 +122,7 @@ const proxyClassHandler: ProxyHandler<ModelClass<AnyModel | AnyDataModel>> = {
 
 const internalModel = <MC extends ModelClass<AnyModel | AnyDataModel>>(
   name: string,
-  clazz: MC,
-  addInitializer: ((initializer: (this: any) => void) => void) | undefined
+  clazz: MC
 ): MC | void => {
   const type = isModelClass(clazz) ? "class" : isDataModelClass(clazz) ? "data" : undefined
   if (!type) {
@@ -151,48 +151,24 @@ const internalModel = <MC extends ModelClass<AnyModel | AnyDataModel>>(
   // track if we fail so we only try it once per class
   afterClassInitializationData.set(clazz, { needsMakeObservable: undefined, type })
 
-  if (addInitializer) {
-    // standard decorator API, avoid proxies
-    addInitializer(function (this: any) {
-      runAfterClassInitialization(clazz, this)
-    })
-
-    const modelInfo = {
-      name,
-      class: clazz,
-    }
-
-    modelInfoByName[name] = modelInfo
+  const decoratedClass = new Proxy<MC>(clazz, proxyClassHandler)
+  ;(decoratedClass as any)[modelUnwrappedClassSymbol] = clazz
 
-    modelInfoByClass.set(clazz, modelInfo)
+  decoratedClass.prototype.constructor = decoratedClass
 
-    runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
-
-    return undefined // use same class
-  } else {
-    // non-standard decorator API, use proxies
-
-    // trick so plain new works
-    const proxyClass = new Proxy<MC>(clazz, proxyClassHandler)
-
-    // set or else it points to the undecorated class
-    proxyClass.prototype.constructor = proxyClass
-    ;(proxyClass as any)[modelUnwrappedClassSymbol] = clazz
-
-    const modelInfo = {
-      name,
-      class: proxyClass,
-    }
+  const modelInfo = {
+    name,
+    class: decoratedClass,
+  }
 
-    modelInfoByName[name] = modelInfo
+  modelInfoByName[name] = modelInfo
 
-    modelInfoByClass.set(proxyClass, modelInfo)
-    modelInfoByClass.set(clazz, modelInfo)
+  modelInfoByClass.set(decoratedClass, modelInfo)
+  modelInfoByClass.set(clazz, modelInfo)
 
-    runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
+  runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
 
-    return proxyClass
-  }
+  return decoratedClass
 }
 
 // basically taken from TS
@@ -243,18 +219,53 @@ export function decoratedModel<M, MC extends abstract new (...ags: any) => M>(
     [k in keyof M]?: AnyFunction | ReadonlyArray<AnyFunction>
   }
 ): MC {
+  const mobx7Annotations: Record<string, unknown> = {}
+
   // decorate class members
   for (const [k, decorator] of Object.entries(decorators)) {
+    const decoratorList = Array.isArray(decorator) ? decorator : [decorator]
+    const mobx7Annotation = decoratorList.find(isMobxAnnotation)
+    if (getMobxVersion() >= 7 && mobx7Annotation) {
+      if (decoratorList.length !== 1) {
+        throw failure("MobX 7 decorators cannot be combined in decoratedModel")
+      }
+      mobx7Annotations[k] = mobx7Annotation
+      continue
+    }
+
     const prototypeValueDesc = Object.getOwnPropertyDescriptor(clazz.prototype, k)
     // TS seems to send null for methods in the prototype
     // (which we substitute for the descriptor to avoid a double look-up) and void 0 (undefined) for props
-    tsDecorate(
-      Array.isArray(decorator) ? decorator : [decorator],
-      clazz.prototype,
-      k,
-      prototypeValueDesc ? prototypeValueDesc : void 0
-    )
+    tsDecorate(decoratorList, clazz.prototype, k, prototypeValueDesc ? prototypeValueDesc : void 0)
+  }
+
+  if (getMobxVersion() >= 7 && Object.keys(mobx7Annotations).length > 0) {
+    addLateInitializationFunction(clazz.prototype, runAfterNewSymbol, (instance) => {
+      makeObservableCompat(instance, mobx7Annotations)
+    })
   }
 
   return (name ? model(name)(clazz as unknown as ModelClass<AnyModel>) : clazz) as MC
 }
+
+type MobxAnnotation = {
+  annotationType_: string
+  make_: AnyFunction
+  extend_: AnyFunction
+}
+
+// MobX uses this same structural check in its internal `isAnnotation` helper.
+// That helper is not part of MobX's public root API, so mirror it here instead
+// of depending on a private deep import that may not exist in every supported version.
+function isMobxAnnotation(value: unknown): value is MobxAnnotation {
+  if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+    return false
+  }
+
+  const annotation = value as Partial<MobxAnnotation>
+  return (
+    typeof annotation.annotationType_ === "string" &&
+    typeof annotation.make_ === "function" &&
+    typeof annotation.extend_ === "function"
+  )
+}

package/src/modelShared/prop.ts

@@ -14,7 +14,7 @@ type SetterMode = boolean | "assign"
 
 export type ModelPropSetterValueTransform<T> = (value: T) => T
 
-/** @internal */
+/** @ignore */
 export interface FullModelPropTransform {
   transform: (
     original: unknown,

package/src/ref/Ref.ts

@@ -1,10 +1,9 @@
-import { computed } from "mobx"
 import { Model } from "../model/Model"
 import { modelTypeKey } from "../model/metadata"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import { tProp } from "../types/tProp"
-import { failure } from "../utils"
+import { failure, mobxComputed } from "../utils"
 
 /**
  * A reference model base type.
@@ -21,7 +20,7 @@ export abstract class Ref<T extends object> extends Model({
   /**
    * The object this reference points to, or `undefined` if the reference is currently invalid.
    */
-  @computed
+  @mobxComputed
   get maybeCurrent(): T | undefined {
     return this.resolve()
   }
@@ -29,7 +28,7 @@ export abstract class Ref<T extends object> extends Model({
   /**
    * If the reference is currently valid.
    */
-  @computed
+  @mobxComputed
   get isValid(): boolean {
     return !!this.maybeCurrent
   }
@@ -37,7 +36,7 @@ export abstract class Ref<T extends object> extends Model({
   /**
    * The object this reference points to, or throws if invalid.
    */
-  @computed
+  @mobxComputed
   get current(): T {
     const current = this.maybeCurrent
 

package/src/ref/core.ts

@@ -9,7 +9,7 @@ import {
 import { fastGetRoot } from "../parent/path"
 import { type ComputedWalkTreeAggregate, computedWalkTreeAggregate } from "../parent/walkTree"
 import { assertTweakedObject } from "../tweaker/core"
-import { assertIsObject, failure } from "../utils"
+import { assertIsObject, failure, mobxAction } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import { Ref, type RefConstructor } from "./Ref"
 
@@ -103,7 +103,7 @@ export function internalCustomRef<T extends object>(
       return true
     }
 
-    @action
+    @mobxAction
     forceUpdateBackRefs() {
       const currentTarget = this.maybeCurrent
       if (!this.startTracking(currentTarget)) {