r-state-tree 0.3.1 → 0.4.0

package/dist/r-state-tree.js

@@ -1,4 +1,64 @@
-import { batch, Signal, signal, computed, untracked, effect } from "@preact/signals-core";
+import { batch, Signal, signal, computed as computed$1, untracked, effect } from "@preact/signals-core";
+import { ReadonlySignal, Signal as Signal2, batch as batch2, effect as effect2, signal as signal2, untracked as untracked2 } from "@preact/signals-core";
+var lib = {};
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  Object.defineProperty(lib, "__esModule", { value: true });
+  Symbol.metadata ??= Symbol("Symbol.metadata");
+  return lib;
+}
+requireLib();
+var CommonCfgTypes = /* @__PURE__ */ ((CommonCfgTypes2) => {
+  CommonCfgTypes2["child"] = "child";
+  return CommonCfgTypes2;
+})(CommonCfgTypes || {});
+var ModelCfgTypes = /* @__PURE__ */ ((ModelCfgTypes2) => {
+  ModelCfgTypes2["state"] = "state";
+  ModelCfgTypes2["id"] = "id";
+  ModelCfgTypes2["modelRef"] = "modelRef";
+  return ModelCfgTypes2;
+})(ModelCfgTypes || {});
+var StoreCfgTypes = /* @__PURE__ */ ((StoreCfgTypes2) => {
+  StoreCfgTypes2["model"] = "model";
+  return StoreCfgTypes2;
+})(StoreCfgTypes || {});
+var ObservableCfgTypes = /* @__PURE__ */ ((ObservableCfgTypes2) => {
+  ObservableCfgTypes2["observable"] = "observable";
+  ObservableCfgTypes2["computed"] = "computed";
+  return ObservableCfgTypes2;
+})(ObservableCfgTypes || {});
+const childType = Object.assign(
+  function(childType2) {
+    return { type: "child", childType: childType2 };
+  },
+  {
+    type: "child"
+    /* child */
+  }
+);
+const stateType = {
+  type: "state"
+  /* state */
+};
+const modelRefType = Object.assign(
+  function(childType2) {
+    return { type: "modelRef", childType: childType2 };
+  },
+  {
+    type: "modelRef"
+    /* modelRef */
+  }
+);
+const idType = {
+  type: "id"
+  /* id */
+};
+const modelType = {
+  type: "model"
+  /* model */
+};
 function isNonPrimitive(val) {
   return val != null && (typeof val === "object" || typeof val === "function");
 }
