@rs-x/state-manager 0.4.11 → 0.4.12

package/dist/index.js

@@ -2,8 +2,8 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // lib/abstract-observer.ts
-import { Type } from "@rs-x/core";
 import { Subject } from "rxjs";
+import { Type } from "@rs-x/core";
 var AbstractObserver = class {
   static {
     __name(this, "AbstractObserver");
@@ -73,6 +73,9 @@ var GroupedChangeSubscriptionsForContextManager = class extends SingletonFactory
   constructor(_context, releaseContext, _errorLog, guidFactory) {
     super(guidFactory), this._context = _context, this.releaseContext = releaseContext, this._errorLog = _errorLog;
   }
+  get context() {
+    return this._context;
+  }
   getSubsriptionData(id) {
     return this._subscriptions.get(id)?.data;
   }
@@ -107,12 +110,30 @@ var GroupedChangeSubscriptionsForContextManager = class extends SingletonFactory
   }
 };
 
-// lib/object-observer/factories/abstract-object-observer-proxy-pair.factory.ts
+// lib/index-watch-rule-registry/index-watch-rule.ts
 import { truePredicate } from "@rs-x/core";
+var IndexWatchRule = class {
+  static {
+    __name(this, "IndexWatchRule");
+  }
+  context;
+  predicate;
+  constructor(context, predicate) {
+    this.context = context;
+    this.predicate = predicate;
+  }
+  test(index, target) {
+    return this.predicate(index, target, this.context);
+  }
+};
+var watchIndexRecursiveRule = new IndexWatchRule(void 0, truePredicate);
+
+// lib/object-observer/factories/abstract-object-observer-proxy-pair.factory.ts
+import { truePredicate as truePredicate2 } from "@rs-x/core";
 
 // lib/observer-group.ts
-import { Type as Type2 } from "@rs-x/core";
 import { ReplaySubject } from "rxjs";
+import { Type as Type2 } from "@rs-x/core";
 var ObserverGroup = class _ObserverGroup extends AbstractObserver {
   static {
     __name(this, "ObserverGroup");
@@ -184,11 +205,11 @@ var ObserverGroup = class _ObserverGroup extends AbstractObserver {
       target: this.target,
       chain: [
         {
-          object: this.target,
-          id: this.id
+          context: this.target,
+          index: this.id
         }
       ],
-      id: this.id,
+      index: this.id,
       newValue
     });
   }
