mobx-keystone 2.3.0 → 2.4.0

package/src/serialization/resolvedCall.ts

@@ -0,0 +1,169 @@
+import { type CallResolution, resolveCallName } from "../action/resolveCallName"
+import { fastGetRootPath, isRoot } from "../parent/path"
+import { isTreeNode } from "../tweaker/core"
+import { failure, isArray } from "../utils"
+import type { Call, ResolvedCall } from "./Call"
+import { CallError, CallErrorCode } from "./CallError"
+import type { JsonValue } from "./JsonValue"
+import { isNodeOfTree } from "./references"
+
+/**
+ * @internal
+ */
+export interface ResolvedCallData {
+  readonly resolution: CallResolution
+  /**
+   * Whether the call has `args`, known without decoding them.
+   */
+  readonly hasArgs: boolean
+}
+
+const resolvedCallData = new WeakMap<object, ResolvedCallData>()
+
+/**
+ * @internal
+ */
+export function getResolvedCallData(call: object): ResolvedCallData | undefined {
+  return resolvedCallData.get(call)
+}
+
+/**
+ * @internal
+ */
+export function assertIsTreeRoot(root: object): void {
+  if (!isTreeNode(root) || !isRoot(root)) {
+    throw failure("root must be a tree root")
+  }
+}
+
+function describeTargetLocation(target: unknown): string {
+  if (!isTreeNode(target)) {
+    return "it is not a tree node"
+  }
+  const { path } = fastGetRootPath(target, false)
+  return path.length === 0
+    ? "it is the root of another tree (or detached)"
+    : `it is at path ${JSON.stringify(path)} of another tree`
+}
+
+/**
+ * @internal
+ *
+ * Throws `NotFound` unless the call target is a node of the root's tree.
+ */
+export function assertIsTargetInTree(target: unknown, root: object): asserts target is object {
+  if (!isNodeOfTree(target, root)) {
+    throw new CallError({
+      code: CallErrorCode.NotFound,
+      message: `the call target is not a node of the root's tree: ${describeTargetLocation(target)}`,
+      path: ["target"],
+    })
+  }
+}
+
+/**
+ * @internal
+ *
+ * Resolves a call's name on its target, throwing `UnknownName` when nothing can be called.
+ */
+export function resolveCallNameOrThrow(target: object, name: string): CallResolution {
+  let resolution: ReturnType<typeof resolveCallName>
+  try {
+    resolution = resolveCallName(target, name)
+  } catch (e) {
+    // a data model member on a target that isn't valid data for the data model
+    throw new CallError({
+      code: CallErrorCode.WrongKind,
+      message: `'${name}' cannot be called on the target: its data model can't be created over it`,
+      path: ["target"],
+      cause: e,
+    })
+  }
+  if (resolution === "hook") {
+    throw new CallError({
+      code: CallErrorCode.UnknownName,
+      message: `calls to hooks (${name}) cannot be applied`,
+      path: ["name"],
+    })
+  }
+  if (resolution === "unknown") {
+    throw new CallError({
+      code: CallErrorCode.UnknownName,
+      message: `'${name}' cannot be called on the target: it is not an action or a view`,
+      path: ["name"],
+    })
+  }
+  return resolution
+}
+
+/**
+ * @internal
+ *
+ * Arguments still to decode: `decode` runs once, when `args` is first read.
+ */
+export interface EncodedArgs {
+  readonly rawArgs: JsonValue[]
+  decode(): unknown[]
+}
+
+/**
+ * @internal
+ *
+ * Creates a resolved call, with its arguments, or with arguments still to decode.
+ */
+export function createResolvedCall(
+  target: object,
+  name: string,
+  resolution: CallResolution,
+  args: unknown[] | EncodedArgs | undefined
+): ResolvedCall {
+  const call: { -readonly [K in keyof ResolvedCall]: ResolvedCall[K] } = {
+    target,
+    name,
+    kind: resolution.kind,
+    isFlow: resolution.isFlow,
+  }
+
+  if (args === undefined || isArray(args)) {
+    call.args = args
+  } else {
+    call.rawArgs = args.rawArgs
+    let decodedArgs: unknown[] | undefined
+    Object.defineProperty(call, "args", {
+      enumerable: true,
+      get: () => (decodedArgs ??= args.decode()),
+    })
+  }
+
+  Object.freeze(call)
+  resolvedCallData.set(call, { resolution, hasArgs: args !== undefined })
+  return call
+}
+
+/**
+ * @internal
+ *
+ * Checks the name and args of a call built in process.
+ */
+export function assertIsCallShape(call: Call): void {
+  if (typeof call.name !== "string") {
+    throw failure("call name must be a string")
+  }
+  if (call.args !== undefined && !isArray(call.args)) {
+    throw failure("call args must be an array or undefined")
+  }
+}
+
+/**
+ * @internal
+ *
+ * Resolves a call built in process (its target must be a node of the tree).
+ */
+export function toResolvedCall(call: Call): ResolvedCall {
+  return createResolvedCall(
+    call.target,
+    call.name,
+    resolveCallNameOrThrow(call.target, call.name),
+    call.args
+  )
+}