@@ -6,15 +66,34 @@ function isPropertyKey(val) {
   return typeof val === "string" || typeof val === "number" || typeof val === "symbol";
 }
 function getPropertyType(key, obj) {
+  const hasMetadata = obj.constructor[Symbol.metadata] !== void 0;
   const descriptor = getPropertyDescriptor$1(obj, key);
-  if (descriptor) {
-    if (typeof descriptor.get === "function" || typeof descriptor.set === "function") {
+  if (descriptor?.value && typeof descriptor.value === "function") {
+    return "action";
+  }
+  const isGetter = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
+  if (!hasMetadata) {
+    if (isGetter) {
       return "computed";
-    } else if (typeof descriptor.value === "function") {
-      return "action";
+    }
+    return "observable";
+  }
+  const metadata = obj.constructor[Symbol.metadata];
+  if (metadata && metadata[key]) {
+    const config = metadata[key];
+    switch (config.type) {
+      case ObservableCfgTypes.computed:
+        return "computed";
+      case ModelCfgTypes.state:
+      case ObservableCfgTypes.observable:
+      case ModelCfgTypes.id:
+      case ModelCfgTypes.modelRef:
+      case CommonCfgTypes.child:
+      case StoreCfgTypes.model:
+        return "observable";
     }
   }
-  return "observable";
+  return null;
 }
 function getPropertyDescriptor$1(obj, key) {
   let node = obj;
@@ -36,9 +115,15 @@ function resolveNode(node) {
   return node.node ?? node;
 }
 let circularRefSet = null;
-const _Administration = class _Administration {
+class Administration {
+  static proxyTraps = {};
+  proxy;
+  source;
+  atom;
+  valuesMap;
+  isObserved = false;
+  forceObservedAtoms;
   constructor(source2) {
-    this.isObserved = false;
     this.atom = createObservedAtom();
     this.source = source2;
     this.proxy = new Proxy(
@@ -85,12 +170,13 @@ const _Administration = class _Administration {
       circularRefSet = null;
     }
   }
-};
-_Administration.proxyTraps = {};
-let Administration = _Administration;
+}
 class NodeMap {
+  map;
+  weakMap;
+  observedAtom;
+  cleanUpRegistered = false;
   constructor(observedAtom) {
-    this.cleanUpRegistered = false;
     this.observedAtom = observedAtom;
   }
   registerCleanup() {
@@ -153,7 +239,47 @@ class SignalMap extends NodeMap {
     return createSignal(initialValue);
   }
 }
-const _ObjectAdministration = class _ObjectAdministration extends Administration {
+class ObjectAdministration extends Administration {
+  keysAtom;
+  hasMap;
+  valuesMap;
+  computedMap;
+  types;
+  static proxyTraps = {
+    has(target, name) {
+      const adm = getAdministration(target);
+      if (!(name in Object.prototype) && isPropertyKey(name))
+        return adm.has(name);
+      return Reflect.has(adm.source, name);
+    },
+    get(target, name) {
+      const adm = getAdministration(target);
+      if (!(name in Object.prototype) && isPropertyKey(name) && (typeof adm.source !== "function" || name !== "prototype")) {
+        return adm.read(name);
+      }
+      return Reflect.get(adm.source, name, adm.proxy);
+    },
+    set(target, name, value) {
+      if (!isPropertyKey(name)) return false;
+      const adm = getAdministration(target);
+      adm.write(name, value);
+      return true;
+    },
+    deleteProperty(target, name) {
+      if (!isPropertyKey(name)) return false;
+      const adm = getAdministration(target);
+      adm.remove(name);
+      return true;
+    },
+    ownKeys(target) {
+      const adm = getAdministration(target);
+      batch(() => {
+        adm.keysAtom.reportObserved();
+        adm.atom.reportObserved();
+      });
+      return Reflect.ownKeys(adm.source);
+    }
+  };
   constructor(source2 = {}) {
     super(source2);
     this.keysAtom = createAtom();
@@ -165,7 +291,7 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
     return Reflect.get(this.source, key, this.proxy);
   }
   set(key, value) {
-    runInBatch(() => {
+    batch(() => {
       Reflect.set(this.source, key, value, this.proxy);
     });
   }
@@ -188,7 +314,7 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
   }
   getType(key) {
     let type = this.types.get(key);
-    if (!type) {
+    if (type === void 0) {
       type = getPropertyType(key, this.source);
       this.types.set(key, type);
     }
@@ -221,6 +347,9 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
   }
   read(key) {
     const type = this.getType(key);
+    if (type === null) {
+      return this.get(key);
+    }
     switch (type) {
       case "observable":
       case "action": {
@@ -245,8 +374,12 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
   }
   write(key, newValue) {
     const type = this.getType(key);
+    if (type === null) {
+      this.set(key, newValue);
+      return;
+    }
     if (type === "computed") {
-      runInBatch(() => this.set(key, newValue));
+      batch(() => this.set(key, newValue));
       return;
     }
     const had = key in this.source;
@@ -257,7 +390,7 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
     }
     if (!had || (isObservable(oldValue) ? oldValue !== newValue : oldValue !== targetValue)) {
       this.set(key, targetValue);
-      runInBatch(() => {
+      batch(() => {
         this.flushChange();
         if (!had) {
           this.keysAtom.reportChanged();
@@ -277,7 +410,7 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
   remove(key) {
     if (!(key in this.source)) return;
     delete this.source[key];
-    runInBatch(() => {
+    batch(() => {
       this.flushChange();
       this.valuesMap.reportChanged(key, void 0);
       this.keysAtom.reportChanged();
@@ -285,66 +418,29 @@ const _ObjectAdministration = class _ObjectAdministration extends Administration
       this.valuesMap.delete(key);
     });
   }
-};
-_ObjectAdministration.proxyTraps = {
-  has(target, name) {
-    const adm = getAdministration(target);
-    if (!(name in Object.prototype) && isPropertyKey(name))
-      return adm.has(name);
-    return Reflect.has(adm.source, name);
-  },
-  get(target, name) {
-    const adm = getAdministration(target);
-    if (!(name in Object.prototype) && isPropertyKey(name) && (typeof adm.source !== "function" || name !== "prototype")) {
-      return adm.read(name);
-    }
-    return Reflect.get(adm.source, name, adm.proxy);
-  },
-  set(target, name, value) {
-    if (!isPropertyKey(name)) return false;
-    const adm = getAdministration(target);
-    adm.write(name, value);
-    return true;
-  },
-  deleteProperty(target, name) {
-    if (!isPropertyKey(name)) return false;
-    const adm = getAdministration(target);
-    adm.remove(name);
-    return true;
-  },
-  ownKeys(target) {
-    const adm = getAdministration(target);
-    runInBatch(() => {
-      adm.keysAtom.reportObserved();
-      adm.atom.reportObserved();
-    });
-    return Reflect.ownKeys(adm.source);
-  }
-};
-let ObjectAdministration = _ObjectAdministration;
-const _PreactObjectAdministration = class _PreactObjectAdministration extends ObjectAdministration {
-};
-_PreactObjectAdministration.proxyTraps = Object.assign(
-  {},
-  ObjectAdministration.proxyTraps,
-  {
-    get(target, prop, proxy) {
-      if (!(prop in target) && (typeof prop === "string" || typeof prop === "number") && String(prop)[0] === "$") {
-        return getSignal(proxy, prop.substring(1));
+}
+class PreactObjectAdministration extends ObjectAdministration {
+  static proxyTraps = Object.assign(
+    {},
+    ObjectAdministration.proxyTraps,
+    {
+      get(target, prop, proxy) {
+        if (!(prop in target) && (typeof prop === "string" || typeof prop === "number") && String(prop)[0] === "$") {
+          return getSignal(proxy, prop.substring(1));
+        }
+        return ObjectAdministration.proxyTraps.get?.apply(
+          null,
+          arguments
+        );
       }
-      return ObjectAdministration.proxyTraps.get?.apply(
-        null,
-        arguments
-      );
     }
-  }
-);
-let PreactObjectAdministration = _PreactObjectAdministration;
+  );
+}
 function createObservedAtom() {
   let value = 0;
   const callbacks = /* @__PURE__ */ new Set();
   let observing = false;
-  const signal2 = new Signal(value, {
+  const signal22 = new Signal(value, {
     watched() {
       callbacks.forEach((callback) => callback(true));
       observing = true;
@@ -355,12 +451,12 @@ function createObservedAtom() {
     }
   });
   return {
-    node: signal2,
+    node: signal22,
     reportObserved() {
-      return signal2.value;
+      return signal22.value;
     },
     reportChanged() {
-      return signal2.value = ++value;
+      return signal22.value = ++value;
     },
     get observing() {
       return observing;
@@ -404,13 +500,7 @@ function createAtom() {
     }
   };
 }
-function createEffect(fn) {
-  return effect(fn);
-}
-function runInUntracked(fn) {
-  return untracked(() => fn());
-}
-function createReaction(fn, callback) {
+function reaction(fn, callback) {
   let initialized = false;
   let currentValue;
   return effect(() => {
@@ -469,7 +559,7 @@ function createListener(callback) {
   return listener;
 }
 function createComputed(fn, context = null) {
-  const c = computed(context ? fn.bind(context) : fn);
+  const c = computed$1(context ? fn.bind(context) : fn);
   return {
     node: c,
     get() {
@@ -482,15 +572,23 @@ function createComputed(fn, context = null) {
     }
   };
 }
-function observable(obj) {
-  return getObservable(obj);
+function observable(value, context) {
+  if (context && typeof context === "object" && "kind" in context) {
+    context.metadata[context.name] = { type: "observable" };
+    return value;
+  }
+  return getObservable(value);
+}
+function computed(value, context) {
+  if (context && typeof context === "object" && "kind" in context) {
+    context.metadata[context.name] = { type: "computed" };
+    return value;
+  }
+  return computed$1(value);
 }
 function source(obj) {
   return getSource(obj);
 }
-function runInBatch(fn) {
-  return batch(() => fn());
-}
 class Observable {
   constructor() {
     return getObservableClassInstance(this);
@@ -510,10 +608,10 @@ const signalMap = /* @__PURE__ */ new WeakMap();
 function getSignal(obj, key) {
   const node = getInternalNode(obj, key);
   if (node instanceof Signal) {
-    let signal2 = signalMap.get(node);
-    if (!signal2) {
-      signal2 = new Signal();
-      Object.defineProperties(signal2, {
+    let signal22 = signalMap.get(node);
+    if (!signal22) {
+      signal22 = new Signal();
+      Object.defineProperties(signal22, {
         value: {
           get() {
             return obj[key];
@@ -528,17 +626,46 @@ function getSignal(obj, key) {
           }
         }
       });
-      signalMap.set(node, signal2);
+      signalMap.set(node, signal22);
     }
-    return signal2;
+    return signal22;
   }
   return node;
 }
-var _a, _b;
-const _CollectionAdministration = class _CollectionAdministration extends Administration {
+class CollectionAdministration extends Administration {
+  isMap;
+  hasMap;
+  valuesMap;
+  keysAtom;
+  static proxyTraps = {
+    get(target, name) {
+      const adm = getAdministration(target);
+      if (name === "size" && "size" in adm.source) {
+        return adm.size;
+      }
+      const val = adm.source[name];
+      const collectionMethods = adm.constructor.methods;
+      if (collectionMethods.hasOwnProperty(name) && typeof val === "function") {
+        return collectionMethods[name];
+      }
+      return val;
+    }
+  };
+  static methods = {
+    clear: createMethod$1("clear"),
+    forEach: createMethod$1("forEach"),
+    has: createMethod$1("has"),
+    add: createMethod$1("add"),
+    set: createMethod$1("set"),
+    get: createMethod$1("get"),
+    delete: createMethod$1("delete"),
+    entries: createMethod$1("entries"),
+    keys: createMethod$1("keys"),
+    values: createMethod$1("values"),
+    [Symbol.iterator]: createMethod$1(Symbol.iterator)
+  };
   constructor(source2) {
     super(source2);
-    this[_a] = "Set";
     this.hasMap = new AtomMap(this.atom);
     this.valuesMap = new SignalMap();
     this.keysAtom = createAtom();
@@ -548,7 +675,7 @@ const _CollectionAdministration = class _CollectionAdministration extends Admini
     return this.source.has(getSource(key)) || this.source.has(key);
   }
   onCollectionChange(key) {
-    runInBatch(() => {
+    batch(() => {
       this.keysAtom.reportChanged();
       this.hasMap.reportChanged(key);
       this.flushChange();
@@ -573,7 +700,7 @@ const _CollectionAdministration = class _CollectionAdministration extends Admini
     );
   }
   clear() {
-    runInBatch(() => {
+    batch(() => {
       this.source.forEach((_, key) => this.delete(key));
     });
   }
@@ -674,7 +801,7 @@ const _CollectionAdministration = class _CollectionAdministration extends Admini
     const hasKey = this.hasEntry(key);
     const oldValue = sourceMap.get(targetKey) ?? sourceMap.get(key);
     if (!hasKey || isObservable(oldValue) ? oldValue !== value : oldValue !== targetValue) {
-      runInBatch(() => {
+      batch(() => {
         this.flushChange();
         if (sourceMap.has(key)) {
           sourceMap.set(key, targetValue);
@@ -709,45 +836,126 @@ const _CollectionAdministration = class _CollectionAdministration extends Admini
       }
     };
   }
-  [(_b = Symbol.iterator, _a = Symbol.toStringTag, _b)]() {
+  [Symbol.iterator]() {
     return this.isMap ? this.entries() : this.values();
   }
-};
-_CollectionAdministration.proxyTraps = {
-  get(target, name) {
-    const adm = getAdministration(target);
-    if (name === "size" && "size" in adm.source) {
-      return adm.size;
-    }
-    const val = adm.source[name];
-    const collectionMethods = adm.constructor.methods;
-    if (collectionMethods.hasOwnProperty(name) && typeof val === "function") {
-      return collectionMethods[name];
-    }
-    return val;
-  }
-};
-_CollectionAdministration.methods = {
-  clear: createMethod$1("clear"),
-  forEach: createMethod$1("forEach"),
-  has: createMethod$1("has"),
-  add: createMethod$1("add"),
-  set: createMethod$1("set"),
-  get: createMethod$1("get"),
-  delete: createMethod$1("delete"),
-  entries: createMethod$1("entries"),
-  keys: createMethod$1("keys"),
-  values: createMethod$1("values"),
-  [Symbol.iterator]: createMethod$1(Symbol.iterator)
-};
-let CollectionAdministration = _CollectionAdministration;
+  [Symbol.toStringTag] = "Set";
+}
 function createMethod$1(method) {
   return function() {
     const adm = getAdministration(this);
     return adm[method].apply(adm, arguments);
   };
 }
-const _ArrayAdministration = class _ArrayAdministration extends Administration {
+class ArrayAdministration extends Administration {
+  valuesMap;
+  keysAtom;
+  static proxyTraps = {
+    get(target, name) {
+      const adm = getAdministration(target);
+      if (name === "length") {
+        return adm.getArrayLength();
+      }
+      if (typeof name === "number") {
+        return adm.get(name);
+      }
+      if (typeof name === "string" && String(parseInt(name)) === name) {
+        return adm.get(parseInt(name));
+      }
+      const arrayMethods = adm.constructor.methods;
+      if (arrayMethods.hasOwnProperty(name)) {
+        return arrayMethods[name];
+      }
+      return adm.source[name];
+    },
+    set(target, name, value) {
+      const adm = getAdministration(target);
+      if (name === "length") {
+        adm.setArrayLength(value);
+      } else if (typeof name === "number") {
+        adm.set(name, value);
+      } else if (typeof name === "string" && String(parseInt(name)) === name) {
+        adm.set(parseInt(name), value);
+      } else {
+        adm.source[name] = value;
+      }
+      return true;
+    }
+  };
+  static methods = {
+    fill(value, start, end) {
+      const adm = getAdministration(this);
+      const oldLength = adm.source.length;
+      adm.source.fill(value, start, end);
+      adm.onArrayChanged(oldLength !== adm.source.length, start, end);
+      return this;
+    },
+    splice(index, deleteCount, ...newItems) {
+      const adm = getAdministration(this);
+      switch (arguments.length) {
+        case 0:
+          return [];
+        case 1:
+          return adm.spliceWithArray(index);
+        case 2:
+          return adm.spliceWithArray(index, deleteCount);
+      }
+      return adm.spliceWithArray(index, deleteCount, newItems);
+    },
+    push(...items) {
+      const adm = getAdministration(this);
+      adm.spliceWithArray(adm.source.length, 0, items);
+      return adm.source.length;
+    },
+    pop() {
+      return this.splice(
+        Math.max(getAdministration(this).source.length - 1, 0),
+        1
+      )[0];
+    },
+    shift() {
+      return this.splice(0, 1)[0];
+    },
+    unshift(...items) {
+      const adm = getAdministration(this);
+      adm.spliceWithArray(0, 0, items);
+      return adm.source.length;
+    },
+    reverse() {
+      const adm = getAdministration(this);
+      adm.source.reverse();
+      adm.onArrayChanged(false, 0, adm.source.length);
+      return this;
+    },
+    sort(compareFn) {
+      const adm = getAdministration(this);
+      adm.onArrayChanged();
+      adm.source.sort(
+        compareFn && ((a, b) => compareFn(getObservable(a), getObservable(b)))
+      );
+      return this;
+    },
+    join: createStringMethod("join"),
+    toString: createStringMethod("toString"),
+    toLocaleString: createStringMethod("toLocaleString"),
+    indexOf: createSearchMethod("indexOf"),
+    lastIndexOf: createSearchMethod("lastIndexOf"),
+    includes: createSearchMethod("includes"),
+    slice: createCopyMethod("slice"),
+    concat: createCopyMethod("concat"),
+    flat: createCopyMethod("flat"),
+    copyWithin: createCopyMethod("copyWithin"),
+    every: createMapMethod("every"),
+    forEach: createMapMethod("forEach"),
+    map: createMapMethod("map"),
+    flatMap: createMapMethod("flatMap"),
+    findIndex: createMapMethod("findIndex"),
+    some: createMapMethod("some"),
+    filter: createFilterMethod("filter"),
+    find: createFilterMethod("find"),
+    reduce: createReduceMethod("reduce"),
+    reduceRight: createReduceMethod("reduceRight")
+  };
   constructor(source2 = []) {
     super(source2);
     this.valuesMap = new SignalMap();
@@ -838,7 +1046,7 @@ const _ArrayAdministration = class _ArrayAdministration extends Administration {
     );
   }
   onArrayChanged(lengthChanged = false, index, count) {
-    runInBatch(() => {
+    batch(() => {
       if (lengthChanged) {
         this.keysAtom.reportChanged();
       }
@@ -852,114 +1060,7 @@ const _ArrayAdministration = class _ArrayAdministration extends Administration {
       this.flushChange();
     });
   }
-};
-_ArrayAdministration.proxyTraps = {
-  get(target, name) {
-    const adm = getAdministration(target);
-    if (name === "length") {
-      return adm.getArrayLength();
-    }
-    if (typeof name === "number") {
-      return adm.get(name);
-    }
-    if (typeof name === "string" && String(parseInt(name)) === name) {
-      return adm.get(parseInt(name));
-    }
-    const arrayMethods = adm.constructor.methods;
-    if (arrayMethods.hasOwnProperty(name)) {
-      return arrayMethods[name];
-    }
-    return adm.source[name];
-  },
-  set(target, name, value) {
-    const adm = getAdministration(target);
-    if (name === "length") {
-      adm.setArrayLength(value);
-    } else if (typeof name === "number") {
-      adm.set(name, value);
-    } else if (typeof name === "string" && String(parseInt(name)) === name) {
-      adm.set(parseInt(name), value);
-    } else {
-      adm.source[name] = value;
-    }
-    return true;
-  }
-};
-_ArrayAdministration.methods = {
-  fill(value, start, end) {
-    const adm = getAdministration(this);
-    const oldLength = adm.source.length;
-    adm.source.fill(value, start, end);
-    adm.onArrayChanged(oldLength !== adm.source.length, start, end);
-    return this;
-  },
-  splice(index, deleteCount, ...newItems) {
-    const adm = getAdministration(this);
-    switch (arguments.length) {
-      case 0:
-        return [];
-      case 1:
-        return adm.spliceWithArray(index);
-      case 2:
-        return adm.spliceWithArray(index, deleteCount);
-    }
-    return adm.spliceWithArray(index, deleteCount, newItems);
-  },
-  push(...items) {
-    const adm = getAdministration(this);
-    adm.spliceWithArray(adm.source.length, 0, items);
-    return adm.source.length;
-  },
-  pop() {
-    return this.splice(
-      Math.max(getAdministration(this).source.length - 1, 0),
-      1
-    )[0];
-  },
-  shift() {
-    return this.splice(0, 1)[0];
-  },
-  unshift(...items) {
-    const adm = getAdministration(this);
-    adm.spliceWithArray(0, 0, items);
-    return adm.source.length;
-  },
-  reverse() {
-    const adm = getAdministration(this);
-    adm.source.reverse();
-    adm.onArrayChanged(false, 0, adm.source.length);
-    return this;
-  },
-  sort(compareFn) {
-    const adm = getAdministration(this);
-    adm.onArrayChanged();
-    adm.source.sort(
-      compareFn && ((a, b) => compareFn(getObservable(a), getObservable(b)))
-    );
-    return this;
-  },
-  join: createStringMethod("join"),
-  toString: createStringMethod("toString"),
-  toLocaleString: createStringMethod("toLocaleString"),
-  indexOf: createSearchMethod("indexOf"),
-  lastIndexOf: createSearchMethod("lastIndexOf"),
-  includes: createSearchMethod("includes"),
-  slice: createCopyMethod("slice"),
-  concat: createCopyMethod("concat"),
-  flat: createCopyMethod("flat"),
-  copyWithin: createCopyMethod("copyWithin"),
-  every: createMapMethod("every"),
-  forEach: createMapMethod("forEach"),
-  map: createMapMethod("map"),
-  flatMap: createMapMethod("flatMap"),
-  findIndex: createMapMethod("findIndex"),
-  some: createMapMethod("some"),
-  filter: createFilterMethod("filter"),
-  find: createFilterMethod("find"),
-  reduce: createReduceMethod("reduce"),
-  reduceRight: createReduceMethod("reduceRight")
-};
-let ArrayAdministration = _ArrayAdministration;
+}
 function createMethod(method, func) {
   if (Array.prototype.hasOwnProperty(method)) {
     return func;
@@ -1046,23 +1147,22 @@ function createReduceMethod(method) {
     return adm.source[method].apply(adm.source, arguments);
   });
 }
-const _DateAdministration = class _DateAdministration extends Administration {
-};
-_DateAdministration.proxyTraps = {
-  get(target, name) {
-    const adm = getAdministration(target);
-    if (typeof adm.source[name] === "function") {
-      if (typeof name === "string" && name.startsWith("set")) {
-        addDateSetMethod(name);
-      } else {
-        addDateGetMethod(name);
+class DateAdministration extends Administration {
+  static proxyTraps = {
+    get(target, name) {
+      const adm = getAdministration(target);
+      if (typeof adm.source[name] === "function") {
+        if (typeof name === "string" && name.startsWith("set")) {
+          addDateSetMethod(name);
+        } else {
+          addDateGetMethod(name);
+        }
+        return dateMethods[name];
       }
-      return dateMethods[name];
+      return adm.source[name];
     }
-    return adm.source[name];
-  }
-};
-let DateAdministration = _DateAdministration;
+  };
+}
 const dateMethods = /* @__PURE__ */ Object.create(null);
 function addDateSetMethod(method) {
   if (!dateMethods[method])
@@ -1157,60 +1257,6 @@ function getInternalNode(obj, key) {
   }
   return adm.getNode(key);
 }
-var CommonCfgTypes = /* @__PURE__ */ ((CommonCfgTypes2) => {
-  CommonCfgTypes2["child"] = "child";
-  CommonCfgTypes2["children"] = "children";
-  return CommonCfgTypes2;
-})(CommonCfgTypes || {});
-var ModelCfgTypes = /* @__PURE__ */ ((ModelCfgTypes2) => {
-  ModelCfgTypes2["state"] = "state";
-  ModelCfgTypes2["id"] = "id";
-  ModelCfgTypes2["modelRef"] = "modelRef";
-  ModelCfgTypes2["modelRefs"] = "modelRefs";
-  return ModelCfgTypes2;
-})(ModelCfgTypes || {});
-var StoreCfgTypes = /* @__PURE__ */ ((StoreCfgTypes2) => {
-  StoreCfgTypes2["model"] = "model";
-  return StoreCfgTypes2;
-})(StoreCfgTypes || {});
-const childType = Object.assign(
-  function(childType2) {
-    return { type: "child", childType: childType2 };
-  },
-  {
-    type: "child"
-    /* child */
-  }
-);
-const childrenType = Object.assign(
-  function(childType2) {
-    return { type: "children", childType: childType2 };
-  },
-  {
-    type: "children"
-    /* children */
-  }
-);
-const stateType = {
-  type: "state"
-  /* state */
-};
-const modelRefType = {
-  type: "modelRef"
-  /* modelRef */
-};
-const modelRefsType = {
-  type: "modelRefs"
-  /* modelRefs */
-};
-const idType = {
-  type: "id"
-  /* id */
-};
-const modelType = {
-  type: "model"
-  /* model */
-};
 function getPropertyDescriptor(obj, key) {
   let node = obj;
   while (node) {
@@ -1249,17 +1295,20 @@ function getDiff(o1, o2, getConfig) {
     const key = keys[i];
     if (obj1[key] !== obj2[key]) {
       if (config?.[key]?.type === CommonCfgTypes.child) {
-        const childDiff = getDiff(obj1[key], obj2[key], getConfig);
-        if (childDiff) {
-          diff[key] = childDiff;
-        }
-      } else if (config?.[key]?.type === CommonCfgTypes.children) {
-        diff[key] = obj2[key].map((model2, index) => {
-          if (obj1[key][index]) {
-            return getDiff(obj1[key][index], model2, getConfig);
+        const value = obj2[key];
+        if (Array.isArray(value)) {
+          diff[key] = value.map((model2, index) => {
+            if (obj1[key][index]) {
+              return getDiff(obj1[key][index], model2, getConfig);
+            }
+            return model2;
+          });
+        } else {
+          const childDiff = getDiff(obj1[key], obj2[key], getConfig);
+          if (childDiff) {
+            diff[key] = childDiff;
           }
-          return model2;
-        });
+        }
       } else {
         diff[key] = obj2[key];
       }
@@ -1267,25 +1316,9 @@ function getDiff(o1, o2, getConfig) {
   }
   return Object.keys(diff).length > 0 ? diff : null;
 }
-function computedProxy(computed2) {
-  const initial = {};
-  Object.keys(computed2.get()).forEach((k) => initial[k] = void 0);
-  const proxy = new Proxy(initial, {
-    get(target, key) {
-      if (!target[key]) {
-        target[key] = createComputed(
-          () => computed2.get()[key],
-          null
-        );
-      }
-      return target[key].get();
-    }
-  });
-  return proxy;
-}
 function updateProps(props, newProps) {
-  runInUntracked(() => {
-    runInBatch(() => {
+  untracked(() => {
+    batch(() => {
       const propKeys = Object.keys(newProps);
       propKeys.forEach((k) => {
         if (k !== "models") {
@@ -1302,26 +1335,63 @@ function updateProps(props, newProps) {
 function getStoreAdm(store) {
   return getAdministration(store);
 }
-const _StoreAdministration = class _StoreAdministration extends PreactObjectAdministration {
-  constructor() {
-    super(...arguments);
-    this.parent = null;
-    this.mounted = false;
-    this.contextReactionUnsub = null;
-    this.childStoreDataMap = /* @__PURE__ */ new Map();
-    this.reactionsUnsub = [];
-  }
-  setConfiguration(configuration) {
-    this.configuration = configuration;
+class StoreAdministration extends PreactObjectAdministration {
+  static proxyTraps = Object.assign(
+    {},
+    PreactObjectAdministration.proxyTraps,
+    {
+      get(target, name) {
+        if (name === "key") {
+          return target.key;
+        }
+        const adm = getAdministration(target);
+        switch (adm.configuration[name]?.type) {
+          case CommonCfgTypes.child:
+            return adm.getStore(name);
+          case StoreCfgTypes.model:
+            return adm.getModelRef(name);
+          default:
+            return PreactObjectAdministration.proxyTraps.get?.apply(
+              null,
+              arguments
+            );
+        }
+      },
+      set(target, name, value) {
+        const adm = getAdministration(target);
+        if (name === "props") {
+          throw new Error(`r-state-tree: ${name} is read-only`);
+        }
+        if (adm.configuration[name]?.type === StoreCfgTypes.model) {
+          if (value !== void 0) {
+            throw new Error(`r-state-tree: model ${String(name)} is read-only`);
+          }
+        }
+        return PreactObjectAdministration.proxyTraps.set?.apply(
+          null,
+          arguments
+        );
+      }
+    }
+  );
+  parent = null;
+  mounted = false;
+  contextCache = /* @__PURE__ */ new Map();
+  childStoreDataMap = /* @__PURE__ */ new Map();
+  reactionsUnsub = [];
+  configurationGetter;
+  setConfiguration(configurationGetter) {
+    this.configurationGetter = configurationGetter;
+  }
+  get configuration() {
+    return this.configurationGetter?.() ?? {};
   }
   createChildStore(element) {
     return allowNewStore(() => new element.Type(element.props));
   }
   setStoreList(name, elements) {
     const childStoreData = this.childStoreDataMap.get(name);
-    const oldStores = runInUntracked(
-      () => childStoreData.value.get()
-    );
+    const oldStores = untracked(() => childStoreData.value.get());
     const stores = [];
     let keyedIndexChanged = false;
     if (!oldStores) {
@@ -1380,7 +1450,7 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
       }
     });
     if (newStores.size || removedStores.size || keyedIndexChanged) {
-      runInBatch(() => childStoreData.value.set(stores));
+      batch(() => childStoreData.value.set(stores));
     }
     removedStores.forEach((s) => getStoreAdm(s).unmount());
     newStores.forEach((s) => getStoreAdm(s).mount(this));
@@ -1388,24 +1458,24 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
   }
   setSingleStore(name, element) {
     const childStoreData = this.childStoreDataMap.get(name);
-    const oldStore = runInUntracked(
+    const oldStore = untracked(
       () => childStoreData.value.get()
     );
     const { key, Type, props } = element || {};
     if (!element) {
       oldStore && getStoreAdm(oldStore).unmount();
-      runInBatch(() => childStoreData.value.set(null));
+      batch(() => childStoreData.value.set(null));
       return null;
     } else if (!oldStore || oldStore.props.key !== key || !(oldStore instanceof Type)) {
       if (oldStore) {
         getStoreAdm(oldStore).unmount();
       }
       const childStore = this.createChildStore(element);
-      runInBatch(() => childStoreData.value.set(childStore));
+      batch(() => childStoreData.value.set(childStore));
       getStoreAdm(childStore).mount(this);
       return childStore;
     } else {
-      runInBatch(() => updateProps(oldStore.props, props));
+      batch(() => updateProps(oldStore.props, props));
       return oldStore;
     }
   }
@@ -1414,14 +1484,7 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
     const storeElement = childStoreData.listener.track(
       () => childStoreData.computed.get()
     );
-    this.setSingleStore(name, storeElement);
-  }
-  updateStores(name) {
-    const childStoreData = this.childStoreDataMap.get(name);
-    const storeElement = childStoreData.listener.track(
-      () => childStoreData.computed.get()
-    );
-    this.setStoreList(name, storeElement);
+    Array.isArray(storeElement) ? this.setStoreList(name, storeElement) : this.setSingleStore(name, storeElement);
   }
   getComputedGetter(name) {
     const descriptor = getPropertyDescriptor(this.source, name);
@@ -1441,21 +1504,7 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
     const storeElement = childStoreData.listener.track(
       () => childStoreData.computed.get()
     );
-    this.setSingleStore(name, storeElement);
-    return childStoreData.value.get();
-  }
-  initializeStores(name) {
-    const value = createSignal([]);
-    const childStoreData = this.childStoreDataMap.get(name) ?? {
-      computed: this.getComputedGetter(name),
-      listener: createListener(() => this.updateStores(name)),
-      value
-    };
-    this.childStoreDataMap.set(name, childStoreData);
-    const storeElement = childStoreData.listener.track(
-      () => childStoreData.computed.get()
-    );
-    this.setStoreList(name, storeElement);
+    Array.isArray(storeElement) ? this.setStoreList(name, storeElement) : this.setSingleStore(name, storeElement);
     return childStoreData.value.get();
   }
   getStore(name) {
@@ -1463,18 +1512,8 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
     if (!childStoreData) {
       return this.initializeStore(name);
     } else {
-      const storeElement = runInUntracked(() => childStoreData.computed.get());
-      this.setSingleStore(name, storeElement);
-      return childStoreData.value.get();
-    }
-  }
-  getStores(name) {
-    const childStoreData = this.childStoreDataMap.get(name);
-    if (!childStoreData) {
-      return this.initializeStores(name);
-    } else {
-      const storeElement = runInUntracked(() => childStoreData.computed.get());
-      this.setStoreList(name, storeElement);
+      const storeElement = untracked(() => childStoreData.computed.get());
+      Array.isArray(storeElement) ? this.setStoreList(name, storeElement) : this.setSingleStore(name, storeElement);
       return childStoreData.value.get();
     }
   }
@@ -1484,22 +1523,46 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
   isRoot() {
     return !this.parent;
   }
-  createReaction(track, callback) {
-    const unsub = createReaction(track, callback);
+  getContextValue(contextId, provideSymbol, defaultValue, hasDefault) {
+    let computed2 = this.contextCache.get(contextId);
+    if (!computed2) {
+      computed2 = createComputed(() => {
+        return this.lookupContextValue(
+          contextId,
+          provideSymbol,
+          defaultValue,
+          hasDefault
+        );
+      });
+      this.contextCache.set(contextId, computed2);
+    }
+    return computed2.get();
+  }
+  lookupContextValue(contextId, provideSymbol, defaultValue, hasDefault) {
+    const provideMethod = this.source[provideSymbol];
+    if (typeof provideMethod === "function") {
+      return provideMethod.call(this.proxy);
+    }
+    if (this.parent) {
+      return this.parent.getContextValue(
+        contextId,
+        provideSymbol,
+        defaultValue,
+        hasDefault
+      );
+    }
+    if (hasDefault) {
+      return defaultValue;
+    }
+    return void 0;
+  }
+  reaction(track, callback) {
+    const unsub = reaction(track, callback);
     this.reactionsUnsub.push(unsub);
     return unsub;
   }
   mount(parent = null) {
     this.parent = parent || null;
-    if (this.parent) {
-      const parentSource = this.parent.proxy;
-      this.computedContext = computedProxy(
-        createComputed(() => ({
-          ...parentSource.context,
-          ...parentSource.provideContext()
-        }))
-      );
-    }
     this.childStoreDataMap.forEach(({ value }) => {
       const stores = value.get();
       if (Array.isArray(stores)) {
@@ -1509,7 +1572,7 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
       }
     });
     this.mounted = true;
-    runInBatch(() => this.proxy.storeDidMount?.());
+    batch(() => this.proxy.storeDidMount?.());
   }
   unmount() {
     this.proxy.storeWillUnmount?.();
@@ -1526,52 +1589,12 @@ const _StoreAdministration = class _StoreAdministration extends PreactObjectAdmi
       listener.dispose();
     });
     this.childStoreDataMap.clear();
-    this.contextReactionUnsub?.();
+    this.contextCache.forEach((computed2) => computed2.clear());
+    this.contextCache.clear();
     this.reactionsUnsub.forEach((u) => u());
     this.parent = null;
   }
-};
-_StoreAdministration.proxyTraps = Object.assign(
-  {},
-  PreactObjectAdministration.proxyTraps,
-  {
-    get(target, name) {
-      if (name === "key") {
-        return target.key;
-      } else if (name === "context") {
-        return target.context;
-      }
-      const adm = getAdministration(target);
-      switch (adm.configuration[name]?.type) {
-        case CommonCfgTypes.child:
-          return adm.getStore(name);
-        case CommonCfgTypes.children:
-          return adm.getStores(name);
-        case StoreCfgTypes.model:
-          return adm.getModelRef(name);
-        default:
-          return PreactObjectAdministration.proxyTraps.get?.apply(
-            null,
-            arguments
-          );
-      }
-    },
-    set(target, name, value) {
-      const adm = getAdministration(target);
-      if (name === "props" || name === "context") {
-        throw new Error(`r-state-tree: ${name} is read-only`);
-      }
-      if (adm.configuration[name]?.type === StoreCfgTypes.model) {
-        throw new Error(`r-state-tree: model ${String(name)} is read-only`);
-      }
-      return PreactObjectAdministration.proxyTraps.set?.apply(
-        null,
-        arguments
-      );
-    }
-  }
-);
-let StoreAdministration = _StoreAdministration;
+}
 let initEnabled$1 = false;
 function allowNewStore(fn) {
   initEnabled$1 = true;
@@ -1592,18 +1615,23 @@ function updateStore(store, props) {
   updateProps(store.props, props);
   return store;
 }
-const _Store = class _Store {
+class Store {
+  static get types() {
+    return this[Symbol.metadata];
+  }
+  props;
   constructor(props) {
     if (!initEnabled$1) {
       throw new Error("r-state-tree: Can't initialize store directly");
     }
-    const config = this.constructor.types;
     const observable2 = createObservableWithCustomAdministration(
       this,
       StoreAdministration
     );
     const adm = getStoreAdm(observable2);
-    adm.setConfiguration(config ?? {});
+    adm.setConfiguration(
+      () => this.constructor.types ?? {}
+    );
     adm.write("props", getObservable({}));
     updateProps(observable2.props, props);
     return observable2;
@@ -1611,14 +1639,8 @@ const _Store = class _Store {
   get key() {
     return this.props.key;
   }
-  get context() {
-    return getStoreAdm(this).computedContext;
-  }
-  createReaction(track, callback) {
-    return getStoreAdm(this).createReaction(track, callback);
-  }
-  provideContext() {
-    return null;
+  reaction(track, callback) {
+    return getStoreAdm(this).reaction(track, callback);
   }
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   storeDidMount() {
@@ -1626,9 +1648,7 @@ const _Store = class _Store {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   storeWillUnmount() {
   }
-};
-_Store.types = {};
-let Store = _Store;
+}
 const attachedIdMap = /* @__PURE__ */ new WeakMap();
 const idMap = /* @__PURE__ */ new WeakMap();
 let loadingSnapshot = false;
@@ -1784,9 +1804,8 @@ function observe(obj, method) {
   return listener.subscribe(method);
 }
 class ObservableListener {
-  constructor() {
-    this.notifying = false;
-  }
+  listeners;
+  notifying = false;
   subscribe(l) {
     let unsubed = false;
     this.listeners = this.listeners || [];
@@ -1818,7 +1837,7 @@ class ObservableListener {
 }
 class ChildModelsAdministration extends ArrayAdministration {
   set(index, newValue) {
-    return runInBatch(() => {
+    return batch(() => {
       super.set(index, newValue);
       const sourceValue = getSource(newValue);
       if (this.source[index] !== sourceValue) {
@@ -1827,7 +1846,7 @@ class ChildModelsAdministration extends ArrayAdministration {
     });
   }
   spliceWithArray(index, deleteCount, newItems) {
-    return runInBatch(() => {
+    return batch(() => {
       const deleted = super.spliceWithArray(index, deleteCount, newItems);
       if (deleteCount || newItems?.length) {
         notifySpliceArray(this.proxy, index, newItems ?? [], deleted);
@@ -1871,19 +1890,108 @@ function getSnapshotRefId(snapshot) {
   }
   return snapshot[keys[0]];
 }
-const _ModelAdministration = class _ModelAdministration extends PreactObjectAdministration {
-  constructor() {
-    super(...arguments);
-    this.parent = null;
-    this.activeModels = /* @__PURE__ */ new Set();
-    this.root = this;
-    this.modelsTraceUnsub = /* @__PURE__ */ new Map();
-    this.writeInProgress = /* @__PURE__ */ new Set();
-    this.snapshotMap = /* @__PURE__ */ new Map();
-    this.parentName = null;
+class ModelAdministration extends PreactObjectAdministration {
+  static proxyTraps = Object.assign(
+    {},
+    PreactObjectAdministration.proxyTraps,
+    {
+      get(target, prop, proxy) {
+        const adm = getAdministration(target);
+        if (prop === "parent") {
+          return target.parent;
+        }
+        switch (adm.configuration[prop]?.type) {
+          case ModelCfgTypes.modelRef:
+            if (Array.isArray(adm.source[prop])) {
+              return adm.getModelRefs(prop);
+            }
+            return adm.getModelRef(prop);
+          default:
+            return PreactObjectAdministration.proxyTraps.get?.apply(
+              null,
+              arguments
+            );
+        }
+      },
+      set(target, name, value) {
+        const adm = getAdministration(target);
+        adm.writeInProgress.add(name);
+        try {
+          switch (adm.configuration[name]?.type) {
+            case ModelCfgTypes.modelRef: {
+              Array.isArray(value) ? adm.setModelRefs(name, value) : adm.setModelRef(name, value);
+              return true;
+            }
+            case CommonCfgTypes.child: {
+              if (Array.isArray(value)) {
+                adm.setModels(name, value);
+                return true;
+              } else {
+                adm.setModel(name, value ?? null);
+                break;
+              }
+            }
+            case ModelCfgTypes.id: {
+              adm.setId(name, value);
+              break;
+            }
+            case ModelCfgTypes.state: {
+              adm.setState(name, value);
+              break;
+            }
+          }
+          return PreactObjectAdministration.proxyTraps.set?.apply(
+            null,
+            arguments
+          );
+        } finally {
+          adm.writeInProgress.delete(name);
+        }
+      },
+      defineProperty(target, name, desc) {
+        const adm = getAdministration(target);
+        if (desc && "value" in desc && !adm.writeInProgress.has(name)) {
+          switch (adm.configuration[name]?.type) {
+            case ModelCfgTypes.modelRef:
+            case CommonCfgTypes.child:
+            case ModelCfgTypes.id: {
+              adm.proxy[name] = desc.value;
+              return true;
+            }
+          }
+        }
+        return Reflect.defineProperty(target, name, desc);
+      }
+    }
+  );
+  configurationGetter;
+  _parent = null;
+  parentAtom = createAtom();
+  referencedAtoms;
+  referencedModels;
+  activeModels = /* @__PURE__ */ new Set();
+  root = this;
+  modelsTraceUnsub = /* @__PURE__ */ new Map();
+  writeInProgress = /* @__PURE__ */ new Set();
+  computedSnapshot;
+  snapshotMap = /* @__PURE__ */ new Map();
+  contextCache = /* @__PURE__ */ new Map();
+  parentName = null;
+  get parent() {
+    this.parentAtom.reportObserved();
+    return this._parent;
+  }
+  set parent(value) {
+    if (this._parent !== value) {
+      this._parent = value;
+      this.parentAtom.reportChanged();
+    }
   }
-  setConfiguration(configuration) {
-    this.configuration = configuration;
+  setConfiguration(configurationGetter) {
+    this.configurationGetter = configurationGetter;
+  }
+  get configuration() {
+    return this.configurationGetter?.() ?? {};
   }
   getReferencedAtom(name) {
     let a = this.referencedAtoms?.get(name);
@@ -1921,13 +2029,18 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
     }
   }
   setModel(name, newModel) {
-    const oldModel = this.getModel(name);
-    if (oldModel === newModel) {
+    const currentValue = this.proxy[name];
+    if (currentValue === newModel) {
       return;
     }
     this.activeModels.add(name);
-    if (oldModel) {
-      getModelAdm(oldModel).detach();
+    if (Array.isArray(currentValue)) {
+      const oldModels = currentValue;
+      oldModels.forEach((child2) => getModelAdm(child2).detach());
+      this.modelsTraceUnsub.get(name)?.();
+      this.modelsTraceUnsub.delete(name);
+    } else if (currentValue) {
+      getModelAdm(currentValue).detach();
     }
     if (newModel) {
       const adm = getModelAdm(newModel);
@@ -1940,17 +2053,21 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
       ChildModelsAdministration
     );
     newModels.push(...newModelsSource);
-    const oldModels = this.getModels(name) ?? [];
-    if (oldModels === newModels) {
+    const currentValue = this.proxy[name];
+    if (currentValue === newModels) {
       return;
     }
-    const oldModelSet = new Set(oldModels);
-    const newModelSet = new Set(newModels);
     this.activeModels.add(name);
-    oldModels.forEach(
-      (child2) => newModelSet.has(child2) || getModelAdm(child2).detach()
-    );
-    this.modelsTraceUnsub.get(name)?.();
+    if (currentValue && !Array.isArray(currentValue)) {
+      getModelAdm(currentValue).detach();
+    } else if (Array.isArray(currentValue)) {
+      const oldModels = currentValue;
+      const newModelSet = new Set(newModels);
+      oldModels.forEach(
+        (child2) => newModelSet.has(child2) || getModelAdm(child2).detach()
+      );
+      this.modelsTraceUnsub.get(name)?.();
+    }
     PreactObjectAdministration.proxyTraps.set(
       this.source,
       name,
@@ -1970,20 +2087,13 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
       })
     );
     newModels.forEach((child2) => {
+      const oldModelSet = Array.isArray(currentValue) ? new Set(currentValue) : /* @__PURE__ */ new Set();
       if (!oldModelSet.has(child2)) {
         const internalModel = getModelAdm(child2);
         internalModel.attach(this, name);
       }
     });
   }
-  getModel(name) {
-    const model2 = this.proxy[name];
-    return model2 ?? null;
-  }
-  getModels(name) {
-    const model2 = this.proxy[name];
-    return model2 ?? [];
-  }
   getModelRef(name) {
     const a = this.getReferencedAtom(name);
     a.reportObserved();
@@ -2040,19 +2150,55 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
       this.root = parent.root;
       this.parentName = parentName;
     }
-    runInBatch(() => {
+    batch(() => {
       onModelAttached(this.proxy);
       this.proxy.modelDidAttach();
     });
   }
   detach() {
-    runInBatch(() => {
+    batch(() => {
       this.proxy.modelWillDetach();
       onModelDetached(this.proxy);
     });
+    this.contextCache.forEach((computed2) => computed2.clear());
+    this.contextCache.clear();
     this.parent = null;
     this.root = this;
   }
+  getContextValue(contextId, provideSymbol, defaultValue, hasDefault) {
+    let computed2 = this.contextCache.get(contextId);
+    if (!computed2) {
+      computed2 = createComputed(() => {
+        return this.lookupContextValue(
+          contextId,
+          provideSymbol,
+          defaultValue,
+          hasDefault
+        );
+      });
+      this.contextCache.set(contextId, computed2);
+    }
+    return computed2.get();
+  }
+  lookupContextValue(contextId, provideSymbol, defaultValue, hasDefault) {
+    const provideMethod = this.source[provideSymbol];
+    if (typeof provideMethod === "function") {
+      return provideMethod.call(this.proxy);
+    }
+    const parent = this.parent;
+    if (parent) {
+      return parent.getContextValue(
+        contextId,
+        provideSymbol,
+        defaultValue,
+        hasDefault
+      );
+    }
+    if (hasDefault) {
+      return defaultValue;
+    }
+    return void 0;
+  }
   toJSON() {
     return Object.keys(this.configuration).reduce((json, key) => {
       switch (this.configuration[key].type) {
@@ -2062,44 +2208,47 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
           break;
         case ModelCfgTypes.modelRef:
           const model2 = this.proxy[key];
-          json[key] = model2 && getModelRefSnapshot(model2);
-          break;
-        case ModelCfgTypes.modelRefs:
-          if (!this.snapshotMap.has(key)) {
-            this.snapshotMap.set(
-              key,
-              createComputed(() => {
-                const models = this.proxy[key] ?? [];
-                return models.map((m) => getModelRefSnapshot(m));
-              })
-            );
+          if (Array.isArray(model2)) {
+            if (!this.snapshotMap.has(key)) {
+              this.snapshotMap.set(
+                key,
+                createComputed(() => {
+                  const models = this.proxy[key] ?? [];
+                  return models.map((m) => getModelRefSnapshot(m));
+                })
+              );
+            }
+            json[key] = this.snapshotMap.get(key).get();
+            break;
           }
-          json[key] = this.snapshotMap.get(key).get();
+          json[key] = model2 && getModelRefSnapshot(model2);
           break;
         case CommonCfgTypes.child:
-          json[key] = getModelAdm(this.proxy[key])?.getSnapshot();
-          break;
-        case CommonCfgTypes.children:
-          if (!this.snapshotMap.has(key)) {
-            this.snapshotMap.set(
-              key,
-              createComputed(() => {
-                return getSource(
-                  (this.proxy[key] ?? []).map(
-                    (model22) => getModelAdm(model22).getSnapshot()
-                  )
-                );
-              })
-            );
+          const child2 = this.proxy[key];
+          if (Array.isArray(child2)) {
+            if (!this.snapshotMap.has(key)) {
+              this.snapshotMap.set(
+                key,
+                createComputed(() => {
+                  return getSource(
+                    (this.proxy[key] ?? []).map(
+                      (model22) => getModelAdm(model22).getSnapshot()
+                    )
+                  );
+                })
+              );
+            }
+            json[key] = this.snapshotMap.get(key).get();
+            break;
           }
-          json[key] = this.snapshotMap.get(key).get();
+          json[key] = getModelAdm(child2)?.getSnapshot();
           break;
       }
       return json;
     }, {});
   }
   onSnapshotChange(onChange) {
-    return createReaction(
+    return reaction(
       () => this.getSnapshot(),
       (snapshot) => onChange(snapshot, this.proxy)
     );
@@ -2122,29 +2271,53 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
             this.proxy[key] = value;
             break;
           case ModelCfgTypes.modelRef:
-            if (value instanceof Model) {
+            if (Array.isArray(value)) {
+              if (value?.[0] instanceof Model) {
+                this.proxy[key] = value;
+              } else {
+                this.source[key] = value.map(
+                  (snapshot2) => getSnapshotRefId(snapshot2)
+                );
+                this.referencedAtoms?.get(key)?.reportChanged();
+              }
+              break;
+            } else if (value instanceof Model) {
               this.proxy[key] = value;
             } else {
               this.source[key] = getSnapshotRefId(value);
               this.referencedAtoms?.get(key)?.reportChanged();
             }
             break;
-          case ModelCfgTypes.modelRefs:
-            if (value?.[0] instanceof Model) {
-              this.proxy[key] = value;
-            } else {
-              this.source[key] = value.map(
-                (snapshot2) => getSnapshotRefId(snapshot2)
-              );
-              this.referencedAtoms?.get(key)?.reportChanged();
-            }
-            break;
           case ModelCfgTypes.id:
             this.setId(key, value);
             break;
           case CommonCfgTypes.child:
             let model2;
-            if (value instanceof Model) {
+            if (Array.isArray(value)) {
+              const Ctor = childType2;
+              this.proxy[key] = value?.map(
+                (snapshot2, index) => {
+                  snapshot2 = snapshot2 ?? {};
+                  let model22;
+                  if (snapshot2 instanceof Model) {
+                    model22 = snapshot2;
+                  } else {
+                    ensureChildTypes(key);
+                    const id = childType2 && getSnapshotId(snapshot2, Ctor);
+                    const foundModel = id != null ? getModelById(this.root.proxy, id) : this.proxy[key][index];
+                    const adm = foundModel && getModelAdm(foundModel);
+                    if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
+                      adm.loadSnapshot(snapshot2);
+                      model22 = foundModel;
+                    } else {
+                      model22 = Ctor.create(snapshot2);
+                    }
+                  }
+                  return model22;
+                }
+              );
+              break;
+            } else if (value instanceof Model) {
               model2 = value;
             } else {
               ensureChildTypes(key);
@@ -2159,28 +2332,6 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
             }
             this.proxy[key] = model2;
             break;
-          case CommonCfgTypes.children:
-            const Ctor = childType2;
-            this.proxy[key] = value?.map((snapshot2, index) => {
-              snapshot2 = snapshot2 ?? {};
-              let model22;
-              if (snapshot2 instanceof Model) {
-                model22 = snapshot2;
-              } else {
-                ensureChildTypes(key);
-                const id = childType2 && getSnapshotId(snapshot2, Ctor);
-                const foundModel = id != null ? getModelById(this.root.proxy, id) : this.proxy[key][index];
-                const adm = foundModel && getModelAdm(foundModel);
-                if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
-                  adm.loadSnapshot(snapshot2);
-                  model22 = foundModel;
-                } else {
-                  model22 = Ctor.create(snapshot2);
-                }
-              }
-              return model22;
-            });
-            break;
           default:
             console.warn(
               `r-state-tree: invalid key '${key}' found in snapshot, ignored.`
@@ -2199,87 +2350,13 @@ const _ModelAdministration = class _ModelAdministration extends PreactObjectAdmi
     }
     return this.computedSnapshot.get();
   }
-};
-_ModelAdministration.proxyTraps = Object.assign(
-  {},
-  PreactObjectAdministration.proxyTraps,
-  {
-    get(target, prop, proxy) {
-      const adm = getAdministration(target);
-      if (prop === "parent") {
-        return target.parent;
-      }
-      switch (adm.configuration[prop]?.type) {
-        case ModelCfgTypes.modelRef:
-          return adm.getModelRef(prop);
-        case ModelCfgTypes.modelRefs:
-          return adm.getModelRefs(prop);
-        default:
-          return PreactObjectAdministration.proxyTraps.get?.apply(
-            null,
-            arguments
-          );
-      }
-    },
-    set(target, name, value) {
-      const adm = getAdministration(target);
-      adm.writeInProgress.add(name);
-      try {
-        switch (adm.configuration[name]?.type) {
-          case ModelCfgTypes.modelRef: {
-            adm.setModelRef(name, value);
-            return true;
-          }
-          case ModelCfgTypes.modelRefs: {
-            adm.setModelRefs(name, value);
-            return true;
-          }
-          case CommonCfgTypes.children: {
-            adm.setModels(name, value);
-            return true;
-          }
-          case CommonCfgTypes.child: {
-            adm.setModel(name, value);
-            break;
-          }
-          case ModelCfgTypes.id: {
-            adm.setId(name, value);
-            break;
-          }
-          case ModelCfgTypes.state: {
-            adm.setState(name, value);
-            break;
-          }
-        }
-        return PreactObjectAdministration.proxyTraps.set?.apply(
-          null,
-          arguments
-        );
-      } finally {
-        adm.writeInProgress.delete(name);
-      }
-    },
-    defineProperty(target, name, desc) {
-      const adm = getAdministration(target);
-      if (desc && "value" in desc && !adm.writeInProgress.has(name)) {
-        switch (adm.configuration[name]?.type) {
-          case ModelCfgTypes.modelRef:
-          case ModelCfgTypes.modelRefs:
-          case CommonCfgTypes.children:
-          case CommonCfgTypes.child:
-          case ModelCfgTypes.id: {
-            adm.proxy[name] = desc.value;
-            return true;
-          }
-        }
-      }
-      return Reflect.defineProperty(target, name, desc);
-    }
-  }
-);
-let ModelAdministration = _ModelAdministration;
+}
 let initEnabled = false;
-const _Model = class _Model {
+class Model {
+  static get types() {
+    return this[Symbol.metadata];
+  }
+  static childTypes = {};
   static create(snapshot, ...args) {
     let instance;
     try {
@@ -2304,8 +2381,9 @@ const _Model = class _Model {
       ModelAdministration
     );
     const adm = getModelAdm(observable2);
-    const config = this.constructor.types;
-    adm.setConfiguration(config ?? {});
+    adm.setConfiguration(
+      () => this.constructor.types ?? {}
+    );
     return observable2;
   }
   get parent() {
@@ -2320,10 +2398,7 @@ const _Model = class _Model {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   modelWillDetach() {
   }
-};
-_Model.types = {};
-_Model.childTypes = {};
-let Model = _Model;
+}
 function mount(container) {
   return allowNewStore(() => {
     const element = container;
@@ -2361,59 +2436,84 @@ function applySnapshot(model2, snapshot) {
   adm.loadSnapshot(snapshot);
   return model2;
 }
-function makeDecorator(type, asMethod = (val) => makeDecorator(type(val))) {
-  return function(...args) {
-    if (args.length === 1) {
-      return asMethod(args[0]);
-    } else {
-      const [target, propertyKey, descriptor] = args;
-      const Ctor = target.constructor;
-      if (Ctor.types === Store.types || Ctor.types === Model.types) {
-        Ctor.types = {};
+const CONTEXT_SYMBOL = Symbol("context");
+const HAS_DEFAULT = Symbol("hasDefault");
+function createContext(defaultValue) {
+  const provideSymbol = Symbol("provide");
+  const contextId = Symbol("contextId");
+  const hasDefault = arguments.length > 0;
+  return {
+    [CONTEXT_SYMBOL]: contextId,
+    [HAS_DEFAULT]: hasDefault,
+    defaultValue,
+    provide: provideSymbol,
+    consume(instance) {
+      const adm = getAdministration(instance);
+      if (!adm || typeof adm.getContextValue !== "function") {
+        throw new Error("Context can only be consumed in Models or Stores");
       }
-      Ctor.types[propertyKey] = type;
-      return descriptor;
+      return adm.getContextValue(
+        contextId,
+        provideSymbol,
+        defaultValue,
+        hasDefault
+      );
     }
   };
 }
-const child = makeDecorator(childType);
-const children = makeDecorator(childrenType);
+function makeDecorator(type) {
+  return function(value, context) {
+    context.metadata[context.name] = type;
+    return value;
+  };
+}
+function makeChildDecorator(typeObj) {
+  return function(valueOrChildType, context) {
+    if (context !== void 0) {
+      return makeDecorator(typeObj)(valueOrChildType, context);
+    }
+    const childCtor = valueOrChildType;
+    return function(value, context2) {
+      const typeWithCtor = typeObj(childCtor);
+      return makeDecorator(typeWithCtor)(value, context2);
+    };
+  };
+}
+const child = makeChildDecorator(childType);
+const modelRef = makeChildDecorator(modelRefType);
 const model = makeDecorator(modelType);
-const modelRef = makeDecorator(modelRefType);
-const modelRefs = makeDecorator(modelRefsType);
 const identifier = makeDecorator(idType);
 const state = makeDecorator(stateType);
 export {
   Model,
   Observable,
+  ReadonlySignal,
+  Signal2 as Signal,
   Store,
   applySnapshot,
+  batch2 as batch,
   child,
-  children,
-  createAtom,
-  createComputed,
-  createEffect,
-  createListener,
-  createReaction,
-  createSignal,
+  computed,
+  createContext,
   createStore,
+  effect2 as effect,
   getSignal,
   identifier,
   isObservable,
   model,
   modelRef,
-  modelRefs,
   mount,
   observable,
   onSnapshot,
   onSnapshotDiff,
+  reaction,
   reportChanged,
   reportObserved,
-  runInBatch,
-  runInUntracked,
+  signal2 as signal,
   source,
   state,
   toSnapshot,
   unmount,
+  untracked2 as untracked,
   updateStore
 };