mobx-keystone 2.3.0 → 2.4.0

package/src/action/resolveCallName.ts

@@ -0,0 +1,207 @@
+import { getDataModelAction } from "../dataModel/actions"
+import { BaseDataModel } from "../dataModel/BaseDataModel"
+import { isDataModelClass } from "../dataModel/utils"
+import { BaseModel } from "../model/BaseModel"
+import { isModel } from "../model/utils"
+import type { ModelClass } from "../modelShared/BaseModelShared"
+import { getModelInfoForName } from "../modelShared/modelInfo"
+import { detach } from "../parent/detach"
+import { applyPatches } from "../patch/applyPatches"
+import { applySnapshot } from "../snapshot/applySnapshot"
+import { getStandaloneAction } from "../standardActions/actions"
+import { failure, namespace } 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 { CallKind } from "./CallKind"
+import { isHookAction } from "./hookActions"
+import { isModelAction } from "./isModelAction"
+import { isModelFlow } from "./modelFlow"
+
+const builtInActionToFunction = {
+  [BuiltInAction.ApplySnapshot]: applySnapshot,
+  [BuiltInAction.ApplyPatches]: applyPatches,
+  [BuiltInAction.Detach]: detach,
+  [BuiltInAction.ApplySet]: applySet,
+  [BuiltInAction.ApplyDelete]: applyDelete,
+  [BuiltInAction.ApplyMethodCall]: applyMethodCall,
+}
+
+const standardActionPrefixes = [`${namespace}/arrayActions::`, `${namespace}/objectActions::`]
+
+const dataModelMemberPrefix = "fn::"
+
+// members that are never callable, even when defined below the base classes
+const nonCallableMemberNames: ReadonlySet<string> = new Set([
+  "constructor",
+  "onInit",
+  "onLazyInit",
+  "onAttachedToRootStore",
+  "onLazyAttachedToRootStore",
+])
+
+/**
+ * @internal
+ *
+ * How a view is used: a getter is read (no `args`), a method is called (with `args`).
+ */
+export type ViewForm = "getter" | "method"
+
+/**
+ * @internal
+ *
+ * What a call's name resolved to on its target.
+ */
+export interface CallResolution {
+  readonly kind: CallKind
+  readonly isFlow: boolean
+  /**
+   * Only for views.
+   */
+  readonly viewForm: ViewForm | undefined
+  /**
+   * Runs the call on the target it was resolved for (args are ignored when reading a getter).
+   */
+  run(args: readonly unknown[]): unknown
+}
+
+/**
+ * @internal
+ *
+ * Why a name couldn't be resolved: a hook (never callable) or nothing callable by that name.
+ */
+export type CallResolutionFailure = "hook" | "unknown"
+
+type FoundMember = { readonly get: AnyFunction } | { readonly fn: AnyFunction }
+
+/**
+ * Finds a callable member without running any getter: a method, getter or function field of the
+ * object or of its prototype chain below `stopProto`.
+ */
+function findMember(obj: object, name: string, stopProto: object): FoundMember | undefined {
+  if (nonCallableMemberNames.has(name)) {
+    return undefined
+  }
+
+  // own accessors too, e.g. computeds MobX defines on the instance with legacy decorators
+  for (
+    let current: object | null = obj;
+    current && current !== stopProto;
+    current = Object.getPrototypeOf(current)
+  ) {
+    const desc = Object.getOwnPropertyDescriptor(current, name)
+    if (desc) {
+      if (desc.get) {
+        return { get: desc.get }
+      }
+      return typeof desc.value === "function" ? { fn: desc.value } : undefined
+    }
+  }
+  return undefined
+}
+
+function resolveMember(member: FoundMember, self: object): CallResolution {
+  if ("get" in member) {
+    const get = member.get
+    return {
+      kind: CallKind.View,
+      isFlow: false,
+      viewForm: "getter",
+      run: () => get.call(self),
+    }
+  }
+
+  const fn = member.fn
+  const run = (args: readonly unknown[]) => fn.apply(self, args as unknown[])
+  if (isModelAction(fn) || isModelFlow(fn)) {
+    return { kind: CallKind.ModelAction, isFlow: isModelFlow(fn), viewForm: undefined, run }
+  }
+  return { kind: CallKind.View, isFlow: false, viewForm: "method", run }
+}
+
+function getDataModelClassAndMember(
+  name: string
+): { modelClass: ModelClass<any>; memberName: string } | undefined {
+  // data model actions are registered under their name
+  const registered = getDataModelAction(name)
+  if (registered) {
+    return { modelClass: registered.modelClass, memberName: registered.fnName }
+  }
+
+  // other members are named the same way: fn::<data model name>::<member>
+  if (!name.startsWith(dataModelMemberPrefix)) {
+    return undefined
+  }
+  const separatorIndex = name.lastIndexOf("::")
+  if (separatorIndex < dataModelMemberPrefix.length) {
+    return undefined
+  }
+  const modelInfo = getModelInfoForName(name.slice(dataModelMemberPrefix.length, separatorIndex))
+  if (!modelInfo || !isDataModelClass(modelInfo.class)) {
+    return undefined
+  }
+  return { modelClass: modelInfo.class, memberName: name.slice(separatorIndex + 2) }
+}
+
+/**
+ * @internal
+ *
+ * Resolves what a call's name refers to on its target, in this order: built-in actions, hooks
+ * (refused), data model members, standalone actions, the target's own model actions and flows,
+ * and finally the target's own methods, getters and function fields (views).
+ *
+ * Getters are never run while resolving.
+ */
+export function resolveCallName(
+  target: object,
+  name: string
+): CallResolution | CallResolutionFailure {
+  if (isBuiltInAction(name)) {
+    const fn = builtInActionToFunction[name] as AnyFunction | undefined
+    if (!fn) {
+      throw failure(`assertion failed: unknown built-in action - ${name}`)
+    }
+    return {
+      kind: CallKind.BuiltInAction,
+      isFlow: false,
+      viewForm: undefined,
+      run: (args) => fn.apply(target, [target, ...args]),
+    }
+  }
+
+  if (isHookAction(name)) {
+    return "hook"
+  }
+
+  const dataModelMember = getDataModelClassAndMember(name)
+  if (dataModelMember) {
+    // the instance is created (or reused, since they are cached) first, so decorators that
+    // initialize on first use have run; it throws when the target isn't valid data for the class
+    const instance: object = new dataModelMember.modelClass(target)
+    const member = findMember(instance, dataModelMember.memberName, BaseDataModel.prototype)
+    return member ? resolveMember(member, instance) : "unknown"
+  }
+
+  const standaloneAction = getStandaloneAction(name)
+  if (standaloneAction) {
+    return {
+      kind: standardActionPrefixes.some((prefix) => name.startsWith(prefix))
+        ? CallKind.StandardAction
+        : CallKind.StandaloneAction,
+      isFlow: standaloneAction.isFlow,
+      viewForm: undefined,
+      run: (args) => standaloneAction.fn(target, ...args),
+    }
+  }
+
+  if (isModel(target)) {
+    const member = findMember(target, name, BaseModel.prototype)
+    if (member) {
+      return resolveMember(member, target)
+    }
+  }
+
+  return "unknown"
+}

