mobx-keystone 2.3.0 → 2.4.0

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

@@ -1,33 +1,33 @@
-import { ArrayTypeInfo, typesArray } from './arrayBased/typesArray';
-import { TupleTypeInfo, typesTuple } from './arrayBased/typesTuple';
-import { ArraySetTypeInfo, typesArraySet } from './objectBased/typesArraySet';
-import { typesDataModelData } from './objectBased/typesDataModelData';
-import { ModelTypeInfo, ModelTypeInfoProps, typesModel } from './objectBased/typesModel';
-import { FrozenTypeInfo, ObjectTypeInfo, ObjectTypeInfoProps, typesFrozen, typesObject } from './objectBased/typesObject';
-import { ObjectMapTypeInfo, typesObjectMap } from './objectBased/typesObjectMap';
-import { RecordTypeInfo, typesRecord } from './objectBased/typesRecord';
-import { RefTypeInfo, typesRef } from './objectBased/typesRef';
-import { typesEnum } from './primitiveBased/typesEnum';
-import { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, typesLiteral } from './primitiveBased/typesPrimitive';
-import { AnyType } from './schemas';
-import { CodecTypeInfo, typesCodec } from './utility/typesCodec';
-import { typesMaybe, typesMaybeNull } from './utility/typesMaybe';
-import { OrTypeInfo, typesOr } from './utility/typesOr';
-import { RefinementTypeInfo, typesRefinement } from './utility/typesRefinement';
-import { SkipCheckTypeInfo, typesSkipCheck } from './utility/typesSkipCheck';
-import { TagTypeInfo, typesTag } from './utility/typesTag';
-import { typesUnchecked, UncheckedTypeInfo } from './utility/typesUnchecked';
-export { getTypeInfo } from './getTypeInfo';
-export { TypeInfo } from './TypeChecker';
+import { ArrayTypeInfo, typesArray } from "./arrayBased/typesArray";
+import { TupleTypeInfo, typesTuple } from "./arrayBased/typesTuple";
+import { ArraySetTypeInfo, typesArraySet } from "./objectBased/typesArraySet";
+import { typesDataModelData } from "./objectBased/typesDataModelData";
+import { ModelTypeInfo, type ModelTypeInfoProps, typesModel } from "./objectBased/typesModel";
+import { FrozenTypeInfo, ObjectTypeInfo, type ObjectTypeInfoProps, typesFrozen, typesObject } from "./objectBased/typesObject";
+import { ObjectMapTypeInfo, typesObjectMap } from "./objectBased/typesObjectMap";
+import { RecordTypeInfo, typesRecord } from "./objectBased/typesRecord";
+import { RefTypeInfo, typesRef } from "./objectBased/typesRef";
+import { typesEnum } from "./primitiveBased/typesEnum";
+import { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, typesLiteral } from "./primitiveBased/typesPrimitive";
+import type { AnyType } from "./schemas";
+import { CodecTypeInfo, typesCodec } from "./utility/typesCodec";
+import { typesMaybe, typesMaybeNull } from "./utility/typesMaybe";
+import { OrTypeInfo, typesOr } from "./utility/typesOr";
+import { RefinementTypeInfo, typesRefinement } from "./utility/typesRefinement";
+import { SkipCheckTypeInfo, typesSkipCheck } from "./utility/typesSkipCheck";
+import { TagTypeInfo, typesTag } from "./utility/typesTag";
+import { typesUnchecked, UncheckedTypeInfo } from "./utility/typesUnchecked";
+export { getTypeInfo } from "./getTypeInfo";
+export { TypeInfo } from "./TypeChecker";
 export type { ModelTypeInfoProps, ObjectTypeInfoProps };
 export { ArraySetTypeInfo, ArrayTypeInfo, BooleanTypeInfo, CodecTypeInfo, FrozenTypeInfo, LiteralTypeInfo, ModelTypeInfo, NumberTypeInfo, ObjectMapTypeInfo, ObjectTypeInfo, OrTypeInfo, RecordTypeInfo, RefinementTypeInfo, RefTypeInfo, SkipCheckTypeInfo, StringTypeInfo, TagTypeInfo, TupleTypeInfo, UncheckedTypeInfo, };
 export declare const types: {
     literal: typeof typesLiteral;
-    undefined: import('./schemas').IdentityType<undefined>;
-    null: import('./schemas').IdentityType<null>;
-    boolean: import('./schemas').IdentityType<boolean>;
-    number: import('./schemas').IdentityType<number>;
-    string: import('./schemas').IdentityType<string>;
+    undefined: import("./schemas").IdentityType<undefined>;
+    null: import("./schemas").IdentityType<null>;
+    boolean: import("./schemas").IdentityType<boolean>;
+    number: import("./schemas").IdentityType<number>;
+    string: import("./schemas").IdentityType<string>;
     or: typeof typesOr;
     maybe: typeof typesMaybe;
     maybeNull: typeof typesMaybeNull;
@@ -44,35 +44,35 @@ export declare const types: {
     tag: typeof typesTag;
     refinement: typeof typesRefinement;
     codec: typeof typesCodec;
-    integer: import('./schemas').IdentityType<number>;
-    nonEmptyString: import('./schemas').IdentityType<string>;
+    integer: import("./schemas").IdentityType<number>;
+    nonEmptyString: import("./schemas").IdentityType<string>;
     objectMap: typeof typesObjectMap;
     arraySet: typeof typesArraySet;
     tuple: typeof typesTuple;
-    bigint: import('.').CodecFromEncoded<StringConstructor, bigint>;
-    dateAsTimestamp: import('.').CodecFromEncoded<NumberConstructor, Date>;
-    dateAsIsoString: import('.').CodecFromEncoded<StringConstructor, Date>;
+    bigint: import(".").CodecFromEncoded<StringConstructor, bigint>;
+    dateAsTimestamp: import(".").CodecFromEncoded<NumberConstructor, Date>;
+    dateAsIsoString: import(".").CodecFromEncoded<StringConstructor, Date>;
     /**
      * @deprecated Prefer `types.mapFromArray(...)` for runtime `Map` values.
      */
-    mapArray<T extends AnyType>(valueType: T): import('./schemas').ArrayType<import('./schemas').ArrayType<[import('./schemas').IdentityType<string>, T]>[]>;
+    mapArray<T extends AnyType>(valueType: T): import("./schemas").ArrayType<import("./schemas").ArrayType<[import("./schemas").IdentityType<string>, T]>[]>;
     /**
      * @deprecated Prefer `types.setFromArray(...)` for runtime `Set` values.
      */
-    setArray<T extends AnyType>(valueType: T): import('./schemas').ArrayType<T[]>;
+    setArray<T extends AnyType>(valueType: T): import("./schemas").ArrayType<T[]>;
     /**
      * @deprecated Prefer `types.mapFromObject(...)` for runtime `Map` values.
      */
-    mapObject<T extends AnyType>(valueType: T): import('./schemas').RecordType<T>;
-    mapFromObject<T extends AnyType>(valueType: T): import('.').CodecFromEncoded<import('./schemas').RecordType<T>, Map<string, import('./schemas').TypeToData<T>>>;
-    mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import('.').CodecFromEncoded<import('./schemas').ArrayType<import('./schemas').ArrayType<[TKeyType, TValueType]>[]>, Map<import('./schemas').TypeToData<TKeyType>, import('./schemas').TypeToData<TValueType>>>;
-    setFromArray<T extends AnyType>(valueType: T): import('.').CodecFromEncoded<import('./schemas').ArrayType<T[]>, Set<import('./schemas').TypeToData<T>> | import('mobx').ObservableSet<import('./schemas').TypeToData<T>>>;
+    mapObject<T extends AnyType>(valueType: T): import("./schemas").RecordType<T>;
+    mapFromObject<T extends AnyType>(valueType: T): import(".").CodecFromEncoded<import("./schemas").RecordType<T>, Map<string, import("./schemas").TypeToData<T>>>;
+    mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import(".").CodecFromEncoded<import("./schemas").ArrayType<import("./schemas").ArrayType<[TKeyType, TValueType]>[]>, Map<import("./schemas").TypeToData<TKeyType>, import("./schemas").TypeToData<TValueType>>>;
+    setFromArray<T extends AnyType>(valueType: T): import(".").CodecFromEncoded<import("./schemas").ArrayType<T[]>, import("mobx").ObservableSet<import("./schemas").TypeToData<T>> | Set<import("./schemas").TypeToData<T>>>;
     /**
      * @deprecated Prefer `types.dateAsIsoString` instead.
      */
-    dateString: import('./schemas').IdentityType<string>;
+    dateString: import("./schemas").IdentityType<string>;
     /**
      * @deprecated Prefer `types.dateAsTimestamp` instead.
      */
-    dateTimestamp: import('./schemas').IdentityType<number>;
+    dateTimestamp: import("./schemas").IdentityType<number>;
 };

package/dist/types/types/utility/typeToStoredData.d.ts

@@ -1,5 +1,5 @@
-import { SimplifyObject } from '../../utils/types';
-import { ArrayType, ObjectOptionalKeys, ObjectType, ObjectTypeFunction, RecordType, TypeToData } from '../schemas';
+import type { SimplifyObject } from "../../utils/types";
+import type { ArrayType, ObjectOptionalKeys, ObjectType, ObjectTypeFunction, RecordType, TypeToData } from "../schemas";
 type ArrayStoredData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToStoredData<S[number]>> : {
     [k in keyof S]: TypeToStoredData<S[k]>;
 };

package/dist/types/types/utility/typesBigInt.d.ts

@@ -1 +1 @@
-export declare const typesBigInt: import('./typesCodecCore').CodecFromEncoded<StringConstructor, bigint>;
+export declare const typesBigInt: import("./typesCodecCore").CodecFromEncoded<StringConstructor, bigint>;

package/dist/types/types/utility/typesCodec.d.ts

@@ -1,7 +1,7 @@
-import { typesBigInt } from './typesBigInt';
-import { CodecTypeInfo, typesCodec } from './typesCodecCore';
-import { createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker } from './typesCodecSupport';
-import { typesDateAsIsoString, typesDateAsTimestamp } from './typesDate';
-import { typesMapFromArray, typesMapFromObject } from './typesMap';
-import { typesSetFromArray } from './typesSet';
+import { typesBigInt } from "./typesBigInt";
+import { CodecTypeInfo, typesCodec } from "./typesCodecCore";
+import { createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker } from "./typesCodecSupport";
+import { typesDateAsIsoString, typesDateAsTimestamp } from "./typesDate";
+import { typesMapFromArray, typesMapFromObject } from "./typesMap";
+import { typesSetFromArray } from "./typesSet";
 export { CodecTypeInfo, createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker, typesBigInt, typesCodec, typesDateAsIsoString, typesDateAsTimestamp, typesMapFromArray, typesMapFromObject, typesSetFromArray, };

package/dist/types/types/utility/typesCodecCore.d.ts

@@ -1,7 +1,7 @@
-import { ModelPropTransform } from '../../modelShared/prop';
-import { AnyStandardType, AnyType, CodecType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from '../schemas';
-import { TypeCheckerBaseType, TypeInfo } from '../TypeChecker';
-import { TypeToStoredData } from './typeToStoredData';
+import type { ModelPropTransform } from "../../modelShared/prop";
+import type { AnyStandardType, AnyType, CodecType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from "../schemas";
+import { TypeCheckerBaseType, TypeInfo } from "../TypeChecker";
+import type { TypeToStoredData } from "./typeToStoredData";
 export interface RuntimeAdapter<Stored, Runtime> {
     toRuntime(stored: Stored, setStored?: (stored: Stored) => void): Runtime;
     toStored(runtime: Runtime): Stored;

package/dist/types/types/utility/typesCodecSupport.d.ts

@@ -1,7 +1,7 @@
-import { ModelPropTransform } from '../../modelShared/prop';
-import { AnyStandardType, AnyType } from '../schemas';
-import { ResolvedCodecSupport } from './typesCodecCore';
+import type { ModelPropTransform } from "../../modelShared/prop";
+import type { AnyStandardType, AnyType } from "../schemas";
+import { type ResolvedCodecSupport } from "./typesCodecCore";
 export declare function resolveCodecSupport(type: AnyType): ResolvedCodecSupport;
 export declare function resolveStoredType(type: AnyType): AnyStandardType;
-export declare function resolveStoredTypeChecker(type: AnyType): import('../TypeChecker').TypeChecker;
+export declare function resolveStoredTypeChecker(type: AnyType): import("../TypeChecker").TypeChecker;
 export declare function createCodecPropTransform(type: AnyType): ModelPropTransform<any, unknown>;

package/dist/types/types/utility/typesDate.d.ts

@@ -1,2 +1,2 @@
-export declare const typesDateAsTimestamp: import('./typesCodecCore').CodecFromEncoded<NumberConstructor, Date>;
-export declare const typesDateAsIsoString: import('./typesCodecCore').CodecFromEncoded<StringConstructor, Date>;
+export declare const typesDateAsTimestamp: import("./typesCodecCore").CodecFromEncoded<NumberConstructor, Date>;
+export declare const typesDateAsIsoString: import("./typesCodecCore").CodecFromEncoded<StringConstructor, Date>;

package/dist/types/types/utility/typesMap.d.ts

@@ -1,4 +1,4 @@
-import { AnyType, ArrayType, RecordType, TypeToData } from '../schemas';
-import { CodecFromEncoded } from './typesCodecCore';
+import type { AnyType, ArrayType, RecordType, TypeToData } from "../schemas";
+import type { CodecFromEncoded } from "./typesCodecCore";
 export declare function typesMapFromObject<TValueType extends AnyType>(valueType: TValueType): CodecFromEncoded<RecordType<TValueType>, Map<string, TypeToData<TValueType>>>;
 export declare function typesMapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): CodecFromEncoded<ArrayType<ArrayType<[TKeyType, TValueType]>[]>, Map<TypeToData<TKeyType>, TypeToData<TValueType>>>;

package/dist/types/types/utility/typesMaybe.d.ts

@@ -1,4 +1,4 @@
-import { AnyType, IdentityType } from '../schemas';
+import type { AnyType, IdentityType } from "../schemas";
 /**
  * A type that represents either a type or undefined.
  * Syntactic sugar for `types.or(baseType, types.undefined)`

package/dist/types/types/utility/typesOr.d.ts

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that represents the union of several other types (a | b | c | ...).
  * Accepts a dispatcher that, given a snapshot, returns the type

package/dist/types/types/utility/typesRefinement.d.ts

@@ -1,6 +1,6 @@
-import { AnyStandardType, AnyType, TypeToData } from '../schemas';
-import { TypeCheckError } from '../TypeCheckError';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType, TypeToData } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+import { TypeCheckError } from "../TypeCheckError";
 /**
  * A refinement over a given type. This allows you to do extra checks
  * over models, ensure numbers are integers, etc.

package/dist/types/types/utility/typesSet.d.ts

@@ -1,4 +1,4 @@
-import { ObservableSet } from 'mobx';
-import { AnyType, ArrayType, TypeToData } from '../schemas';
-import { CodecFromEncoded } from './typesCodecCore';
+import type { ObservableSet } from "mobx";
+import type { AnyType, ArrayType, TypeToData } from "../schemas";
+import type { CodecFromEncoded } from "./typesCodecCore";
 export declare function typesSetFromArray<TValueType extends AnyType>(valueType: TValueType): CodecFromEncoded<ArrayType<TValueType[]>, Set<TypeToData<TValueType>> | ObservableSet<TypeToData<TValueType>>>;

package/dist/types/types/utility/typesSkipCheck.d.ts

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that wraps another type but skips runtime validation.
  * Unlike `types.unchecked()`, this preserves the wrapped type's

package/dist/types/types/utility/typesTag.d.ts

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * Wrap a given type with tag information.
  * This allows you to associate metadata with the type of a prop that

package/dist/types/types/utility/typesUnchecked.d.ts

@@ -1,5 +1,5 @@
-import { IdentityType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { IdentityType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that represents a given value that won't be type checked.
  * This is basically a way to bail out of the runtime type checking system.

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

@@ -1,4 +1,4 @@
-import { AnyModel } from '../model/BaseModel';
+import type { AnyModel } from "../model/BaseModel";
 /**
  * A view of the models under a node, as they were when the pool was created.
  * Must be released once no longer used.

package/dist/types/wrappers/ArraySet.d.ts

@@ -1,4 +1,4 @@
-import { AnyModel } from '../model/BaseModel';
+import type { AnyModel } from "../model/BaseModel";
 declare const arraySetBase: abstract new (data: any) => AnyModel & {
     readonly $: {
         items: any[];

package/dist/types/wrappers/ObjectMap.d.ts

@@ -1,4 +1,4 @@
-import { AnyModel } from '../model/BaseModel';
+import type { AnyModel } from "../model/BaseModel";
 declare const objectMapBase: abstract new (data: any) => AnyModel & {
     readonly $: {
         items: Record<string, any>;

package/dist/types/wrappers/asMap.d.ts

@@ -1,4 +1,4 @@
-import { ObservableMap } from 'mobx';
+import { type ObservableMap } from "mobx";
 type Ts6MapExtras<K, V> = {
     getOrInsert(key: K, defaultValue: V): V;
     getOrInsertComputed(key: K, callback: (key: K) => V): V;

package/dist/types/wrappers/asSet.d.ts

@@ -1,4 +1,4 @@
-import { ObservableSet } from 'mobx';
+import { type ObservableSet } from "mobx";
 /**
  * Wraps an observable array to offer a set like interface.
  *

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

@@ -1,4 +1,4 @@
-export * from './ArraySet';
-export * from './asMap';
-export * from './asSet';
-export * from './ObjectMap';
+export * from "./ArraySet";
+export * from "./asMap";
+export * from "./asSet";
+export * from "./ObjectMap";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -50,19 +50,6 @@
     "CHANGELOG.md",
     "README.md"
   ],
-  "scripts": {
-    "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 && 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",
-    "test:perf:run": "cd perf_bench && NODE_ENV=production TS_NODE_COMPILER=@typescript/typescript6 /usr/bin/time node --expose-gc --require ts-node/register ./report.ts",
-    "memtest": "cd perf_bench && NODE_ENV=production TS_NODE_COMPILER=@typescript/typescript6 node --expose-gc --require ts-node/register ./memtest.ts",
-    "build-docs": "shx rm -rf ../../apps/site/generated-api && node --import ./scripts/typedoc-typescript6-register.mjs ./node_modules/typedoc/dist/cli.js --options ./typedocconfig.js src/index.ts"
-  },
   "peerDependencies": {
     "mobx": "^7.0.0 || ^6.0.0 || ^5.0.0 || ^4.0.0"
   },
@@ -77,7 +64,7 @@
     "@types/babel__core": "^7.20.5",
     "@types/node": "^26.6.2",
     "@typescript/typescript6": "^6.0.2",
-    "@vitest/coverage-v8": "^5.0.1",
+    "@vitest/coverage-v8": "catalog:",
     "expect-type": "^1.4.0",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
@@ -89,9 +76,9 @@
     "typedoc-docusaurus-theme": "^1.4.3",
     "typedoc-plugin-markdown": "^4.13.1",
     "typescript": "^7.0.2",
-    "vite": "^8.3.1",
-    "vite-plugin-dts": "^5.1.1",
-    "vitest": "^5.0.1"
+    "vite": "catalog:",
+    "vite-plus": "catalog:",
+    "vitest": "catalog:"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/action/CallKind.ts

@@ -0,0 +1,29 @@
+/**
+ * What a call's name resolved to on its target.
+ */
+export enum CallKind {
+  /**
+   * An action declared on a class: a model's `@modelAction` / `@modelFlow` (including
+   * `withSetter()` setters), or a data model's action.
+   */
+  ModelAction = "modelAction",
+  /**
+   * An action the app defines with `standaloneAction` / `standaloneFlow`, under a global name.
+   */
+  StandaloneAction = "standaloneAction",
+  /**
+   * A standalone action the library ships for editing any array or plain object
+   * (`arrayActions`, `objectActions`).
+   */
+  StandardAction = "standardAction",
+  /**
+   * A built-in action, as library functions record when they change a node: `$$applySnapshot`,
+   * `$$applyPatches`, `$$detach`, `$$applySet`, `$$applyDelete`, `$$applyMethodCall` (see
+   * `BuiltInAction`).
+   */
+  BuiltInAction = "builtInAction",
+  /**
+   * Not an action: a method, getter or function field of a model's or data model's own classes.
+   */
+  View = "view",
+}

package/src/action/applyAction.ts

@@ -1,20 +1,10 @@
-import { getDataModelAction } from "../dataModel/actions"
-import { detach } from "../parent/detach"
 import { resolvePathCheckingIds } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
-import { applyPatches } from "../patch/applyPatches"
-import { applySnapshot } from "../snapshot/applySnapshot"
 import { getStandaloneAction } from "../standardActions/actions"
 import { assertTweakedObject } from "../tweaker/core"
 import { failure } from "../utils"
-import type { AnyFunction } from "../utils/AnyFunction"
-import { applyDelete } from "./applyDelete"
-import { applyMethodCall } from "./applyMethodCall"
-import { applySet } from "./applySet"
-import { BuiltInAction, isBuiltInAction } from "./builtInActions"
-import { isHookAction } from "./hookActions"
-import { isModelAction } from "./isModelAction"
-import { isModelFlow } from "./modelFlow"
+import { CallKind } from "./CallKind"
+import { resolveCallName } from "./resolveCallName"
 
 /**
  * An action call.
@@ -42,23 +32,20 @@ export interface ActionCall {
 
   /**
    * Marks this action call as non-serialized.
+   *
+   * @deprecated Not needed with `createSerializer`: a `Call` is never serialized, an
+   * `EncodedCall` always is.
    */
   readonly serialized?: boolean
 }
 
-const builtInActionToFunction = {
-  [BuiltInAction.ApplySnapshot]: applySnapshot,
-  [BuiltInAction.ApplyPatches]: applyPatches,
-  [BuiltInAction.Detach]: detach,
-  [BuiltInAction.ApplySet]: applySet,
-  [BuiltInAction.ApplyDelete]: applyDelete,
-  [BuiltInAction.ApplyMethodCall]: applyMethodCall,
-}
-
 /**
  * Applies (runs) an action over a target object.
  *
- * If you intend to apply serialized actions check one of the `applySerializedAction` methods instead.
+ * It runs any kind of action (built-in, standalone, model actions and flows), but not views.
+ * To apply calls that come from outside (e.g. as JSON), decode them with a serializer
+ * (`defaultSerializer.decodeCall`) and use `applyCall` / `applyCallAsync` instead, which check
+ * what may be called.
  *
  * @param subtreeRoot Subtree root target object to run the action over.
  * @param call The action, usually as coming from `onActionMiddleware`.
@@ -88,38 +75,24 @@ export function applyAction<TRet = any>(subtreeRoot: object, call: ActionCall):
   }
   assertTweakedObject(current, "resolved target", true)
 
-  if (isBuiltInAction(call.actionName)) {
-    const fnToCall = builtInActionToFunction[call.actionName] as AnyFunction | undefined
-    if (!fnToCall) {
-      throw failure(`assertion failed: unknown built-in action - ${call.actionName}`)
-    }
-
-    return fnToCall.apply(current, [current, ...call.args])
-  }
-
-  if (isHookAction(call.actionName)) {
+  const resolution = resolveCallName(current, call.actionName)
+  if (resolution === "hook") {
     throw failure(`calls to hooks (${call.actionName}) cannot be applied`)
   }
-
-  const dataModelAction = getDataModelAction(call.actionName)
-  if (dataModelAction) {
-    const instance: any = new dataModelAction.modelClass(current)
-    return instance[dataModelAction.fnName](...call.args)
+  if (resolution === "unknown") {
+    throw failure(`action '${call.actionName}' could not be resolved to a function`)
   }
 
-  const standaloneAction = getStandaloneAction(call.actionName)
-  if (standaloneAction) {
-    return standaloneAction.apply(current, call.args as any)
-  }
+  switch (resolution.kind) {
+    case CallKind.View:
+      throw failure(`action '${call.actionName}' is not a model action`)
 
-  const actionFn = (current as any)[call.actionName]
-  if (typeof actionFn !== "function") {
-    throw failure(`action '${call.actionName}' could not be resolved to a function`)
-  }
+    case CallKind.StandaloneAction:
+    case CallKind.StandardAction:
+      // the target is already the first argument
+      return getStandaloneAction(call.actionName)!.fn(...call.args)
 
-  if (!isModelAction(actionFn) && !isModelFlow(actionFn)) {
-    throw failure(`action '${call.actionName}' is not a model action`)
+    default:
+      return resolution.run(call.args) as TRet
   }
-
-  return actionFn.apply(current, call.args)
 }

package/src/action/applySet.ts

@@ -1,7 +1,7 @@
 import { isObservable } from "mobx"
 import { isModel } from "../model/utils"
 import { assertTweakedObject } from "../tweaker/core"
-import { lazy } from "../utils"
+import { failure, hasOwnProp, lazy } from "../utils"
 import { setIfDifferent } from "../utils/setIfDifferent"
 import { BuiltInAction } from "./builtInActions"
 import { ActionContextActionType } from "./context"
@@ -30,10 +30,30 @@ function internalApplySet<O extends object>(this: O, fieldName: string | number,
   if (!isModel(this) && isObservable(this)) {
     setIfDifferent(this, fieldName, value)
   } else {
+    // assigning '__proto__' would replace the prototype of the model instead of setting a field,
+    // and assigning an inherited method (e.g. an action) would shadow it on this instance
+    if (fieldName === "__proto__" || isInheritedDataProp(this, fieldName)) {
+      throw failure(`applySet cannot set '${String(fieldName)}' on a model`)
+    }
     ;(this as any)[fieldName] = value
   }
 }
 
+function isInheritedDataProp(obj: object, fieldName: string | number): boolean {
+  if (hasOwnProp(obj, fieldName)) {
+    return false
+  }
+  let proto = Object.getPrototypeOf(obj)
+  while (proto) {
+    const descriptor = Object.getOwnPropertyDescriptor(proto, fieldName)
+    if (descriptor) {
+      return !descriptor.get && !descriptor.set
+    }
+    proto = Object.getPrototypeOf(proto)
+  }
+  return false
+}
+
 const wrappedInternalApplySet = lazy(() =>
   wrapInAction({
     nameOrNameFn: BuiltInAction.ApplySet,

package/src/action/index.ts

@@ -3,6 +3,7 @@ export * from "./applyDelete"
 export * from "./applyMethodCall"
 export * from "./applySet"
 export * from "./builtInActions"
+export * from "./CallKind"
 export * from "./context"
 export * from "./hookActions"
 export * from "./isModelAction"

package/src/action/modelAction.ts

@@ -8,7 +8,7 @@ import { wrapInAction } from "./wrapInAction"
  * Decorator that turns a function into a model action.
  */
 export function modelAction(...args: any[]): void {
-  // biome-ignore lint/correctness/noVoidTypeReturn: proper way to declare a decorator
+  // Proper way to declare a decorator
   return decorateWrapMethodOrField("modelAction", args, (data, fn) => {
     if (isModelAction(fn)) {
       return fn

package/src/action/modelFlow.ts

@@ -163,7 +163,7 @@ export function isModelFlow(fn: unknown) {
  * Decorator that turns a function generator into a model flow.
  */
 export function modelFlow(...args: any[]): void {
-  // biome-ignore lint/correctness/noVoidTypeReturn: proper way to declare a decorator
+  // Proper way to declare a decorator
   return decorateWrapMethodOrField("modelFlow", args, (data, fn) => {
     if (isModelFlow(fn)) {
       return fn