@@ -215,8 +236,8 @@ var ObserverGroup = class _ObserverGroup extends AbstractObserver {
     const isThisTarget = change.target === this.target;
     const chain = isThisTarget || Type2.isNullOrUndefined(this.id) ? change.chain : [
       {
-        object: this.target,
-        id: this.id
+        context: this.target,
+        index: this.id
       },
       ...change.chain ?? []
     ];
@@ -252,8 +273,8 @@ var AbstractObjectObserverProxyPairFactory = class {
     this._objectPropertyObserverProxyPairManager = _objectPropertyObserverProxyPairManager;
   }
   create(owner, data) {
-    const observerGroup = new ObserverGroup(this.createDisposableOwner(owner, data), data.target, data.target, truePredicate, this._errorLog, void 0, () => rootObserver?.observer, this._observerRootObserver);
-    this.onObserverGroupCreate(data.target, observerGroup, data.mustProxify);
+    const observerGroup = new ObserverGroup(this.createDisposableOwner(owner, data), data.target, data.target, truePredicate2, this._errorLog, void 0, () => rootObserver?.observer, this._observerRootObserver);
+    this.onObserverGroupCreate(data.target, observerGroup, data.indexWatchRule);
     const rootObserver = this.createRootObserver(data);
     if (!data.initializeManually) {
       observerGroup.init();
@@ -267,19 +288,19 @@ var AbstractObjectObserverProxyPairFactory = class {
   createDisposableOwner(owner, _data) {
     return owner;
   }
-  onObserverGroupCreate(target, observerGroup, mustProxify) {
-    if (!mustProxify) {
+  onObserverGroupCreate(target, observerGroup, indexWatchRule) {
+    if (!indexWatchRule) {
       return;
     }
     const observers = [];
     const indexes = this._indexAccessor.getIndexes(target);
     for (const index of indexes) {
-      if (!mustProxify(index, target)) {
+      if (!indexWatchRule.test(index, target)) {
         continue;
       }
       const { observer } = this._objectPropertyObserverProxyPairManager.create(target).instance.create({
-        key: index,
-        mustProxify
+        index,
+        indexWatchRule
       }).instance;
       observers.push(observer);
     }
@@ -290,7 +311,7 @@ var AbstractObjectObserverProxyPairFactory = class {
 // lib/object-observer/factories/array-observer-proxy-pair.factory.ts
 import { Inject, Injectable, RsXCoreInjectionTokens } from "@rs-x/core";
 
-// lib/rs-x-state-manager-injection-tokes.ts
+// lib/rs-x-state-manager-injection-tokens.ts
 var RsXStateManagerInjectionTokens = {
   IArrayProxyFactory: Symbol("IArrayProxyFactory"),
   IMapProxyFactory: Symbol("IMapProxyFactory"),
@@ -318,7 +339,6 @@ var RsXStateManagerInjectionTokens = {
   IPropertyObserverProxyPairFactoryList: Symbol("IPropertyObserverProxyPairFactoryList"),
   NonIterableObjectPropertyObserverProxyPairFactory: Symbol("NonIterableObjectPropertyObserverProxyPairFactory"),
   ICollectionItemObserverProxyPairFactory: Symbol("ICollectionItemObserverProxyPairFactory"),
-  IMustProxifyItemHandlerFactory: Symbol("IMustProxifyItemHandlerFactory"),
   IObjectStateManager: Symbol("IObjectStateManager"),
   IPropertyObserverProxyPairFactoryProvider: Symbol("IPropertyObserverProxyPairFactoryProvider"),
   IPropertyObserverProxyPairFactoryProviderFactory: Symbol("IPropertyObserverProxyPairFactoryProviderFactory"),
@@ -475,8 +495,8 @@ MapObserverProxyPairFactory = _ts_decorate3([
 ], MapObserverProxyPairFactory);
 
 // lib/object-observer/factories/observable-observer-proxy-pair.factory.ts
-import { Inject as Inject4, Injectable as Injectable4 } from "@rs-x/core";
 import { isObservable } from "rxjs";
+import { Inject as Inject4, Injectable as Injectable4 } from "@rs-x/core";
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -523,7 +543,7 @@ ObservableObserverProxyPairFactory = _ts_decorate4([
 ], ObservableObserverProxyPairFactory);
 
 // lib/object-observer/factories/plain-object-observer-proxy-pair.factory.ts
-import { Inject as Inject5, Injectable as Injectable5, RsXCoreInjectionTokens as RsXCoreInjectionTokens3, truePredicate as truePredicate2, Type as Type3 } from "@rs-x/core";
+import { Inject as Inject5, Injectable as Injectable5, RsXCoreInjectionTokens as RsXCoreInjectionTokens3, truePredicate as truePredicate3, Type as Type3 } from "@rs-x/core";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -552,21 +572,24 @@ var PlainObjectObserverProxyPairFactory = class extends AbstractObjectObserverPr
     return Type3.isPlainObject(object);
   }
   createRootObserver(data) {
-    if (data.mustProxify) {
+    if (!data.indexWatchRule) {
       return void 0;
     }
     const target = data.target;
     const observers = [];
     for (const index of this._indexAccessor.getIndexes(target)) {
+      if (!data.indexWatchRule.test(index, target)) {
+        continue;
+      }
       const { observer } = this._objectPropertyObserverProxyPairManager.create(target).instance.create({
-        key: index
+        index
       }).instance;
       observers.push(observer);
     }
     if (observers.length === 0) {
       return void 0;
     }
-    const observerGroup = new ObserverGroup(void 0, data.target, data.target, truePredicate2, this._errorLog);
+    const observerGroup = new ObserverGroup(void 0, data.target, data.target, truePredicate3, this._errorLog);
     observerGroup.replaceObservers(observers);
     return {
       observer: observerGroup
@@ -755,7 +778,7 @@ var ObjectObserverProxyPairManager = class extends SingletonFactoryWithGuid2 {
     return data.target;
   }
   getGroupMemberId(data) {
-    return data.mustProxify;
+    return data.indexWatchRule;
   }
   create(data) {
     if (this._proxyRegistry.isProxy(data.target)) {
@@ -817,10 +840,10 @@ var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 e
     super(guidFactory), this._object = _object, this._observerFactories = _observerFactories, this.releaseContext = releaseContext;
   }
   getGroupId(data) {
-    return data.key;
+    return data.index;
   }
   getGroupMemberId(data) {
-    return data.mustProxify;
+    return data.indexWatchRule;
   }
   createInstance(propertyInfo, id) {
     return this.getObserverFactory(propertyInfo).create({
@@ -840,7 +863,7 @@ var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 e
   getObserverFactory(propertyInfo) {
     const observerFactory = this._observerFactories.find((observerFactory2) => observerFactory2.applies(this._object, propertyInfo));
     if (!observerFactory) {
-      throw new UnsupportedException(`No observer factory found for given object of type ${Type5.getConstructorName(this._object)} for given id ${propertyInfo.key}`);
+      throw new UnsupportedException(`No observer factory found for given object of type ${Type5.getConstructorName(this._object)} for given id ${propertyInfo.index}`);
     }
     return observerFactory;
   }
@@ -924,7 +947,7 @@ var CollectionIndexObserver = class CollectionIndexObserver2 extends AbstractObs
     this._collectionObserver.dispose();
   }
   onChanged = /* @__PURE__ */ __name((change) => {
-    if (change.id !== this.id) {
+    if (change.index !== this.id) {
       return;
     }
     if (!this._indexValueAccessor.hasValue(this.target, this.id)) {
@@ -1013,7 +1036,7 @@ CollectionItemObserverManager = _ts_decorate11([
 import { Inject as Inject11, Injectable as Injectable12, RsXCoreInjectionTokens as RsXCoreInjectionTokens8, truePredicate as truePredicate4 } from "@rs-x/core";
 
 // lib/property-observer/factories/indexed-value-observer-proxy-pair/indexed-value-observer-proxy-pair.factory.ts
-import { truePredicate as truePredicate3, Type as Type6, UnexpectedException } from "@rs-x/core";
+import { Type as Type6, UnexpectedException } from "@rs-x/core";
 
 // lib/property-observer/factories/indexed-value-observer-proxy-pair/index-change-subscription-manager.ts
 import { SingletonFactory as SingletonFactory3 } from "@rs-x/core";
@@ -1029,7 +1052,7 @@ var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsFo
     return data.index;
   }
   getGroupMemberId(data) {
-    return data.mustProxify;
+    return data.indexWatchRule;
   }
   createObserver(context, data, id) {
     const indexSetObserver = this._indexSetObserverManager.create(context).instance.create({
@@ -1049,7 +1072,7 @@ var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsFo
         data.owner.release();
         this.release(id);
       }, "release")
-    }, this._context, data.initialValue, data.mustHandleChange, this._errorLog, data.index, () => indexSetObserver).addObservers(data.indexValueObserver ? [
+    }, this.context, data.initialValue, data.mustHandleChange, this._errorLog, data.index, () => indexSetObserver).addObservers(data.indexValueObserver ? [
       data.indexValueObserver
     ] : []);
     if (!data.initializeManually) {
@@ -1091,12 +1114,14 @@ var IndexObserverProxyPairFactory = class {
   _objectObserveryManager;
   _indexValueAccessor;
   _proxyRegister;
+  _valueMetadata;
   mustHandleChange;
   _indexChangeSubscriptionManager;
-  constructor(_objectObserveryManager, indexSetObserverManager, errorLog, guidFactory, _indexValueAccessor, _proxyRegister, mustHandleChange) {
+  constructor(_objectObserveryManager, indexSetObserverManager, errorLog, guidFactory, _indexValueAccessor, _proxyRegister, _valueMetadata, mustHandleChange) {
     this._objectObserveryManager = _objectObserveryManager;
     this._indexValueAccessor = _indexValueAccessor;
     this._proxyRegister = _proxyRegister;
+    this._valueMetadata = _valueMetadata;
     this.mustHandleChange = mustHandleChange;
     this._indexChangeSubscriptionManager = new IndexChangeSubscriptionManager(indexSetObserverManager, errorLog, guidFactory);
   }
@@ -1104,45 +1129,39 @@ var IndexObserverProxyPairFactory = class {
     this._indexChangeSubscriptionManager.dispose();
   }
   create(owner, object, propertyInfo) {
-    const index = propertyInfo.key;
+    const index = propertyInfo.index;
     const valueAtIndex = this._indexValueAccessor.getValue(object, index);
-    const mustProxify = this.getMustProxifyHandler(propertyInfo.mustProxify, object, index);
-    const indexValueObserverProxyPair = mustProxify ? this.createIndexValueProxy(propertyInfo, object, index, valueAtIndex, mustProxify) : void 0;
+    const needProxy = this._valueMetadata.isAsync(valueAtIndex) || propertyInfo.indexWatchRule?.test?.(index, object);
+    const indexValueObserverProxyPair = needProxy ? this.createIndexValueProxy(propertyInfo, object, index, valueAtIndex, propertyInfo.indexWatchRule) : void 0;
     const initialValue = indexValueObserverProxyPair ? indexValueObserverProxyPair.observer.value : valueAtIndex;
-    ;
-    const groupObserver = this.createGroupObserver(owner, object, index, initialValue, propertyInfo.initializeManually, indexValueObserverProxyPair?.observer, mustProxify);
+    const groupObserver = this.createGroupObserver(owner, object, index, initialValue, propertyInfo.initializeManually, indexValueObserverProxyPair?.observer, propertyInfo.indexWatchRule);
     return {
       observer: groupObserver,
       proxy: indexValueObserverProxyPair?.proxy,
       proxyTarget: valueAtIndex
     };
   }
-  getMustProxifyHandler(mustProxify, context, index) {
-    if (mustProxify) {
-      return mustProxify;
-    }
-    return this._indexValueAccessor.isAsync(context, index) ? truePredicate3 : void 0;
-  }
-  createIndexValueProxy(propertyInfo, object, index, value, mustProxify) {
+  createIndexValueProxy(propertyInfo, object, index, value, indexWatchRule) {
     const setValue = propertyInfo.setValue ?? ((v) => this._indexValueAccessor.setValue(object, index, v));
-    return this.proxifyIndexValue(value, mustProxify, propertyInfo.initializeManually, setValue);
+    return this.proxifyIndexValue(value, indexWatchRule, propertyInfo.initializeManually, setValue);
   }
-  createGroupObserver(owner, object, index, initialValue, initializeManually, indexValueObserver, mustProxify) {
+  createGroupObserver(owner, object, index, initialValue, initializeManually, indexValueObserver, indexWatchRule) {
     const indexChangeSubscriptionsForContextManager = this._indexChangeSubscriptionManager.create(object).instance;
     const { id } = indexChangeSubscriptionsForContextManager.create({
       index,
       initialValue,
       indexValueObserver,
-      mustProxify,
+      indexWatchRule,
       initializeManually,
       mustHandleChange: this.mustHandleChange,
-      onChanged: /* @__PURE__ */ __name((change) => this.onIndexSet(change, id, mustProxify), "onChanged"),
+      onChanged: /* @__PURE__ */ __name((change) => this.onIndexSet(change, id, indexWatchRule), "onChanged"),
       owner
     });
     return Type6.cast(indexChangeSubscriptionsForContextManager.getSubsriptionData(id));
   }
-  onIndexSet(change, subsriptionId, mustProxify) {
-    const emitValue = Type6.isNullOrUndefined(change.newValue) || !this._indexValueAccessor.isAsync(change.target, change.id);
+  onIndexSet(change, subsriptionId, indexWatchRule) {
+    const isAsync = this._valueMetadata.isAsync(change.newValue);
+    const emitValue = Type6.isNullOrUndefined(change.newValue) || !isAsync;
     const observerGroup = this._indexChangeSubscriptionManager.getFromId(change.target)?.getSubsriptionData(subsriptionId);
     if (!observerGroup) {
       throw new UnexpectedException(`Observer group not found for subscription id ${subsriptionId}`);
@@ -1150,17 +1169,16 @@ var IndexObserverProxyPairFactory = class {
     if (emitValue) {
       observerGroup.emitValue(change.newValue);
     }
-    const observers = this.getNestedObservers(change, mustProxify);
+    const observers = this.getNestedObservers(change, isAsync, indexWatchRule);
     observerGroup.replaceObservers(observers);
   }
-  getNestedObservers(change, mustProxify) {
-    const mustProxifyHandler = this.getMustProxifyHandler(mustProxify, change.target, change.id);
+  getNestedObservers(change, isAsync, indexWatchRule) {
     let observers = [];
-    if (mustProxifyHandler) {
-      const observerProxyPair = this.proxifyIndexValue(change.newValue, mustProxifyHandler, true, change.setValue ?? ((value) => {
+    if (isAsync || indexWatchRule && indexWatchRule.test(change.index, change.target)) {
+      const observerProxyPair = this.proxifyIndexValue(change.newValue, indexWatchRule, true, change.setValue ?? ((value) => {
         const obj = Type6.toObject(change.target);
         if (obj) {
-          obj[change.id] = value;
+          obj[change.index] = value;
         }
       }));
       if (observerProxyPair) {
@@ -1169,11 +1187,11 @@ var IndexObserverProxyPairFactory = class {
     }
     return observers;
   }
-  proxifyIndexValue(value, mustProxify, initializeManually, setValue) {
+  proxifyIndexValue(value, indexWatchRule, initializeManually, setValue) {
     const target = this._proxyRegister.getProxyTarget(value) ?? value;
     const observerProxyPair = this._objectObserveryManager.create({
       target,
-      mustProxify,
+      indexWatchRule,
       initializeManually
     }).instance;
     if (!observerProxyPair) {
@@ -1208,8 +1226,8 @@ var CollectionItemObserverProxyPairFactory = class extends IndexObserverProxyPai
   static {
     __name(this, "CollectionItemObserverProxyPairFactory");
   }
-  constructor(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister) {
-    super(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, truePredicate4);
+  constructor(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata) {
+    super(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata, truePredicate4);
   }
   applies(object) {
     return object instanceof Map || object instanceof Array || object instanceof Set;
@@ -1223,6 +1241,7 @@ CollectionItemObserverProxyPairFactory = _ts_decorate12([
   _ts_param12(3, Inject11(RsXCoreInjectionTokens8.IGuidFactory)),
   _ts_param12(4, Inject11(RsXCoreInjectionTokens8.IIndexValueAccessor)),
   _ts_param12(5, Inject11(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param12(6, Inject11(RsXCoreInjectionTokens8.IValueMetadata)),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
     typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
@@ -1230,7 +1249,8 @@ CollectionItemObserverProxyPairFactory = _ts_decorate12([
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
-    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
+    typeof IValueMetadata === "undefined" ? Object : IValueMetadata
   ])
 ], CollectionItemObserverProxyPairFactory);
 
@@ -1253,9 +1273,9 @@ function _ts_param13(paramIndex, decorator) {
   };
 }
 __name(_ts_param13, "_ts_param");
-var DatePropertybserver = class DatePropertybserver2 extends AbstractObserver {
+var DatePropertyObserver = class DatePropertyObserver2 extends AbstractObserver {
   static {
-    __name(this, "DatePropertybserver");
+    __name(this, "DatePropertyObserver");
   }
   _dateObserver;
   _errorLog;
@@ -1279,7 +1299,7 @@ var DatePropertybserver = class DatePropertybserver2 extends AbstractObserver {
     this._dateChangeSubscription.unsubscribe();
   }
   onDateChanged = /* @__PURE__ */ __name((change) => {
-    if (change.id !== this.id || change.newValue === this._oldValue) {
+    if (change.index !== this.id || change.newValue === this._oldValue) {
       return;
     }
     this.emitChange(change);
@@ -1294,10 +1314,9 @@ var ProperForDataObserverManager = class ProperForDataObserverManager2 extends S
   _dateProxyFactory;
   _datePropertyAccessor;
   _errorLog;
-  _mustProxifyItemHandlerFactory;
   releaseObject;
-  constructor(_date, _dateProxyFactory, _datePropertyAccessor, _errorLog, _mustProxifyItemHandlerFactory, releaseObject) {
-    super(), this._date = _date, this._dateProxyFactory = _dateProxyFactory, this._datePropertyAccessor = _datePropertyAccessor, this._errorLog = _errorLog, this._mustProxifyItemHandlerFactory = _mustProxifyItemHandlerFactory, this.releaseObject = releaseObject;
+  constructor(_date, _dateProxyFactory, _datePropertyAccessor, _errorLog, releaseObject) {
+    super(), this._date = _date, this._dateProxyFactory = _dateProxyFactory, this._datePropertyAccessor = _datePropertyAccessor, this._errorLog = _errorLog, this.releaseObject = releaseObject;
   }
   getId(data) {
     return data.index;
@@ -1305,14 +1324,16 @@ var ProperForDataObserverManager = class ProperForDataObserverManager2 extends S
   createId(data) {
     return data.index;
   }
-  createInstance(data, id) {
+  createInstance(data, index) {
+    const indexWatchPredicate = /* @__PURE__ */ __name((targetIndex, target, context) => targetIndex === index && target === context, "indexWatchPredicate");
+    const indexWatchRule = new IndexWatchRule(this._date, indexWatchPredicate);
     const dateObserver = this._dateProxyFactory.create({
       date: this._date,
-      mustProxify: this._mustProxifyItemHandlerFactory.create(id).instance
+      indexWatchRule
     }).instance.observer;
-    return new DatePropertybserver({
-      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
-      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    return new DatePropertyObserver({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(index) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(index), "release")
     }, this._date, data.index, this._datePropertyAccessor, dateObserver, this._errorLog);
   }
   releaseInstance(observer) {
@@ -1329,9 +1350,8 @@ var DatePropertyObserverManager = class extends SingletonFactory4 {
   _dateProxyFactory;
   _errorLog;
   _datePropertyAccessor;
-  _mustProxifyItemHandlerFactory;
-  constructor(_dateProxyFactory, _errorLog, _datePropertyAccessor, _mustProxifyItemHandlerFactory) {
-    super(), this._dateProxyFactory = _dateProxyFactory, this._errorLog = _errorLog, this._datePropertyAccessor = _datePropertyAccessor, this._mustProxifyItemHandlerFactory = _mustProxifyItemHandlerFactory;
+  constructor(_dateProxyFactory, _errorLog, _datePropertyAccessor) {
+    super(), this._dateProxyFactory = _dateProxyFactory, this._errorLog = _errorLog, this._datePropertyAccessor = _datePropertyAccessor;
   }
   getId(date) {
     return date;
@@ -1340,7 +1360,7 @@ var DatePropertyObserverManager = class extends SingletonFactory4 {
     return date;
   }
   createInstance(date) {
-    return new ProperForDataObserverManager(date, this._dateProxyFactory, this._datePropertyAccessor, this._errorLog, this._mustProxifyItemHandlerFactory, () => this.release(date));
+    return new ProperForDataObserverManager(date, this._dateProxyFactory, this._datePropertyAccessor, this._errorLog, () => this.release(date));
   }
   releaseInstance(properForDataObserverManager) {
     properForDataObserverManager.dispose();
@@ -1351,13 +1371,11 @@ DatePropertyObserverManager = _ts_decorate13([
   _ts_param13(0, Inject12(RsXStateManagerInjectionTokens.IDateProxyFactory)),
   _ts_param13(1, Inject12(RsXCoreInjectionTokens9.IErrorLog)),
   _ts_param13(2, Inject12(RsXCoreInjectionTokens9.IDatePropertyAccessor)),
-  _ts_param13(3, Inject12(RsXStateManagerInjectionTokens.IMustProxifyItemHandlerFactory)),
   _ts_metadata13("design:type", Function),
   _ts_metadata13("design:paramtypes", [
     typeof IDateProxyFactory === "undefined" ? Object : IDateProxyFactory,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
-    typeof IDatePropertyAccessor === "undefined" ? Object : IDatePropertyAccessor,
-    typeof IMustProxifyItemHandlerFactory === "undefined" ? Object : IMustProxifyItemHandlerFactory
+    typeof IDatePropertyAccessor === "undefined" ? Object : IDatePropertyAccessor
   ])
 ], DatePropertyObserverManager);
 
@@ -1384,8 +1402,8 @@ var DatePropertyObserverProxyPairFactory = class extends IndexObserverProxyPairF
   static {
     __name(this, "DatePropertyObserverProxyPairFactory");
   }
-  constructor(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister) {
-    super(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister, truePredicate5);
+  constructor(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister, valueMetadata) {
+    super(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister, valueMetadata, truePredicate5);
   }
   applies(object) {
     return object instanceof Date;
@@ -1399,6 +1417,7 @@ DatePropertyObserverProxyPairFactory = _ts_decorate14([
   _ts_param14(3, Inject13(RsXCoreInjectionTokens10.IGuidFactory)),
   _ts_param14(4, Inject13(RsXCoreInjectionTokens10.IIndexValueAccessor)),
   _ts_param14(5, Inject13(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param14(6, Inject13(RsXCoreInjectionTokens10.IValueMetadata)),
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
     typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
@@ -1406,7 +1425,8 @@ DatePropertyObserverProxyPairFactory = _ts_decorate14([
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
-    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
+    typeof IValueMetadata === "undefined" ? Object : IValueMetadata
   ])
 ], DatePropertyObserverProxyPairFactory);
 
@@ -1433,11 +1453,11 @@ var NonIterableObjectPropertyObserverProxyPairFactory = class extends IndexObser
   static {
     __name(this, "NonIterableObjectPropertyObserverProxyPairFactory");
   }
-  constructor(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister) {
-    super(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister);
+  constructor(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata) {
+    super(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata);
   }
   applies(object, propertyInfo) {
-    return !(Array.isArray(object) || object instanceof Date || object instanceof Map || object instanceof Set) && Type7.isString(propertyInfo.key) && !Type7.isMethod((Type7.toObject(object) ?? {})[propertyInfo.key]);
+    return !(Array.isArray(object) || object instanceof Date || object instanceof Map || object instanceof Set) && Type7.isString(propertyInfo.index) && !Type7.isMethod((Type7.toObject(object) ?? {})[propertyInfo.index]);
   }
   setIndexValue(object, key, value) {
     object[key] = value;
@@ -1451,6 +1471,7 @@ NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate15([
   _ts_param15(3, Inject14(RsXCoreInjectionTokens11.IGuidFactory)),
   _ts_param15(4, Inject14(RsXCoreInjectionTokens11.IIndexValueAccessor)),
   _ts_param15(5, Inject14(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param15(6, Inject14(RsXCoreInjectionTokens11.IValueMetadata)),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
@@ -1458,13 +1479,14 @@ NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate15([
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
-    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
+    typeof IValueMetadata === "undefined" ? Object : IValueMetadata
   ])
 ], NonIterableObjectPropertyObserverProxyPairFactory);
 
 // lib/property-observer/factories/non-iterable-object-property/object-property-observer-manager.ts
-import { Inject as Inject15, Injectable as Injectable16, InvalidOperationException as InvalidOperationException2, PropertyDescriptorType, SingletonFactory as SingletonFactory5, Type as Type8 } from "@rs-x/core";
 import { Subject as Subject2 } from "rxjs";
+import { Inject as Inject15, Injectable as Injectable16, InvalidOperationException as InvalidOperationException2, PropertyDescriptorType, SingletonFactory as SingletonFactory5, Type as Type8 } from "@rs-x/core";
 function _ts_decorate16(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1550,12 +1572,12 @@ var PropertObserver = class PropertObserver2 extends AbstractObserver {
         ...change,
         chain: [
           {
-            object: this.target,
-            id: this.id
+            context: this.target,
+            index: this.id
           }
         ],
         target: this.target,
-        id,
+        index: id,
         setValue: this.setValue
       });
       this._emitingChange = false;
@@ -1655,8 +1677,9 @@ ObjectPropertyObserverManager = _ts_decorate16([
   ])
 ], ObjectPropertyObserverManager);
 
-// lib/property-observer/must-proxify-item-handler.factory.ts
-import { Injectable as Injectable17, SingletonFactory as SingletonFactory6 } from "@rs-x/core";
+// lib/proxies/array-proxy/array-proxy.factory.ts
+import { Subject as Subject3 } from "rxjs";
+import { Inject as Inject16, Injectable as Injectable17, SingletonFactory as SingletonFactory6, Type as Type9 } from "@rs-x/core";
 function _ts_decorate17(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1668,43 +1691,6 @@ function _ts_metadata17(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata17, "_ts_metadata");
-var MustProxifyItemHandlerFactory = class extends SingletonFactory6 {
-  static {
-    __name(this, "MustProxifyItemHandlerFactory");
-  }
-  constructor() {
-    super();
-  }
-  getId(index) {
-    return index;
-  }
-  createInstance(_, id) {
-    return (index) => index === id;
-  }
-  createId(index) {
-    return index;
-  }
-};
-MustProxifyItemHandlerFactory = _ts_decorate17([
-  Injectable17(),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [])
-], MustProxifyItemHandlerFactory);
-
-// lib/proxies/array-proxy/array-proxy.factory.ts
-import { Inject as Inject16, Injectable as Injectable18, SingletonFactory as SingletonFactory7, Type as Type9 } from "@rs-x/core";
-import { Subject as Subject3 } from "rxjs";
-function _ts_decorate18(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate18, "_ts_decorate");
-function _ts_metadata18(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata18, "_ts_metadata");
 function _ts_param17(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1832,11 +1818,11 @@ var ArrayProxy = class ArrayProxy2 extends AbstractObserver {
       arguments: [],
       chain: [
         {
-          object: originaArray,
-          id: index
+          context: originaArray,
+          index
         }
       ],
-      id: index,
+      index,
       target: originaArray,
       newValue: value
     });
@@ -1848,7 +1834,7 @@ var ArrayProxy = class ArrayProxy2 extends AbstractObserver {
     }
   }
 };
-var ArrayProxyFactory = class extends SingletonFactory7 {
+var ArrayProxyFactory = class extends SingletonFactory6 {
   static {
     __name(this, "ArrayProxyFactory");
   }
@@ -1881,29 +1867,29 @@ var ArrayProxyFactory = class extends SingletonFactory7 {
     arrayObserverWithProxy.observer.dispose();
   }
 };
-ArrayProxyFactory = _ts_decorate18([
-  Injectable18(),
+ArrayProxyFactory = _ts_decorate17([
+  Injectable17(),
   _ts_param17(0, Inject16(RsXStateManagerInjectionTokens.IProxyRegistry)),
-  _ts_metadata18("design:type", Function),
-  _ts_metadata18("design:paramtypes", [
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], ArrayProxyFactory);
 
 // lib/proxies/date-proxy/date-proxy.factory.ts
-import { Inject as Inject17, Injectable as Injectable19, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, SingletonFactoryWithGuid as SingletonFactoryWithGuid4, Type as Type10 } from "@rs-x/core";
 import { Subject as Subject4 } from "rxjs";
-function _ts_decorate19(decorators, target, key, desc) {
+import { Inject as Inject17, Injectable as Injectable18, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, SingletonFactoryWithGuid as SingletonFactoryWithGuid4, Type as Type10 } from "@rs-x/core";
+function _ts_decorate18(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate19, "_ts_decorate");
-function _ts_metadata19(k, v) {
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata18(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata19, "_ts_metadata");
+__name(_ts_metadata18, "_ts_metadata");
 function _ts_param18(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1915,7 +1901,7 @@ var DateProxy = class DateProxy2 extends AbstractObserver {
     __name(this, "DateProxy");
   }
   _proxyRegistry;
-  _filter;
+  indexWatchRule;
   _dateSetterMetadata = /* @__PURE__ */ new Map([
     [
       "setFullYear",
@@ -2038,8 +2024,8 @@ var DateProxy = class DateProxy2 extends AbstractObserver {
       }
     ]
   ]);
-  constructor(owner, initialValue, _proxyRegistry, _filter) {
-    super(owner, Type10.cast(void 0), initialValue, new Subject4(), void 0), this._proxyRegistry = _proxyRegistry, this._filter = _filter;
+  constructor(owner, initialValue, _proxyRegistry, indexWatchRule) {
+    super(owner, Type10.cast(void 0), initialValue, new Subject4(), void 0), this._proxyRegistry = _proxyRegistry, this.indexWatchRule = indexWatchRule;
     this.target = new Proxy(initialValue, this);
     this._proxyRegistry.register(initialValue, this.target);
   }
@@ -2062,40 +2048,40 @@ var DateProxy = class DateProxy2 extends AbstractObserver {
     }
     return value;
   }
-  emitChanges(oldTimestamp, newDate, propertyName) {
+  emitChanges(oldTimestamp, date, propertyName) {
     const oldDate = new Date(oldTimestamp);
-    if (!this._filter) {
+    if (!this.indexWatchRule) {
       this.emitChange({
         arguments: [],
         chain: [
           {
-            object: newDate,
-            id: propertyName
+            context: date,
+            index: propertyName
           }
         ],
-        id: propertyName,
-        target: newDate,
-        newValue: newDate
+        index: propertyName,
+        target: date,
+        newValue: date
       });
       return;
     }
     for (const setterMetaData of this._dateSetterMetadata.values()) {
-      if (!this._filter(setterMetaData.name)) {
+      if (!this.indexWatchRule.test(setterMetaData.name, date)) {
         continue;
       }
       const oldValue = oldDate[setterMetaData.getterName].call(oldDate);
-      const newValue = newDate[setterMetaData.getterName].call(newDate);
+      const newValue = date[setterMetaData.getterName].call(date);
       if (oldValue !== newValue) {
         this.emitChange({
           arguments: [],
           chain: [
             {
-              object: newDate,
-              id: setterMetaData.name
+              context: date,
+              index: setterMetaData.name
             }
           ],
-          id: setterMetaData.name,
-          target: newDate,
+          index: setterMetaData.name,
+          target: date,
           newValue
         });
       }
@@ -2111,11 +2097,11 @@ var DateProxy = class DateProxy2 extends AbstractObserver {
         ],
         chain: [
           {
-            object: target,
-            id: 0
+            context: target,
+            index: 0
           }
         ],
-        id: 0,
+        index: 0,
         target,
         newValue: target
       });
@@ -2139,7 +2125,7 @@ var DateProxyFactory = class extends SingletonFactoryWithGuid4 {
     return data.date;
   }
   getGroupMemberId(data) {
-    return data.mustProxify;
+    return data.indexWatchRule;
   }
   createInstance(dateProxyData, id) {
     const observer = new DateProxy({
@@ -2148,7 +2134,7 @@ var DateProxyFactory = class extends SingletonFactoryWithGuid4 {
         this.release(id);
         dateProxyData.owner?.release();
       }, "release")
-    }, dateProxyData.date, this._proxyRegistry, dateProxyData.mustProxify);
+    }, dateProxyData.date, this._proxyRegistry, dateProxyData.indexWatchRule);
     return {
       observer,
       proxy: observer.target,
@@ -2156,30 +2142,30 @@ var DateProxyFactory = class extends SingletonFactoryWithGuid4 {
     };
   }
 };
-DateProxyFactory = _ts_decorate19([
-  Injectable19(),
+DateProxyFactory = _ts_decorate18([
+  Injectable18(),
   _ts_param18(0, Inject17(RsXCoreInjectionTokens12.IGuidFactory)),
   _ts_param18(1, Inject17(RsXStateManagerInjectionTokens.IProxyRegistry)),
-  _ts_metadata19("design:type", Function),
-  _ts_metadata19("design:paramtypes", [
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], DateProxyFactory);
 
 // lib/proxies/map-proxy/map-proxy.factory.ts
-import { Inject as Inject18, Injectable as Injectable20, SingletonFactory as SingletonFactory8, Type as Type11 } from "@rs-x/core";
-function _ts_decorate20(decorators, target, key, desc) {
+import { Inject as Inject18, Injectable as Injectable19, SingletonFactory as SingletonFactory7, Type as Type11 } from "@rs-x/core";
+function _ts_decorate19(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate20, "_ts_decorate");
-function _ts_metadata20(k, v) {
+__name(_ts_decorate19, "_ts_decorate");
+function _ts_metadata19(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata20, "_ts_metadata");
+__name(_ts_metadata19, "_ts_metadata");
 function _ts_param19(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2216,7 +2202,6 @@ var MapProxy = class extends AbstractObserver {
   }
   disposeInternal() {
     this._proxyRegistry.unregister(this.value);
-    ;
   }
   isUpdateMapKey(property) {
     return typeof property === "string" && property in this.updateMap;
@@ -2250,17 +2235,17 @@ var MapProxy = class extends AbstractObserver {
       arguments: [],
       chain: [
         {
-          object: originalMap,
-          id: key
+          context: originalMap,
+          index: key
         }
       ],
-      id: key,
+      index: key,
       target: originalMap,
       newValue: value
     });
   }
 };
-var MapProxyFactory = class extends SingletonFactory8 {
+var MapProxyFactory = class extends SingletonFactory7 {
   static {
     __name(this, "MapProxyFactory");
   }
@@ -2292,29 +2277,29 @@ var MapProxyFactory = class extends SingletonFactory8 {
     mapObserverWithProxy.observer.dispose();
   }
 };
-MapProxyFactory = _ts_decorate20([
-  Injectable20(),
+MapProxyFactory = _ts_decorate19([
+  Injectable19(),
   _ts_param19(0, Inject18(RsXStateManagerInjectionTokens.IProxyRegistry)),
-  _ts_metadata20("design:type", Function),
-  _ts_metadata20("design:paramtypes", [
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], MapProxyFactory);
 
 // lib/proxies/observable-proxy/observable-proxy.factory.ts
-import { Inject as Inject19, Injectable as Injectable21, RsXCoreInjectionTokens as RsXCoreInjectionTokens13, SingletonFactory as SingletonFactory9 } from "@rs-x/core";
 import { ReplaySubject as ReplaySubject2 } from "rxjs";
-function _ts_decorate21(decorators, target, key, desc) {
+import { Inject as Inject19, Injectable as Injectable20, RsXCoreInjectionTokens as RsXCoreInjectionTokens13, SingletonFactory as SingletonFactory8 } from "@rs-x/core";
+function _ts_decorate20(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate21, "_ts_decorate");
-function _ts_metadata21(k, v) {
+__name(_ts_decorate20, "_ts_decorate");
+function _ts_metadata20(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata21, "_ts_metadata");
+__name(_ts_metadata20, "_ts_metadata");
 function _ts_param20(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2353,12 +2338,12 @@ var ObservableProxy = class ObservableProxy2 extends AbstractObserver {
       arguments: [],
       chain: [],
       target: this.target,
-      id: this.id,
+      index: this.id,
       newValue
     });
   }, "emitObservableChange");
 };
-var ObservableProxyFactory = class extends SingletonFactory9 {
+var ObservableProxyFactory = class extends SingletonFactory8 {
   static {
     __name(this, "ObservableProxyFactory");
   }
@@ -2390,29 +2375,29 @@ var ObservableProxyFactory = class extends SingletonFactory9 {
     observableObserverWithProxy.observer.dispose();
   }
 };
-ObservableProxyFactory = _ts_decorate21([
-  Injectable21(),
+ObservableProxyFactory = _ts_decorate20([
+  Injectable20(),
   _ts_param20(0, Inject19(RsXCoreInjectionTokens13.IObservableAccessor)),
-  _ts_metadata21("design:type", Function),
-  _ts_metadata21("design:paramtypes", [
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
     typeof IObservableAccessor === "undefined" ? Object : IObservableAccessor
   ])
 ], ObservableProxyFactory);
 
 // lib/proxies/promise-proxy/promise-proxy.factory.ts
-import { Inject as Inject20, Injectable as Injectable22, RsXCoreInjectionTokens as RsXCoreInjectionTokens14, SingletonFactory as SingletonFactory10 } from "@rs-x/core";
 import { ReplaySubject as ReplaySubject3 } from "rxjs";
-function _ts_decorate22(decorators, target, key, desc) {
+import { Inject as Inject20, Injectable as Injectable21, RsXCoreInjectionTokens as RsXCoreInjectionTokens14, SingletonFactory as SingletonFactory9 } from "@rs-x/core";
+function _ts_decorate21(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate22, "_ts_decorate");
-function _ts_metadata22(k, v) {
+__name(_ts_decorate21, "_ts_decorate");
+function _ts_metadata21(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata22, "_ts_metadata");
+__name(_ts_metadata21, "_ts_metadata");
 function _ts_param21(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2444,7 +2429,7 @@ var PromiseObserver = class PromiseObserver2 extends AbstractObserver {
     });
   }, "onValueResolved");
 };
-var PromiseProxyFactory = class extends SingletonFactory10 {
+var PromiseProxyFactory = class extends SingletonFactory9 {
   static {
     __name(this, "PromiseProxyFactory");
   }
@@ -2476,24 +2461,24 @@ var PromiseProxyFactory = class extends SingletonFactory10 {
     promiseObserverWithProxy.observer.dispose();
   }
 };
-PromiseProxyFactory = _ts_decorate22([
-  Injectable22(),
+PromiseProxyFactory = _ts_decorate21([
+  Injectable21(),
   _ts_param21(0, Inject20(RsXCoreInjectionTokens14.IPromiseAccessor)),
-  _ts_metadata22("design:type", Function),
-  _ts_metadata22("design:paramtypes", [
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
     typeof IPromiseAccessor === "undefined" ? Object : IPromiseAccessor
   ])
 ], PromiseProxyFactory);
 
 // lib/proxies/proxy-registry/proxy-registry.ts
-import { Injectable as Injectable23 } from "@rs-x/core";
-function _ts_decorate23(decorators, target, key, desc) {
+import { Injectable as Injectable22 } from "@rs-x/core";
+function _ts_decorate22(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate23, "_ts_decorate");
+__name(_ts_decorate22, "_ts_decorate");
 var ProxyRegistry = class {
   static {
     __name(this, "ProxyRegistry");
@@ -2515,23 +2500,23 @@ var ProxyRegistry = class {
     return !!this.getProxyTarget(object);
   }
 };
-ProxyRegistry = _ts_decorate23([
-  Injectable23()
+ProxyRegistry = _ts_decorate22([
+  Injectable22()
 ], ProxyRegistry);
 
 // lib/proxies/set-proxy/set-proxy.factory.ts
-import { Inject as Inject21, Injectable as Injectable24, SingletonFactory as SingletonFactory11, Type as Type12 } from "@rs-x/core";
-function _ts_decorate24(decorators, target, key, desc) {
+import { Inject as Inject21, Injectable as Injectable23, SingletonFactory as SingletonFactory10, Type as Type12 } from "@rs-x/core";
+function _ts_decorate23(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate24, "_ts_decorate");
-function _ts_metadata23(k, v) {
+__name(_ts_decorate23, "_ts_decorate");
+function _ts_metadata22(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata23, "_ts_metadata");
+__name(_ts_metadata22, "_ts_metadata");
 function _ts_param22(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2589,17 +2574,17 @@ var SetProxy = class extends AbstractObserver {
       arguments: [],
       chain: [
         {
-          object: originalSet,
-          id
+          context: originalSet,
+          index: id
         }
       ],
-      id,
+      index: id,
       target: originalSet,
       newValue: value
     });
   }
 };
-var SetProxyFactory = class extends SingletonFactory11 {
+var SetProxyFactory = class extends SingletonFactory10 {
   static {
     __name(this, "SetProxyFactory");
   }
@@ -2631,11 +2616,11 @@ var SetProxyFactory = class extends SingletonFactory11 {
     setObserverWithProxy.observer.dispose();
   }
 };
-SetProxyFactory = _ts_decorate24([
-  Injectable24(),
+SetProxyFactory = _ts_decorate23([
+  Injectable23(),
   _ts_param22(0, Inject21(RsXStateManagerInjectionTokens.IProxyRegistry)),
-  _ts_metadata23("design:type", Function),
-  _ts_metadata23("design:paramtypes", [
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], SetProxyFactory);
@@ -2644,25 +2629,25 @@ SetProxyFactory = _ts_decorate24([
 import { ContainerModule, InjectionContainer, registerMultiInjectServices, RsXCoreModule } from "@rs-x/core";
 
 // lib/state-manager/object-state-manager.ts
-import { Inject as Inject22, Injectable as Injectable25, RsXCoreInjectionTokens as RsXCoreInjectionTokens15, SingletonFactory as SingletonFactory12, UnsupportedException as UnsupportedException2 } from "@rs-x/core";
-function _ts_decorate25(decorators, target, key, desc) {
+import { Inject as Inject22, Injectable as Injectable24, RsXCoreInjectionTokens as RsXCoreInjectionTokens15, SingletonFactory as SingletonFactory11, UnsupportedException as UnsupportedException2 } from "@rs-x/core";
+function _ts_decorate24(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate25, "_ts_decorate");
-function _ts_metadata24(k, v) {
+__name(_ts_decorate24, "_ts_decorate");
+function _ts_metadata23(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata24, "_ts_metadata");
+__name(_ts_metadata23, "_ts_metadata");
 function _ts_param23(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param23, "_ts_param");
-var StateForObjectManager = class extends SingletonFactory12 {
+var StateForObjectManager = class extends SingletonFactory11 {
   static {
     __name(this, "StateForObjectManager");
   }
@@ -2708,7 +2693,7 @@ var StateForObjectManager = class extends SingletonFactory12 {
     this.releaseContext();
   }
 };
-var ObjectStateManager = class extends SingletonFactory12 {
+var ObjectStateManager = class extends SingletonFactory11 {
   static {
     __name(this, "ObjectStateManager");
   }
@@ -2752,21 +2737,21 @@ var ObjectStateManager = class extends SingletonFactory12 {
     return new StateForObjectManager(this._deepClone, () => this.release(context));
   }
 };
-ObjectStateManager = _ts_decorate25([
-  Injectable25(),
+ObjectStateManager = _ts_decorate24([
+  Injectable24(),
   _ts_param23(0, Inject22(RsXCoreInjectionTokens15.IDeepClone)),
-  _ts_metadata24("design:type", Function),
-  _ts_metadata24("design:paramtypes", [
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
     typeof IDeepClone === "undefined" ? Object : IDeepClone
   ])
 ], ObjectStateManager);
 
 // lib/state-manager/state-manager.ts
-import { Inject as Inject23, Injectable as Injectable26, PENDING, RsXCoreInjectionTokens as RsXCoreInjectionTokens16 } from "@rs-x/core";
 import { Subject as Subject5 } from "rxjs";
+import { Assertion, Inject as Inject23, Injectable as Injectable25, PENDING, RsXCoreInjectionTokens as RsXCoreInjectionTokens16, truePredicate as truePredicate6 } from "@rs-x/core";
 
 // lib/state-manager/state-change-subscription-manager/state-change-subsription-manager.ts
-import { SingletonFactory as SingletonFactory13 } from "@rs-x/core";
+import { SingletonFactory as SingletonFactory12 } from "@rs-x/core";
 var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
   static {
     __name(this, "StateChangeSubscriptionsForContextManager");
@@ -2776,17 +2761,17 @@ var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsFo
     super(context, releaseContext, errorLog, guidFactory), this._objectObserverManager = _objectObserverManager;
   }
   getGroupId(data) {
-    return data.key;
+    return data.index;
   }
   getGroupMemberId(data) {
-    return data.mustProxify;
+    return data.indexWatchRule;
   }
   createObserver(context, data, id) {
     const objectObserver = this._objectObserverManager.create(context).instance;
     const observer = objectObserver.create({
-      key: data.key,
+      index: data.index,
       initializeManually: true,
-      mustProxify: data.mustProxify,
+      indexWatchRule: data.indexWatchRule,
       owner: {
         release: /* @__PURE__ */ __name(() => this.release(id), "release")
       }
@@ -2797,7 +2782,7 @@ var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsFo
     };
   }
 };
-var StateChangeSubscriptionManager = class extends SingletonFactory13 {
+var StateChangeSubscriptionManager = class extends SingletonFactory12 {
   static {
     __name(this, "StateChangeSubscriptionManager");
   }
@@ -2810,6 +2795,9 @@ var StateChangeSubscriptionManager = class extends SingletonFactory13 {
   getId(context) {
     return context;
   }
+  instanceGroupInfoEntriesForContext(context) {
+    return this.getFromId(context)?.instanceGroupInfoEntries() ?? [][Symbol.iterator]();
+  }
   isRegistered(context, key) {
     const stateChangeSubscriptionsForContextManager = this.getFromId(context);
     if (!stateChangeSubscriptionsForContextManager) {
@@ -2830,17 +2818,17 @@ var StateChangeSubscriptionManager = class extends SingletonFactory13 {
 };
 
 // lib/state-manager/state-manager.ts
-function _ts_decorate26(decorators, target, key, desc) {
+function _ts_decorate25(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate26, "_ts_decorate");
-function _ts_metadata25(k, v) {
+__name(_ts_decorate25, "_ts_decorate");
+function _ts_metadata24(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata25, "_ts_metadata");
+__name(_ts_metadata24, "_ts_metadata");
 function _ts_param24(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2881,31 +2869,34 @@ var StateManager = class {
   toString() {
     return this._objectStateManager.toString();
   }
-  isWatched(context, index, mustProxify) {
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `${this.constructor.name}`;
+  }
+  isWatched(context, index, indexWatchRule) {
     const stateChangeSubscriptionsForContextManager = this._stateChangeSubscriptionManager.getFromId(context);
     if (!stateChangeSubscriptionsForContextManager) {
       return false;
     }
     const id = stateChangeSubscriptionsForContextManager.getId({
-      key: index,
-      mustProxify
+      index,
+      indexWatchRule
     });
     return id ? stateChangeSubscriptionsForContextManager.has(id) : false;
   }
-  watchState(context, index, mustProxify) {
-    if (!this.isWatched(context, index, mustProxify)) {
+  watchState(context, index, indexWatchRule) {
+    if (!this.isWatched(context, index, indexWatchRule)) {
       const value = this.getState(context, index);
-      this.tryToSubscribeToChange(context, index, mustProxify);
+      this.tryToSubscribeToChange(context, index, indexWatchRule);
       return value;
     } else {
       return this.increaseStateReferenceCount(context, index, true);
     }
   }
-  releaseState(context, index, mustProxify) {
+  releaseState(context, index, indexWatchRule) {
     if (!this._objectStateManager.getFromId(context)?.has(index)) {
       return;
     }
-    this.internalUnregister(context, index, mustProxify);
+    this.internalUnregister(context, index, indexWatchRule);
   }
   clear() {
     this._stateChangeSubscriptionManager.dispose();
@@ -2917,31 +2908,34 @@ var StateManager = class {
   setState(context, index, value) {
     this.internalSetState(context, index, value, {
       context,
-      value: this.getState(context, index)
+      value: this.getState(context, index),
+      shouldEmitChange: truePredicate6
     });
   }
   internalSetState(context, index, value, transferValue) {
     this.tryRebindingNestedState(value, transferValue.value);
     this._objectStateManager.replaceState(index, context, value, transferValue.context, false);
-    this.emitChange(context, index, value, transferValue.value, transferValue.context);
+    if (!transferValue?.shouldEmitChange || transferValue.shouldEmitChange(context, index)) {
+      this.emitChange(context, index, value, transferValue.value, transferValue.context);
+    }
   }
   getOldValue(context, index) {
     return this._objectStateManager.getFromId(context)?.getFromId(index)?.valueCopy;
   }
-  unnsubscribeToObserverEvents(context, index, mustProxify) {
+  unnsubscribeToObserverEvents(context, index, indexWatchRule) {
     const subscriptionsForKey = this._stateChangeSubscriptionManager.getFromId(context);
     const observer = subscriptionsForKey?.getFromData({
-      key: index,
-      mustProxify
+      index,
+      indexWatchRule
     });
     if (!observer) {
       return;
     }
     observer.dispose();
   }
-  internalUnregister(context, index, mustProxify) {
+  internalUnregister(context, index, indexWatchRule) {
     if (this.canReleaseState(context, index)) {
-      this.unnsubscribeToObserverEvents(context, index, mustProxify);
+      this.unnsubscribeToObserverEvents(context, index, indexWatchRule);
     }
   }
   emitChange(context, index, newValue, oldValue, oldContext) {
@@ -2951,7 +2945,7 @@ var StateManager = class {
     this._changed.next({
       oldContext: oldContext ?? context,
       context,
-      key: index,
+      index,
       oldValue,
       newValue
     });
@@ -2971,11 +2965,11 @@ var StateManager = class {
     });
     return state;
   }
-  tryToSubscribeToChange(context, index, mustProxify, transferedValue) {
+  tryToSubscribeToChange(context, index, indexWatchRule, transferedValue) {
     this._stateChangeSubscriptionManager.create(context).instance.create({
-      key: index,
-      mustProxify,
-      onChanged: /* @__PURE__ */ __name((change) => this.onChange(change, mustProxify, true), "onChanged"),
+      index,
+      indexWatchRule,
+      onChanged: /* @__PURE__ */ __name((change) => this.onChange(change, true), "onChanged"),
       init: /* @__PURE__ */ __name((observer) => {
         if (observer.value !== void 0) {
           this.setInitialValue(context, index, observer.value, transferedValue, true);
@@ -2996,22 +2990,21 @@ var StateManager = class {
     if (!oldState) {
       return [];
     }
-    return Array.from(oldState.ids()).map((id) => {
-      const { value: oldValue, watched } = oldState.getFromId(id) ?? {};
-      const newValue = this.getValue(newContext, id);
+    return Array.from(oldState.ids()).map((index) => {
+      const { value: oldValue, watched } = oldState.getFromId(index) ?? {};
+      const newValue = this.getValue(newContext, index);
       if (oldContext === newContext && this._equalityService.isEqual(oldValue, newValue)) {
         return [];
       }
-      let pendingId = null;
       if (newValue === PENDING) {
         this._pending.set(newContext, oldValue);
       }
       const stateInfo = {
         oldContext,
         context: newContext,
-        key: id,
+        index,
         oldValue,
-        newValue: pendingId ?? newValue,
+        newValue,
         watched
       };
       return newValue === PENDING ? [
@@ -3022,38 +3015,68 @@ var StateManager = class {
       ];
     }).reduce((a, b) => a.concat(b), []);
   }
-  tryRebindingNestedState(newValue, oldValue, mustProxify) {
+  tryRebindingNestedState(newValue, oldValue) {
     const stateChanges = this.getStateChanges(oldValue, newValue);
-    stateChanges.forEach((stateChange) => {
-      this.internalUnregister(stateChange.oldContext, stateChange.key, mustProxify);
-    });
-    stateChanges.filter((stateChange) => stateChange.context !== stateChange.oldContext).forEach((stateChange) => this._contextChanged.next({
-      context: stateChange.context,
-      oldContext: stateChange.oldContext,
-      key: stateChange.key
-    }));
-    stateChanges.filter((stateChange) => stateChange.watched).forEach((stateChange) => this.tryToSubscribeToChange(stateChange.context, stateChange.key, mustProxify, {
-      context: stateChange.oldContext,
-      value: stateChange.oldValue
-    }));
-    stateChanges.filter((stateChange) => !stateChange.watched).forEach((stateChange) => this.internalSetState(stateChange.context, stateChange.key, stateChange.newValue, {
-      context: stateChange.oldContext,
-      value: stateChange.oldValue
-    }));
+    if (stateChanges.length === 0) {
+      return;
+    }
+    const emitted = [];
+    const shouldEmitChange = /* @__PURE__ */ __name((context, index) => {
+      if (emitted.some(([c, i]) => c === context && i === index)) {
+        return false;
+      }
+      emitted.push([
+        context,
+        index
+      ]);
+      return true;
+    }, "shouldEmitChange");
+    for (const stateChange of stateChanges) {
+      Assertion.assert(() => stateChange.context !== stateChange.oldContext, "Expected old and new context not to be equal");
+      this._contextChanged.next({
+        context: stateChange.context,
+        oldContext: stateChange.oldContext,
+        index: stateChange.index
+      });
+      if (!stateChange.watched) {
+        this.internalUnregister(stateChange.oldContext, stateChange.index, void 0);
+        this.internalSetState(stateChange.context, stateChange.index, stateChange.newValue, {
+          context: stateChange.oldContext,
+          value: stateChange.oldValue
+        });
+        continue;
+      }
+      const instanceGroupInfos = this._stateChangeSubscriptionManager.instanceGroupInfoEntriesForContext(stateChange.oldContext);
+      const rebindingOptions = {
+        context: stateChange.oldContext,
+        value: stateChange.oldValue,
+        shouldEmitChange
+      };
+      for (const { groupMemberId } of instanceGroupInfos) {
+        const indexWatchRule = groupMemberId;
+        this.internalUnregister(stateChange.oldContext, stateChange.index, indexWatchRule);
+        if (indexWatchRule) {
+          indexWatchRule.context = stateChange.context;
+        }
+        this.tryToSubscribeToChange(stateChange.context, stateChange.index, indexWatchRule, rebindingOptions);
+      }
+    }
   }
   setInitialValue(context, index, initialValue, transferedValue, watched) {
     this.updateState(context, transferedValue?.context ?? context, index, initialValue, watched);
-    this.emitChange(context, index, initialValue, transferedValue?.value, transferedValue?.context);
+    if (!transferedValue?.shouldEmitChange || transferedValue.shouldEmitChange(context, index)) {
+      this.emitChange(context, index, initialValue, transferedValue?.value, transferedValue?.context);
+    }
   }
   getChainChanges(chain) {
     if (!chain) {
       return [];
     }
-    const registeredChainParts = chain.filter((chainPart) => this._stateChangeSubscriptionManager.isRegistered(chainPart.object, chainPart.id));
+    const registeredChainParts = chain.filter((chainPart) => this._stateChangeSubscriptionManager.isRegistered(chainPart.context, chainPart.index));
     return registeredChainParts.map((chainPart) => ({
       ...chainPart,
-      oldValue: this.getOldValue(chainPart.object, chainPart.id),
-      value: this.getValue(chainPart.object, chainPart.id)
+      oldValue: this.getOldValue(chainPart.context, chainPart.index),
+      value: this.getValue(chainPart.context, chainPart.index)
     }));
   }
   getCurrentValue(context, id) {
@@ -3064,7 +3087,7 @@ var StateManager = class {
     }
     return this.getState(context, id);
   }
-  onChange(change, mustProxify, watched) {
+  onChange(change, watched = false) {
     const chainChanges = this.getChainChanges(change.chain);
     if (chainChanges.length === 0) {
       return;
@@ -3072,25 +3095,25 @@ var StateManager = class {
     this._startChangeCycle.next();
     try {
       const chainLeaf = chainChanges[chainChanges.length - 1];
-      const currentValue = this.getCurrentValue(chainLeaf.object, chainLeaf.id);
-      this.tryRebindingNestedState(change.newValue, currentValue, mustProxify);
-      this.updateState(chainLeaf.object, chainLeaf.object, chainLeaf.id, chainLeaf.value, watched);
-      chainChanges.forEach((chainChange) => this.emitChange(chainChange.object, chainChange.id, chainChange.value, chainChange.oldValue));
+      const currentValue = this.getCurrentValue(chainLeaf.context, chainLeaf.index);
+      this.tryRebindingNestedState(change.newValue, currentValue);
+      this.updateState(chainLeaf.context, chainLeaf.context, chainLeaf.index, chainLeaf.value, watched);
+      chainChanges.forEach((chainChange) => this.emitChange(chainChange.context, chainChange.index, chainChange.value, chainChange.oldValue));
     } finally {
       this._endChangeCycle.next();
     }
   }
 };
-StateManager = _ts_decorate26([
-  Injectable26(),
+StateManager = _ts_decorate25([
+  Injectable25(),
   _ts_param24(0, Inject23(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
   _ts_param24(1, Inject23(RsXStateManagerInjectionTokens.IObjectStateManager)),
   _ts_param24(2, Inject23(RsXCoreInjectionTokens16.IErrorLog)),
   _ts_param24(3, Inject23(RsXCoreInjectionTokens16.IGuidFactory)),
   _ts_param24(4, Inject23(RsXCoreInjectionTokens16.IIndexValueAccessor)),
   _ts_param24(5, Inject23(RsXCoreInjectionTokens16.IEqualityService)),
-  _ts_metadata25("design:type", Function),
-  _ts_metadata25("design:paramtypes", [
+  _ts_metadata24("design:type", Function),
+  _ts_metadata24("design:paramtypes", [
     typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager,
     typeof IObjectStateManager === "undefined" ? Object : IObjectStateManager,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
@@ -3162,7 +3185,6 @@ var RsXStateManagerModule = new ContainerModule((options) => {
   options.bind(RsXStateManagerInjectionTokens.IObjectPropertyObserverManager).to(ObjectPropertyObserverManager).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.ICollectionItemObserverManager).to(CollectionItemObserverManager).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IDatePropertyObserverManager).to(DatePropertyObserverManager).inSingletonScope();
-  options.bind(RsXStateManagerInjectionTokens.IMustProxifyItemHandlerFactory).to(MustProxifyItemHandlerFactory).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IObjectStateManager).to(ObjectStateManager).inTransientScope();
   options.bind(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProviderFactory).toFactory((context) => {
     return () => context.get(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProvider);
@@ -3188,10 +3210,10 @@ export {
   GroupedChangeSubscriptionsForContextManager,
   IndexChangeSubscriptionManager,
   IndexObserverProxyPairFactory,
+  IndexWatchRule,
   MapObserverProxyPairFactory,
   MapProxy,
   MapProxyFactory,
-  MustProxifyItemHandlerFactory,
   NonIterableObjectPropertyObserverProxyPairFactory,
   ObjectObserverProxyPairFactoryProvider,
   ObjectObserverProxyPairManager,
@@ -3215,5 +3237,6 @@ export {
   StateManager,
   defaultObjectObserverProxyPairFactoryList,
   defaultPropertyObserverProxyPairFactoryList,
-  unloadRsXStateManagerModule
+  unloadRsXStateManagerModule,
+  watchIndexRecursiveRule
 };