package/src/actionMiddlewares/actionSerialization/actionSerialization.ts

@@ -24,6 +24,8 @@ const serializersMap = new Map<string, ActionCallArgumentSerializer<any, any>>()
  *
  * @param serializer Serializer to register.
  * @returns A disposer to unregister the serializer.
+ *
+ * @deprecated Use a `ValueSerializer` in the list passed to `createSerializer` instead.
  */
 export function registerActionCallArgumentSerializer(
   serializer: ActionCallArgumentSerializer<any, any>
@@ -54,6 +56,8 @@ export function registerActionCallArgumentSerializer(
 
 /**
  * Serialized action call argument.
+ *
+ * @deprecated Replaced by the marked value `{ "$mobxKeystone": tag, "v": payload }` of `createSerializer`.
  */
 export interface SerializedActionCallArgument {
   /**
@@ -68,6 +72,8 @@ export interface SerializedActionCallArgument {
 
 /**
  * A serialized action call.
+ *
+ * @deprecated Use `EncodedCall` instead.
  */
 export interface SerializedActionCall extends Omit<ActionCall, "serialized"> {
   /**
@@ -99,6 +105,8 @@ export interface SerializedActionCall extends Omit<ActionCall, "serialized"> {
  * @param argValue Argument value to be transformed into its serializable form.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The serializable form of the passed value.
+ *
+ * @deprecated Use `serializer.encodeValue(root, value)` instead (e.g. with `defaultSerializer`).
  */
 export function serializeActionCallArgument(
   argValue: any,
@@ -137,6 +145,8 @@ export function serializeActionCallArgument(
  * @param actionCall Action call to convert.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The serializable action call.
+ *
+ * @deprecated Use `serializer.encodeCall(root, call)` instead (e.g. with `defaultSerializer`).
  */
 export function serializeActionCall(
   actionCall: ActionCall,
@@ -165,6 +175,8 @@ export function serializeActionCall(
  * @param argValue Argument value to be transformed into its deserialized form.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The deserialized form of the passed value.
+ *
+ * @deprecated Use `serializer.decodeValue(root, json)` instead (e.g. with `defaultSerializer`).
  */
 export function deserializeActionCallArgument(
   argValue: SerializedActionCallArgument | JSONPrimitiveValue,
@@ -200,6 +212,8 @@ export function deserializeActionCallArgument(
  * @param actionCall Action call to convert.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The deserialized action call.
+ *
+ * @deprecated Use `serializer.decodeCall(root, json)` instead (e.g. with `defaultSerializer`), then `applyCall`.
  */
 export function deserializeActionCall(
   actionCall: SerializedActionCall,

package/src/actionMiddlewares/actionSerialization/applySerializedAction.ts

@@ -17,6 +17,8 @@ import { deserializeActionCall, type SerializedActionCall } from "./actionSerial
  * Serialized action call with model ID overrides.
  * Can be generated with `applySerializedActionAndTrackNewModelIds`.
  * To be applied with `applySerializedActionAndSyncNewModelIds`.
+ *
+ * @deprecated Use `EncodedCall` instead; model id overrides aren't needed when replicas apply the patches the server broadcasts.
  */
 export interface SerializedActionCallWithModelIdOverrides extends SerializedActionCall {
   /**
@@ -38,6 +40,8 @@ export interface SerializedActionCallWithModelIdOverrides extends SerializedActi
  * @param call The serialized action, usually as coming from the server/client.
  * @returns The return value of the action, if any, plus a new serialized action
  * with model overrides.
+ *
+ * @deprecated Use `applyCall` / `applyCallAsync` on the server instead, broadcasting the patches the call produces.
  */
 export function applySerializedActionAndTrackNewModelIds<TRet = any>(
   subtreeRoot: object,
@@ -156,6 +160,8 @@ function deepScanValueForModelIdChanges(
  * @param subtreeRoot Subtree root target object to run the action over.
  * @param call The serialized action, usually as coming from the server/client.
  * @returns The return value of the action, if any.
+ *
+ * @deprecated Use `applyPatches` on the patches the server broadcasts instead.
  */
 export function applySerializedActionAndSyncNewModelIds<TRet = any>(
   subtreeRoot: object,

package/src/actionMiddlewares/actionSerialization/core.ts

@@ -1,7 +1,14 @@
+/**
+ * Returned by an `ActionCallArgumentSerializer` that can't serialize a value.
+ *
+ * @deprecated Use `ValueSerializer.is` returning false instead.
+ */
 export const cannotSerialize = Symbol("cannotSerialize")
 
 /**
  * Serializer of action call arguments.
+ *
+ * @deprecated Use `ValueSerializer` instead.
  */
 export interface ActionCallArgumentSerializer<TOriginal, TSerialized> {
   /**

package/src/actionMiddlewares/actionSerialization/index.ts

@@ -1,3 +1,5 @@
+// Deprecated: replaced by `src/serialization`; kept unchanged until the next major.
+
 export * from "./actionSerialization"
 export * from "./applySerializedAction"
 export * from "./core"

package/src/actionMiddlewares/actionSerialization/objectPathSerializer.ts

@@ -1,6 +1,6 @@
 import { fastGetRootPath, resolvePathCheckingIds } from "../../parent/path"
 import type { Path } from "../../parent/pathTypes"
-import { isTweakedObject } from "../../tweaker/core"
+import { isTreeNode, isTweakedObject } from "../../tweaker/core"
 import { failure, namespace } from "../../utils"
 import { rootPathToTargetPathIds } from "../utils"
 import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
@@ -36,7 +36,8 @@ export const objectPathSerializer: ActionCallArgumentSerializer<object, ObjectPa
     // try to resolve the node back
     if (targetRoot) {
       const result = resolvePathCheckingIds(targetRoot, ref.targetPath, ref.targetPathIds)
-      if (result.resolved) {
+      // only tree nodes can be serialized as paths, so anything else is not a valid target
+      if (result.resolved && isTreeNode(result.value)) {
         return result.value
       }
     }

package/src/dataModel/BaseDataModel.ts

@@ -1,4 +1,4 @@
-import { propsTypeSymbol } from "../modelShared/BaseModelShared"
+import { type propsTypeSymbol } from "../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../modelShared/modelPropsInfo"
 import {
@@ -13,8 +13,8 @@ import { getSnapshot } from "../snapshot/getSnapshot"
 import { isTreeNode } from "../tweaker/core"
 import { toTreeNode } from "../tweaker/tweak"
 import { typesDataModelData } from "../types/objectBased/typesDataModelData"
-import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
+import type { TypeCheckError } from "../types/TypeCheckError"
 import { clonePlainObject, failure, hasOwnProp, isObject, setProtoProp } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import type { DataModelConstructorOptions } from "./DataModelConstructorOptions"
@@ -73,7 +73,7 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
     }
 
     const constructorOptions =
-      // biome-ignore lint/complexity/noArguments: internal factory code passes hidden constructor options through super().
+      // oxlint-disable-next-line eslint/prefer-rest-params -- internal factory code passes hidden constructor options through super().
       arguments[1] as DataModelConstructorOptions
     const { modelClass: _modelClass } = constructorOptions
     const modelClass = _modelClass!
@@ -140,7 +140,7 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
 
     const instance = instancesForModelClass.get(tweakedData)
     if (instance) {
-      // biome-ignore lint/correctness/noConstructorReturn: no other way to return an instance
+      // oxlint-disable-next-line eslint/no-constructor-return -- no other way to return an instance
       return instance
     }
 
@@ -189,6 +189,6 @@ export interface AnyDataModel extends BaseDataModel<any> {}
  * A data model class declaration, made of a base model and the model interface.
  */
 export type DataModelClassDeclaration<BaseModelClass, ModelInterface> = BaseModelClass & {
-  // biome-ignore lint/style/useShorthandFunctionType: make type recursive
+  // oxlint-disable-next-line typescript/prefer-function-type -- make type recursive
   (...args: any[]): ModelInterface
 }

package/src/index.ts

@@ -13,6 +13,7 @@ export * from "./patch"
 export * from "./redux"
 export * from "./ref"
 export * from "./rootStore"
+export * from "./serialization"
 export * from "./snapshot"
 export * from "./standardActions"
 export * from "./transforms"

package/src/model/BaseModel.ts

@@ -1,9 +1,9 @@
 import { observable } from "mobx"
 import {
-  fromSnapshotOverrideTypeSymbol,
+  type fromSnapshotOverrideTypeSymbol,
   type ModelClass,
-  propsTypeSymbol,
-  toSnapshotOverrideTypeSymbol,
+  type propsTypeSymbol,
+  type toSnapshotOverrideTypeSymbol,
 } from "../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../modelShared/modelInfo"
 import type {
@@ -15,12 +15,12 @@ import { getSnapshot } from "../snapshot/getSnapshot"
 import { setModelInitialDataSnapshot } from "../snapshot/modelInitialData"
 import type { SnapshotInOfModel, SnapshotOutOfModel } from "../snapshot/SnapshotOf"
 import { typesModel } from "../types/objectBased/typesModel"
-import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
+import type { TypeCheckError } from "../types/TypeCheckError"
 import { assertIsObject, failure, nodeObservableOptions } from "../utils"
 import { getModelIdPropertyName } from "./getModelMetadata"
-import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { modelIdKey, modelTypeKey } from "./metadata"
+import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { internalFromSnapshotModel, internalNewModel } from "./newModel"
 import { assertIsModelClass } from "./utils"
 
@@ -134,7 +134,7 @@ export abstract class BaseModel<
   constructor(data: ModelPropsToTransformedCreationData<TProps>) {
     const initialData = data as any
     const constructorOptions =
-      // biome-ignore lint/complexity/noArguments: internal factory code passes hidden constructor options through super().
+      // oxlint-disable-next-line eslint/prefer-rest-params -- internal factory code passes hidden constructor options through super().
       arguments[1] as ModelConstructorOptions
     const { snapshotInitialData, modelClass, generateNewIds } = constructorOptions
 
@@ -205,6 +205,7 @@ export interface AnyModel extends BaseModel<any, any, any, any> {}
  * @param type Abstract model class.
  * @returns
  */
+// oxlint-disable-next-line typescript/no-wrapper-object-types -- part of the public signature
 export function abstractModelClass<T>(type: T): T & Object {
   return type as any
 }

package/src/model/mixins.ts

@@ -2,7 +2,7 @@ import {
   type AbstractModelClass,
   type ModelClass,
   modelClass,
-  propsTypeSymbol,
+  type propsTypeSymbol,
 } from "../modelShared/BaseModelShared"
 import type { ModelProps, ModelPropsToTransformedData } from "../modelShared/prop"
 import type { AnyModel, BaseModelKeys } from "./BaseModel"

package/src/model/newModel.ts

@@ -27,8 +27,8 @@ import { failure, hasOwnProp, inDevMode, makePropReadonly } from "../utils"
 import { setIfDifferent, setIfDifferentWithReturn } from "../utils/setIfDifferent"
 import type { AnyModel } from "./BaseModel"
 import { getModelIdPropertyName } from "./getModelMetadata"
-import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { modelTypeKey } from "./metadata"
+import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { assertIsModelClass } from "./utils"
 
 /**

package/src/modelShared/modelDecorator.ts

@@ -43,9 +43,7 @@ export const model =
 // the model instance type is checked through `prototype` rather than through a typed constructor
 // signature, since comparing constructor signatures would compute the (expensive) model creation data
 // type of every decorated class
-type ModelDecoratorTarget = (new (
-  ...args: any
-) => any) & {
+type ModelDecoratorTarget = (new (...args: any) => any) & {
   prototype: AnyModel | AnyDataModel
 }
 
@@ -191,7 +189,7 @@ function tsDecorate(
     r = (Reflect as any).decorate(decorators, target, key, desc)
   } else {
     for (
-      // biome-ignore lint/correctness/noInnerDeclarations: minified file
+      // oxlint-disable-next-line eslint/no-inner-declarations, eslint/no-var -- minified file
       var i = decorators.length - 1;
       i >= 0;
       i--
@@ -201,8 +199,8 @@ function tsDecorate(
       }
     }
   }
-  // biome-ignore lint/complexity/noCommaOperator: minified file
-  return c > 3 && r && Object.defineProperty(target, key, r), r
+  // oxlint-disable-next-line eslint/no-sequences -- minified file
+  return (c > 3 && r && Object.defineProperty(target, key, r), r)
 }
 
 /**

package/src/modelShared/modelInfo.ts

@@ -58,10 +58,11 @@ export function setModelInfo(modelInfo: ModelInfo, unwrappedClass: ModelClass<an
   // registration of a model
   const baseModelInfo = findModelInfoForPrototype(Object.getPrototypeOf(unwrappedClass.prototype))
   const ancestorDistances = new Map<string, number>()
-  baseModelInfo &&
+  if (baseModelInfo) {
     ancestorDistancesByModelInfo.get(baseModelInfo)?.forEach((distance, name) => {
       ancestorDistances.set(name, distance + 1)
     })
+  }
   ancestorDistances.set(modelInfo.name, 0)
   ancestorDistancesByModelInfo.set(modelInfo, ancestorDistances)
   ancestorDistancesByModelName.set(modelInfo.name, ancestorDistances)

package/src/modelShared/sharedInternalModel.ts

@@ -11,8 +11,8 @@ import type { DataModelMetadata } from "../dataModel/getDataModelMetadata"
 import { getGlobalConfig } from "../globalConfig/globalConfig"
 import { type AnyModel, BaseModel, baseModelPropNames } from "../model/BaseModel"
 import type { ModelMetadata } from "../model/getModelMetadata"
-import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { modelTypeKey } from "../model/metadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { typesObject } from "../types/objectBased/typesObject"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import type { AnyType } from "../types/schemas"

package/src/parent/path.ts

@@ -256,19 +256,20 @@ export function resolvePath<T = any>(
 
     const p = path[i]
 
-    // check just to avoid mobx warnings about trying to access out of bounds index
-    if (isArray(current) && +p >= current.length) {
-      return unresolved
-    }
-
-    if (isModel(current)) {
+    if (isArray(current)) {
+      if (!isArrayIndexOf(current, p)) {
+        return unresolved
+      }
+    } else if (isModel(current)) {
       const dataNode = modelToDataNode(current)
-      if (p in dataNode) {
+      if (hasOwnProp(dataNode, p)) {
         current = dataNode
+      } else if (!hasOwnProp(current, p) && !isInheritedGetter(current, p)) {
+        // the model's own fields and getters (e.g. computed trees) resolve,
+        // but not its methods or anything inherited from Object.prototype
+        return unresolved
       }
-    }
-
-    if (!(p in current)) {
+    } else if (!hasOwnProp(current, p)) {
       return unresolved
     }
 
@@ -278,6 +279,39 @@ export function resolvePath<T = any>(
   return { resolved: true, value: current }
 }
 
+/**
+ * @internal
+ *
+ * Whether a value can be a path element (a property name or an array index).
+ */
+export function isPathElement(value: unknown): value is PathElement {
+  return typeof value === "string" || typeof value === "number"
+}
+
+/**
+ * Whether a path element is an index of the array, so non-index props such as 'length' never
+ * resolve. It also avoids mobx warnings about trying to access out of bounds indexes.
+ */
+function isArrayIndexOf(array: readonly unknown[], p: PathElement): boolean {
+  const index = +p
+  return Number.isInteger(index) && index >= 0 && index < array.length && p in array
+}
+
+/**
+ * Whether a getter is defined for a prop by the prototype chain of an object, below `Object.prototype`.
+ */
+function isInheritedGetter(obj: object, p: PathElement): boolean {
+  let proto = Object.getPrototypeOf(obj)
+  while (proto && proto !== Object.prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(proto, p)
+    if (descriptor) {
+      return descriptor.get !== undefined
+    }
+    proto = Object.getPrototypeOf(proto)
+  }
+  return false
+}
+
 /**
  * @internal
  */
@@ -321,9 +355,8 @@ export function resolvePathCheckingIds<T = any>(
 
     const p = path[i]
 
-    // check just to avoid mobx warnings about trying to access out of bounds index
     if (isArray(current)) {
-      if (+p >= current.length || !(p in current)) {
+      if (!isArrayIndexOf(current, p)) {
         return { resolved: false }
       }
     } else if (!hasOwnProp(current, p)) {

package/src/patch/emitPatch.ts

@@ -148,6 +148,9 @@ export function hasPatchListenersFor(target: object): boolean {
 /**
  * Adds a listener that will be called every time a patch is generated for the tree of the given target object.
  *
+ * The listener runs inside the action that made the change, so `getCurrentActionContext()` returns
+ * that action's context: its `rootContext` is the top-level action (for a flow step, the flow).
+ *
  * @param subtreeRoot Subtree root object of the patch listener.
  * @param listener The listener function that will be called everytime a patch is generated for the object or its children.
  * @returns A disposer to stop listening to patches.
@@ -190,6 +193,9 @@ export function internalOnPatches(
  * Adds a listener that will be called every time a patch is generated anywhere.
  * Usually prefer using `onPatches`.
  *
+ * The listener runs inside the action that made the change, so `getCurrentActionContext()` returns
+ * that action's context: its `rootContext` is the top-level action (for a flow step, the flow).
+ *
  * @param listener The listener function that will be called everytime a patch is generated anywhere.
  * @returns A disposer to stop listening to patches.
  */

package/src/ref/Ref.ts

@@ -1,5 +1,5 @@
-import { Model } from "../model/Model"
 import { modelTypeKey } from "../model/metadata"
+import { Model } from "../model/Model"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import { tProp } from "../types/tProp"