package/src/snapshot/SnapshotterAndReconcilerPriority.ts

@@ -1,10 +1,11 @@
 /**
  * @internal
  */
-// biome-ignore lint/style/useEnumInitializers: that's ok, it is not serialized
+/* oxlint-disable typescript/prefer-enum-initializers -- that's ok, it is not serialized */
 export enum SnapshotterAndReconcilerPriority {
   Array,
   Frozen,
   Model,
   PlainObject,
 }
+/* oxlint-enable typescript/prefer-enum-initializers */

package/src/snapshot/fromModelSnapshot.ts

@@ -1,7 +1,7 @@
 import type { AnyModel } from "../model/BaseModel"
 import { getModelIdPropertyName } from "../model/getModelMetadata"
-import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { modelTypeKey } from "../model/metadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { getModelOrSnapshotTypeAndId, getSnapshotModelType } from "../model/utils"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"

package/src/snapshot/fromSnapshot.ts

@@ -83,7 +83,7 @@ export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
     let snapshot: any
     let unprocessedSnapshot: unknown
     let options: Partial<FromSnapshotOptions> | undefined
-    // biome-ignore lint/complexity/noArguments: overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
+    // oxlint-disable-next-line eslint/prefer-rest-params -- overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
     const standardType = arguments.length >= 2 ? resolveStandardTypeNoThrow(arg1) : undefined
 
     if (isLateTypeChecker(arg1) || arg1 instanceof TypeChecker || standardType) {

package/src/standardActions/actions.ts

@@ -12,12 +12,20 @@ import { copyFunctionMetadata } from "../utils/decorators"
  */
 type TargetedAction = AnyFunction
 
-const standaloneActionRegistry = new Map<string, TargetedAction>()
+/**
+ * @internal
+ */
+export interface StandaloneActionEntry {
+  readonly fn: TargetedAction
+  readonly isFlow: boolean
+}
+
+const standaloneActionRegistry = new Map<string, StandaloneActionEntry>()
 
 /**
  * @internal
  */
-export function getStandaloneAction(actionName: string) {
+export function getStandaloneAction(actionName: string): StandaloneActionEntry | undefined {
   return standaloneActionRegistry.get(actionName)
 }
 
@@ -59,6 +67,6 @@ export function addStandaloneAction(fullActionName: string, fn: TargetedAction,
   // preserve user-provided metadata without leaking internal action/flow markers.
   copyFunctionMetadata(fn, finalAction)
 
-  standaloneActionRegistry.set(fullActionName, finalAction)
+  standaloneActionRegistry.set(fullActionName, { fn: finalAction, isFlow })
   return finalAction
 }

package/src/transforms/ImmutableDate.ts

@@ -3,25 +3,25 @@ import { failure } from "../utils"
 /**
  * @internal
  */
-export interface ImmutableDate
-  extends Omit<
-    Date,
-    | "setTime"
-    | "setMilliseconds"
-    | "setUTCMilliseconds"
-    | "setSeconds"
-    | "setUTCSeconds"
-    | "setMinutes"
-    | "setUTCMinutes"
-    | "setHours"
-    | "setUTCHours"
-    | "setDate"
-    | "setUTCDate"
-    | "setMonth"
-    | "setUTCMonth"
-    | "setFullYear"
-    | "setUTCFullYear"
-  > {}
+// oxlint-disable-next-line typescript/no-unsafe-declaration-merging -- the class implements this narrowed Date API.
+export interface ImmutableDate extends Omit<
+  Date,
+  | "setTime"
+  | "setMilliseconds"
+  | "setUTCMilliseconds"
+  | "setSeconds"
+  | "setUTCSeconds"
+  | "setMinutes"
+  | "setUTCMinutes"
+  | "setHours"
+  | "setUTCHours"
+  | "setDate"
+  | "setUTCDate"
+  | "setMonth"
+  | "setUTCMonth"
+  | "setFullYear"
+  | "setUTCFullYear"
+> {}
 
 const errMessage = "this Date object is immutable"
 

package/src/tweaker/tweakArray.ts

@@ -36,7 +36,6 @@ import { failure, inDevMode, isArray, isPrimitive } from "../utils"
 import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
 import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
 import { activateHandlers, areHandlersActive, runningWithoutSnapshotOrPatches } from "./core"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import {
   assertCanAttach,
@@ -46,6 +45,7 @@ import {
   tweak,
 } from "./tweak"
 import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { TweakerPriority } from "./TweakerPriority"
 import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**

package/src/tweaker/tweakFrozen.ts

@@ -2,9 +2,9 @@ import { Frozen, frozenKey } from "../frozen/Frozen"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
 import { setNewInternalSnapshot } from "../snapshot/internal"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker } from "./tweak"
+import { TweakerPriority } from "./TweakerPriority"
 
 /**
  * @internal

package/src/tweaker/tweakModel.ts

@@ -1,9 +1,9 @@
 import { isModel } from "../model/utils"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker } from "./tweak"
+import { TweakerPriority } from "./TweakerPriority"
 
 /**
  * @internal

package/src/tweaker/tweakPlainObject.ts

@@ -43,10 +43,10 @@ import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedT
 import { setIfDifferent } from "../utils/setIfDifferent"
 import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
 import { activateHandlers, runningWithoutSnapshotOrPatches } from "./core"
-import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject, treeNodeMetadata } from "./treeNodeMetadata"
 import { assertCanAttachValue, registerTweaker, tweak } from "./tweak"
 import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { TweakerPriority } from "./TweakerPriority"
 import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**

package/src/types/arrayBased/typesArray.ts

@@ -5,7 +5,6 @@ import { createChunkedArrayCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -14,6 +13,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 /**

package/src/types/arrayBased/typesTuple.ts

@@ -5,7 +5,6 @@ import { createWholeContainerCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -14,6 +13,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 /**

package/src/types/objectBased/typesArraySet.ts

@@ -7,7 +7,6 @@ import { typesArray } from "../arrayBased/typesArray"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -16,6 +15,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { resolveCodecSupport } from "../utility/typesCodec"
 import { typesObject } from "./typesObject"
 

package/src/types/objectBased/typesModel.ts

@@ -15,9 +15,8 @@ import {
   snapshotModelTypeMatches,
 } from "../modelTypeMatching"
 import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
-import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import type { AnyStandardType, ModelType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import {
   lateTypeChecker,
   TypeChecker,
@@ -25,6 +24,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 
 const cachedModelTypeChecker = new WeakMap<ModelClass<AnyModel>, TypeChecker>()
 const modelStandardTypes = new WeakSet<object>()

package/src/types/objectBased/typesObject.ts

@@ -23,7 +23,6 @@ import type {
   ObjectTypeFunction,
   TypeToData,
 } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   type LateTypeChecker,
   lateTypeChecker,
@@ -34,6 +33,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 const needsObservableObjectKeyTracking = getMobxVersion() < 5

package/src/types/objectBased/typesObjectMap.ts

@@ -6,7 +6,6 @@ import { ObjectMap } from "../../wrappers/ObjectMap"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -15,6 +14,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { resolveCodecSupport } from "../utility/typesCodec"
 import { typesObject } from "./typesObject"
 import { typesRecord } from "./typesRecord"

package/src/types/objectBased/typesRecord.ts

@@ -6,7 +6,6 @@ import { createChunkedRecordCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, RecordType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -15,6 +14,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 /**

package/src/types/objectBased/typesRef.ts

@@ -10,10 +10,10 @@ import {
 } from "../modelTypeMatching"
 import { typesString } from "../primitiveBased/typesPrimitive"
 import { resolveTypeChecker } from "../resolveTypeChecker"
-import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import type { ModelType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { typesObject } from "./typesObject"
 
 /**

package/src/types/primitiveBased/typesPrimitive.ts

@@ -2,8 +2,8 @@ import { assertIsPrimitive, isEqualOrBothNaN } from "../../utils"
 import type { PrimitiveValue } from "../../utils/types"
 import { registerStandardTypeResolver, type StandardTypeResolverFn } from "../resolveTypeChecker"
 import type { AnyStandardType, IdentityType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import { TypeChecker, TypeCheckerBaseType, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 
 const standardTypeResolvers: StandardTypeResolverFn[] = []
 

package/src/types/schemas.ts

@@ -96,7 +96,7 @@ type ObjectSnapshotOutData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<
 export interface ObjectType<S> extends Type<"object", ObjectData<S>> {}
 
 export interface ObjectTypeFunction {
-  // biome-ignore lint/style/useShorthandFunctionType: make the type recursive
+  // oxlint-disable-next-line typescript/prefer-function-type -- make the type recursive
   (): ObjectOfTypes
 }
 

package/src/types/utility/typesCodecCore.ts

@@ -11,7 +11,6 @@ import type {
   TypeToSnapshotIn,
   TypeToSnapshotOut,
 } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   TypeChecker,
@@ -19,6 +18,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import type { TypeToStoredData } from "./typeToStoredData"
 
 export interface RuntimeAdapter<Stored, Runtime> {

package/src/types/utility/typesCodecSupport.ts

@@ -275,6 +275,7 @@ function createArrayLikeRuntimeAdapter(
       target.length = storedValues.length
       for (let i = 0; i < storedValues.length; i++) {
         if (i in storedValues) target[i] = storedValues[i]
+        // oxlint-disable-next-line typescript/no-array-delete -- keep the holes of sparse arrays
         else delete target[i]
       }
     }
@@ -513,6 +514,7 @@ function createCodecLeafRuntimeAdapter(
 
       // Declared up front (rather than initialized from the call) so that a setter invoked
       // while decoding can read it without hitting the temporal dead zone.
+      // oxlint-disable-next-line eslint/prefer-const -- see above
       let runtime: unknown
       let storedChanged = false
       runtime = transform.transform({

package/src/types/utility/typesOr.ts

@@ -14,9 +14,8 @@ import {
   resolveStandardTypeNoThrow,
   resolveTypeChecker,
 } from "../resolveTypeChecker"
-import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import type { AnyStandardType, AnyType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import {
   getTypeCheckerBaseTypeFromValue,
   lateTypeChecker,
@@ -26,6 +25,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { typesUnchecked } from "./typesUnchecked"
 
 /**

package/src/types/utility/typesRefinement.ts

@@ -1,7 +1,6 @@
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -9,6 +8,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 
 /**
  * A refinement over a given type. This allows you to do extra checks

package/src/utils/errorDiagnostics.ts

@@ -63,11 +63,16 @@ export function getCurrentErrorDiagnosticsContext(): ErrorDiagnosticsContext | u
  * @internal
  */
 export function runWithErrorDiagnosticsContext<T>(fn: () => T): T {
-  const existing = getCurrentErrorDiagnosticsContext()
-  if (existing) {
-    return fn()
-  }
+  return getCurrentErrorDiagnosticsContext() ? fn() : runWithNewErrorDiagnosticsContext(fn)
+}
 
+/**
+ * @internal
+ *
+ * Like `runWithErrorDiagnosticsContext`, but always with a new context, so paths start empty
+ * even when called while another context is active.
+ */
+export function runWithNewErrorDiagnosticsContext<T>(fn: () => T): T {
   const ctx = new ErrorDiagnosticsContext()
   errorDiagnosticsContextStack.push(ctx)
   try {

package/src/utils/index.ts

@@ -117,7 +117,7 @@ export let hasOwnProp: (object: object, propName: PropertyKey) => boolean = (
     typeof Object.hasOwn === "function"
       ? Object.hasOwn
       : (object, propName) => {
-          // biome-ignore lint/suspicious/noPrototypeBuiltins: legacy fallback for runtimes without Object.hasOwn.
+          // oxlint-disable-next-line eslint/no-prototype-builtins -- legacy fallback for runtimes without Object.hasOwn.
           return Object.prototype.hasOwnProperty.call(object, propName)
         }
 
@@ -133,7 +133,7 @@ export let hasOwnProp: (object: object, propName: PropertyKey) => boolean = (
  * @internal
  */
 export function isEqualOrBothNaN(a: unknown, b: unknown): boolean {
-  // biome-ignore lint/suspicious/noSelfCompare: NaN check
+  // oxlint-disable-next-line eslint/no-self-compare -- NaN check
   return a === b || (a !== a && b !== b)
 }
 
@@ -244,19 +244,26 @@ export function isArray(val: unknown): val is any[] | IObservableArray {
   return Array.isArray(val) || isObservableArray(val)
 }
 
-declare const process:
-  | {
-      env?: Record<string, string | undefined>
-    }
-  | undefined
+declare const process: {
+  env: Record<string, string | undefined>
+}
+
+function readInDevMode(): boolean {
+  // Bundlers replace the literal expression `process.env.NODE_ENV` with a string, so it must stay
+  // spelled out in full (no optional chaining, destructuring or `typeof process` guard) for dev
+  // mode to work in browser bundles. The try/catch keeps the library loadable where there is
+  // neither a bundler replacement nor a global `process`.
+  try {
+    return process.env.NODE_ENV !== undefined && process.env.NODE_ENV !== "production"
+  } catch {
+    return false
+  }
+}
 
 /**
  * @internal
  */
-export const inDevMode =
-  typeof process !== "undefined" &&
-  process?.env?.NODE_ENV !== undefined &&
-  process.env.NODE_ENV !== "production"
+export const inDevMode = readInDevMode()
 
 /**
  * @internal
@@ -390,11 +397,11 @@ export function logWarning(type: "warn" | "error", msg: string, uniqueKey?: stri
   msg = "[mobx-keystone] " + msg
   switch (type) {
     case "warn":
-      // biome-ignore lint/suspicious/noConsole: this internal helper intentionally emits user-facing warnings.
+      // oxlint-disable-next-line eslint/no-console -- this internal helper intentionally emits user-facing warnings.
       console.warn(msg)
       break
     case "error":
-      // biome-ignore lint/suspicious/noConsole: this internal helper intentionally emits user-facing errors.
+      // oxlint-disable-next-line eslint/no-console -- this internal helper intentionally emits user-facing errors.
       console.error(msg)
       break
     default: