@rs-x/state-manager 0.4.21 → 1.0.1

package/dist/index.js

@@ -61,8 +61,8 @@ var AbstractObserver = class {
 };
 
 // lib/grouped-change-subscriptions-for-context-manager.ts
-import { SingletonFactoryWithGuid } from "@rs-x/core";
-var GroupedChangeSubscriptionsForContextManager = class extends SingletonFactoryWithGuid {
+import { GuidKeyedInstanceFactory } from "@rs-x/core";
+var GroupedChangeSubscriptionsForContextManager = class extends GuidKeyedInstanceFactory {
   static {
     __name(this, "GroupedChangeSubscriptionsForContextManager");
   }
@@ -317,7 +317,6 @@ var RsXStateManagerInjectionTokens = {
   IMapProxyFactory: Symbol("IMapProxyFactory"),
   ISetProxyFactory: Symbol("ISetProxyFactory"),
   IDateProxyFactory: Symbol("IDateProxyFactory"),
-  IProxyRegistry: Symbol("IProxyRegistry"),
   IPromiseProxyFactory: Symbol("IPromiseProxyFactory"),
   IObservableProxyFactory: Symbol("IObservableProxyFactory"),
   IObjectPropertyObserverProxyPairManager: Symbol("IObjectPropertyObserverProxyPairManager"),
@@ -747,7 +746,7 @@ ObjectObserverProxyPairFactoryProvider = _ts_decorate8([
 ], ObjectObserverProxyPairFactoryProvider);
 
 // lib/object-observer/object-observer-proxy-pair-manager.ts
-import { Inject as Inject8, Injectable as Injectable9, InvalidOperationException, RsXCoreInjectionTokens as RsXCoreInjectionTokens5, SingletonFactoryWithGuid as SingletonFactoryWithGuid2, Type as Type4 } from "@rs-x/core";
+import { GuidKeyedInstanceFactory as GuidKeyedInstanceFactory2, Inject as Inject8, Injectable as Injectable9, InvalidOperationException, RsXCoreInjectionTokens as RsXCoreInjectionTokens5, Type as Type4 } from "@rs-x/core";
 function _ts_decorate9(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);
@@ -765,7 +764,7 @@ function _ts_param9(paramIndex, decorator) {
   };
 }
 __name(_ts_param9, "_ts_param");
-var ObjectObserverProxyPairManager = class extends SingletonFactoryWithGuid2 {
+var ObjectObserverProxyPairManager = class extends GuidKeyedInstanceFactory2 {
   static {
     __name(this, "ObjectObserverProxyPairManager");
   }
@@ -800,7 +799,7 @@ var ObjectObserverProxyPairManager = class extends SingletonFactoryWithGuid2 {
 ObjectObserverProxyPairManager = _ts_decorate9([
   Injectable9(),
   _ts_param9(0, Inject8(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProviderFactory)),
-  _ts_param9(1, Inject8(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param9(1, Inject8(RsXCoreInjectionTokens5.IProxyRegistry)),
   _ts_param9(2, Inject8(RsXCoreInjectionTokens5.IGuidFactory)),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
@@ -811,7 +810,7 @@ ObjectObserverProxyPairManager = _ts_decorate9([
 ], ObjectObserverProxyPairManager);
 
 // lib/object-property-observer-proxy-pair-manager.ts
-import { Inject as Inject9, Injectable as Injectable10, MultiInject as MultiInject2, RsXCoreInjectionTokens as RsXCoreInjectionTokens6, SingletonFactory, SingletonFactoryWithGuid as SingletonFactoryWithGuid3, Type as Type5, UnsupportedException } from "@rs-x/core";
+import { GuidKeyedInstanceFactory as GuidKeyedInstanceFactory3, Inject as Inject9, Injectable as Injectable10, KeyedInstanceFactory, MultiInject as MultiInject2, RsXCoreInjectionTokens as RsXCoreInjectionTokens6, Type as Type5, UnsupportedException } from "@rs-x/core";
 function _ts_decorate10(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);
@@ -829,7 +828,7 @@ function _ts_param10(paramIndex, decorator) {
   };
 }
 __name(_ts_param10, "_ts_param");
-var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 extends SingletonFactoryWithGuid3 {
+var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 extends GuidKeyedInstanceFactory3 {
   static {
     __name(this, "PropertyObserverProxyPairManager");
   }
@@ -868,7 +867,7 @@ var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 e
     return observerFactory;
   }
 };
-var ObjectPropertyObserverProxyPairManager = class extends SingletonFactory {
+var ObjectPropertyObserverProxyPairManager = class extends KeyedInstanceFactory {
   static {
     __name(this, "ObjectPropertyObserverProxyPairManager");
   }
@@ -899,7 +898,7 @@ ObjectPropertyObserverProxyPairManager = _ts_decorate10([
 ], ObjectPropertyObserverProxyPairManager);
 
 // lib/property-observer/factories/collection-item/collection-item-observer-manager.ts
-import { Inject as Inject10, Injectable as Injectable11, RsXCoreInjectionTokens as RsXCoreInjectionTokens7, SingletonFactory as SingletonFactory2 } from "@rs-x/core";
+import { Inject as Inject10, Injectable as Injectable11, KeyedInstanceFactory as KeyedInstanceFactory2, RsXCoreInjectionTokens as RsXCoreInjectionTokens7 } from "@rs-x/core";
 function _ts_decorate11(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);
@@ -961,7 +960,7 @@ var CollectionIndexObserver = class CollectionIndexObserver2 extends AbstractObs
     }
   }, "onChanged");
 };
-var CollectionIndexObserverManager = class CollectionIndexObserverManager2 extends SingletonFactory2 {
+var CollectionIndexObserverManager = class CollectionIndexObserverManager2 extends KeyedInstanceFactory2 {
   static {
     __name(this, "CollectionIndexObserverManager");
   }
@@ -993,7 +992,7 @@ var CollectionIndexObserverManager = class CollectionIndexObserverManager2 exten
     this.releaseObject();
   }
 };
-var CollectionItemObserverManager = class extends SingletonFactory2 {
+var CollectionItemObserverManager = class extends KeyedInstanceFactory2 {
   static {
     __name(this, "CollectionItemObserverManager");
   }
@@ -1039,7 +1038,7 @@ import { Inject as Inject11, Injectable as Injectable12, RsXCoreInjectionTokens
 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";
+import { KeyedInstanceFactory as KeyedInstanceFactory3 } from "@rs-x/core";
 var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
   static {
     __name(this, "IndexChangeSubscriptionsForContextManager");
@@ -1081,7 +1080,7 @@ var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsFo
     return observer;
   }
 };
-var IndexChangeSubscriptionManager = class extends SingletonFactory3 {
+var IndexChangeSubscriptionManager = class extends KeyedInstanceFactory3 {
   static {
     __name(this, "IndexChangeSubscriptionManager");
   }
@@ -1240,7 +1239,7 @@ CollectionItemObserverProxyPairFactory = _ts_decorate12([
   _ts_param12(2, Inject11(RsXCoreInjectionTokens8.IErrorLog)),
   _ts_param12(3, Inject11(RsXCoreInjectionTokens8.IGuidFactory)),
   _ts_param12(4, Inject11(RsXCoreInjectionTokens8.IIndexValueAccessor)),
-  _ts_param12(5, Inject11(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param12(5, Inject11(RsXCoreInjectionTokens8.IProxyRegistry)),
   _ts_param12(6, Inject11(RsXCoreInjectionTokens8.IValueMetadata)),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
@@ -1255,7 +1254,7 @@ CollectionItemObserverProxyPairFactory = _ts_decorate12([
 ], CollectionItemObserverProxyPairFactory);
 
 // lib/property-observer/factories/date-property/data-property-observer-manager.ts
-import { Inject as Inject12, Injectable as Injectable13, RsXCoreInjectionTokens as RsXCoreInjectionTokens9, SingletonFactory as SingletonFactory4 } from "@rs-x/core";
+import { Inject as Inject12, Injectable as Injectable13, KeyedInstanceFactory as KeyedInstanceFactory4, RsXCoreInjectionTokens as RsXCoreInjectionTokens9 } from "@rs-x/core";
 function _ts_decorate13(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);
@@ -1306,7 +1305,7 @@ var DatePropertyObserver = class DatePropertyObserver2 extends AbstractObserver
     this._oldValue = change.newValue;
   }, "onDateChanged");
 };
-var ProperForDataObserverManager = class ProperForDataObserverManager2 extends SingletonFactory4 {
+var ProperForDataObserverManager = class ProperForDataObserverManager2 extends KeyedInstanceFactory4 {
   static {
     __name(this, "ProperForDataObserverManager");
   }
@@ -1343,7 +1342,7 @@ var ProperForDataObserverManager = class ProperForDataObserverManager2 extends S
     this.releaseObject();
   }
 };
-var DatePropertyObserverManager = class extends SingletonFactory4 {
+var DatePropertyObserverManager = class extends KeyedInstanceFactory4 {
   static {
     __name(this, "DatePropertyObserverManager");
   }
@@ -1416,7 +1415,7 @@ DatePropertyObserverProxyPairFactory = _ts_decorate14([
   _ts_param14(2, Inject13(RsXCoreInjectionTokens10.IErrorLog)),
   _ts_param14(3, Inject13(RsXCoreInjectionTokens10.IGuidFactory)),
   _ts_param14(4, Inject13(RsXCoreInjectionTokens10.IIndexValueAccessor)),
-  _ts_param14(5, Inject13(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param14(5, Inject13(RsXCoreInjectionTokens10.IProxyRegistry)),
   _ts_param14(6, Inject13(RsXCoreInjectionTokens10.IValueMetadata)),
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
@@ -1470,7 +1469,7 @@ NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate15([
   _ts_param15(2, Inject14(RsXCoreInjectionTokens11.IErrorLog)),
   _ts_param15(3, Inject14(RsXCoreInjectionTokens11.IGuidFactory)),
   _ts_param15(4, Inject14(RsXCoreInjectionTokens11.IIndexValueAccessor)),
-  _ts_param15(5, Inject14(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param15(5, Inject14(RsXCoreInjectionTokens11.IProxyRegistry)),
   _ts_param15(6, Inject14(RsXCoreInjectionTokens11.IValueMetadata)),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
@@ -1486,7 +1485,7 @@ NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate15([
 
 // lib/property-observer/factories/non-iterable-object-property/object-property-observer-manager.ts
 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";
+import { Inject as Inject15, Injectable as Injectable16, InvalidOperationException as InvalidOperationException2, KeyedInstanceFactory as KeyedInstanceFactory5, PropertyDescriptorType, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, 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);
@@ -1618,7 +1617,7 @@ var PropertObserver = class PropertObserver2 extends AbstractObserver {
     return newDescriptor;
   }
 };
-var PropertyObserverManager = class PropertyObserverManager2 extends SingletonFactory5 {
+var PropertyObserverManager = class PropertyObserverManager2 extends KeyedInstanceFactory5 {
   static {
     __name(this, "PropertyObserverManager");
   }
@@ -1647,7 +1646,7 @@ var PropertyObserverManager = class PropertyObserverManager2 extends SingletonFa
     observer.dispose();
   }
 };
-var ObjectPropertyObserverManager = class extends SingletonFactory5 {
+var ObjectPropertyObserverManager = class extends KeyedInstanceFactory5 {
   static {
     __name(this, "ObjectPropertyObserverManager");
   }
@@ -1670,7 +1669,7 @@ var ObjectPropertyObserverManager = class extends SingletonFactory5 {
 };
 ObjectPropertyObserverManager = _ts_decorate16([
   Injectable16(),
-  _ts_param16(0, Inject15(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param16(0, Inject15(RsXCoreInjectionTokens12.IProxyRegistry)),
   _ts_metadata16("design:type", Function),
   _ts_metadata16("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
@@ -1679,7 +1678,7 @@ ObjectPropertyObserverManager = _ts_decorate16([
 
 // 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";
+import { Inject as Inject16, Injectable as Injectable17, KeyedInstanceFactory as KeyedInstanceFactory6, RsXCoreInjectionTokens as RsXCoreInjectionTokens13, 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);
@@ -1834,7 +1833,7 @@ var ArrayProxy = class ArrayProxy2 extends AbstractObserver {
     }
   }
 };
-var ArrayProxyFactory = class extends SingletonFactory6 {
+var ArrayProxyFactory = class extends KeyedInstanceFactory6 {
   static {
     __name(this, "ArrayProxyFactory");
   }
@@ -1869,7 +1868,7 @@ var ArrayProxyFactory = class extends SingletonFactory6 {
 };
 ArrayProxyFactory = _ts_decorate17([
   Injectable17(),
-  _ts_param17(0, Inject16(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param17(0, Inject16(RsXCoreInjectionTokens13.IProxyRegistry)),
   _ts_metadata17("design:type", Function),
   _ts_metadata17("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
@@ -1878,7 +1877,7 @@ ArrayProxyFactory = _ts_decorate17([
 
 // lib/proxies/date-proxy/date-proxy.factory.ts
 import { Subject as Subject4 } from "rxjs";
-import { Inject as Inject17, Injectable as Injectable18, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, SingletonFactoryWithGuid as SingletonFactoryWithGuid4, Type as Type10 } from "@rs-x/core";
+import { GuidKeyedInstanceFactory as GuidKeyedInstanceFactory4, Inject as Inject17, Injectable as Injectable18, RsXCoreInjectionTokens as RsXCoreInjectionTokens14, 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);
@@ -2113,7 +2112,7 @@ var DateProxy = class DateProxy2 extends AbstractObserver {
     this.target = Type10.cast(void 0);
   }
 };
-var DateProxyFactory = class extends SingletonFactoryWithGuid4 {
+var DateProxyFactory = class extends GuidKeyedInstanceFactory4 {
   static {
     __name(this, "DateProxyFactory");
   }
@@ -2144,8 +2143,8 @@ var DateProxyFactory = class extends SingletonFactoryWithGuid4 {
 };
 DateProxyFactory = _ts_decorate18([
   Injectable18(),
-  _ts_param18(0, Inject17(RsXCoreInjectionTokens12.IGuidFactory)),
-  _ts_param18(1, Inject17(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param18(0, Inject17(RsXCoreInjectionTokens14.IGuidFactory)),
+  _ts_param18(1, Inject17(RsXCoreInjectionTokens14.IProxyRegistry)),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
@@ -2154,7 +2153,7 @@ DateProxyFactory = _ts_decorate18([
 ], DateProxyFactory);
 
 // lib/proxies/map-proxy/map-proxy.factory.ts
-import { Inject as Inject18, Injectable as Injectable19, SingletonFactory as SingletonFactory7, Type as Type11 } from "@rs-x/core";
+import { Inject as Inject18, Injectable as Injectable19, KeyedInstanceFactory as KeyedInstanceFactory7, RsXCoreInjectionTokens as RsXCoreInjectionTokens15, 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);
@@ -2245,7 +2244,7 @@ var MapProxy = class extends AbstractObserver {
     });
   }
 };
-var MapProxyFactory = class extends SingletonFactory7 {
+var MapProxyFactory = class extends KeyedInstanceFactory7 {
   static {
     __name(this, "MapProxyFactory");
   }
@@ -2279,7 +2278,7 @@ var MapProxyFactory = class extends SingletonFactory7 {
 };
 MapProxyFactory = _ts_decorate19([
   Injectable19(),
-  _ts_param19(0, Inject18(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param19(0, Inject18(RsXCoreInjectionTokens15.IProxyRegistry)),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
@@ -2288,7 +2287,7 @@ MapProxyFactory = _ts_decorate19([
 
 // lib/proxies/observable-proxy/observable-proxy.factory.ts
 import { ReplaySubject as ReplaySubject2 } from "rxjs";
-import { Inject as Inject19, Injectable as Injectable20, RsXCoreInjectionTokens as RsXCoreInjectionTokens13, SingletonFactory as SingletonFactory8 } from "@rs-x/core";
+import { Inject as Inject19, Injectable as Injectable20, KeyedInstanceFactory as KeyedInstanceFactory8, RsXCoreInjectionTokens as RsXCoreInjectionTokens16 } 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);
@@ -2343,7 +2342,7 @@ var ObservableProxy = class ObservableProxy2 extends AbstractObserver {
     });
   }, "emitObservableChange");
 };
-var ObservableProxyFactory = class extends SingletonFactory8 {
+var ObservableProxyFactory = class extends KeyedInstanceFactory8 {
   static {
     __name(this, "ObservableProxyFactory");
   }
@@ -2377,7 +2376,7 @@ var ObservableProxyFactory = class extends SingletonFactory8 {
 };
 ObservableProxyFactory = _ts_decorate20([
   Injectable20(),
-  _ts_param20(0, Inject19(RsXCoreInjectionTokens13.IObservableAccessor)),
+  _ts_param20(0, Inject19(RsXCoreInjectionTokens16.IObservableAccessor)),
   _ts_metadata20("design:type", Function),
   _ts_metadata20("design:paramtypes", [
     typeof IObservableAccessor === "undefined" ? Object : IObservableAccessor
@@ -2386,7 +2385,7 @@ ObservableProxyFactory = _ts_decorate20([
 
 // lib/proxies/promise-proxy/promise-proxy.factory.ts
 import { ReplaySubject as ReplaySubject3 } from "rxjs";
-import { Inject as Inject20, Injectable as Injectable21, RsXCoreInjectionTokens as RsXCoreInjectionTokens14, SingletonFactory as SingletonFactory9 } from "@rs-x/core";
+import { Inject as Inject20, Injectable as Injectable21, KeyedInstanceFactory as KeyedInstanceFactory9, RsXCoreInjectionTokens as RsXCoreInjectionTokens17 } 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);
@@ -2429,7 +2428,7 @@ var PromiseObserver = class PromiseObserver2 extends AbstractObserver {
     });
   }, "onValueResolved");
 };
-var PromiseProxyFactory = class extends SingletonFactory9 {
+var PromiseProxyFactory = class extends KeyedInstanceFactory9 {
   static {
     __name(this, "PromiseProxyFactory");
   }
@@ -2463,15 +2462,15 @@ var PromiseProxyFactory = class extends SingletonFactory9 {
 };
 PromiseProxyFactory = _ts_decorate21([
   Injectable21(),
-  _ts_param21(0, Inject20(RsXCoreInjectionTokens14.IPromiseAccessor)),
+  _ts_param21(0, Inject20(RsXCoreInjectionTokens17.IPromiseAccessor)),
   _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 Injectable22 } from "@rs-x/core";
+// lib/proxies/set-proxy/set-proxy.factory.ts
+import { Inject as Inject21, Injectable as Injectable22, KeyedInstanceFactory as KeyedInstanceFactory10, RsXCoreInjectionTokens as RsXCoreInjectionTokens18, Type as Type12 } 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);
@@ -2479,40 +2478,6 @@ function _ts_decorate22(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate22, "_ts_decorate");
-var ProxyRegistry = class {
-  static {
-    __name(this, "ProxyRegistry");
-  }
-  _proxies = /* @__PURE__ */ new Map();
-  getProxyTarget(proxyToFind) {
-    return Array.from(this._proxies.entries()).find(([_, proxy]) => proxy === proxyToFind)?.[0];
-  }
-  getProxy(proxyTarget) {
-    return this._proxies.get(proxyTarget);
-  }
-  register(proxyTarget, proxy) {
-    this._proxies.set(proxyTarget, proxy);
-  }
-  unregister(proxyTarget) {
-    this._proxies.delete(proxyTarget);
-  }
-  isProxy(object) {
-    return !!this.getProxyTarget(object);
-  }
-};
-ProxyRegistry = _ts_decorate22([
-  Injectable22()
-], ProxyRegistry);
-
-// lib/proxies/set-proxy/set-proxy.factory.ts
-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_decorate23, "_ts_decorate");
 function _ts_metadata22(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -2584,7 +2549,7 @@ var SetProxy = class extends AbstractObserver {
     });
   }
 };
-var SetProxyFactory = class extends SingletonFactory10 {
+var SetProxyFactory = class extends KeyedInstanceFactory10 {
   static {
     __name(this, "SetProxyFactory");
   }
@@ -2616,9 +2581,9 @@ var SetProxyFactory = class extends SingletonFactory10 {
     setObserverWithProxy.observer.dispose();
   }
 };
-SetProxyFactory = _ts_decorate23([
-  Injectable23(),
-  _ts_param22(0, Inject21(RsXStateManagerInjectionTokens.IProxyRegistry)),
+SetProxyFactory = _ts_decorate22([
+  Injectable22(),
+  _ts_param22(0, Inject21(RsXCoreInjectionTokens18.IProxyRegistry)),
   _ts_metadata22("design:type", Function),
   _ts_metadata22("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
@@ -2629,14 +2594,14 @@ SetProxyFactory = _ts_decorate23([
 import { ContainerModule, InjectionContainer, registerMultiInjectServices, RsXCoreModule } from "@rs-x/core";
 
 // lib/state-manager/object-state-manager.ts
-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) {
+import { Inject as Inject22, Injectable as Injectable23, KeyedInstanceFactory as KeyedInstanceFactory11, RsXCoreInjectionTokens as RsXCoreInjectionTokens19, UnsupportedException as UnsupportedException2 } 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");
+__name(_ts_decorate23, "_ts_decorate");
 function _ts_metadata23(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -2647,7 +2612,7 @@ function _ts_param23(paramIndex, decorator) {
   };
 }
 __name(_ts_param23, "_ts_param");
-var StateForObjectManager = class extends SingletonFactory11 {
+var StateForObjectManager = class extends KeyedInstanceFactory11 {
   static {
     __name(this, "StateForObjectManager");
   }
@@ -2659,16 +2624,19 @@ var StateForObjectManager = class extends SingletonFactory11 {
   getId(data) {
     return data.key;
   }
-  set(key, value, watched) {
+  set(key, value, watched, ownerId) {
     const state = this.getFromId(key);
     if (state) {
       state.valueCopy = this.deepClone(key, value);
       state.value = value;
+      state.watched = watched;
+      state.ownerId = ownerId;
     } else {
       this.create({
         key,
         value,
-        watched
+        watched,
+        ownerId
       });
     }
   }
@@ -2676,6 +2644,9 @@ var StateForObjectManager = class extends SingletonFactory11 {
     return data.key;
   }
   deepClone(key, data) {
+    if (data === null || typeof data !== "object" && typeof data !== "function") {
+      return data;
+    }
     try {
       return this._deepClone.clone(data);
     } catch (e) {
@@ -2686,14 +2657,15 @@ var StateForObjectManager = class extends SingletonFactory11 {
     return {
       value: data.value,
       valueCopy: this.deepClone(data.key, data.value),
-      watched: data.watched
+      watched: data.watched,
+      ownerId: data.ownerId
     };
   }
   onReleased() {
     this.releaseContext();
   }
 };
-var ObjectStateManager = class extends SingletonFactory11 {
+var ObjectStateManager = class extends KeyedInstanceFactory11 {
   static {
     __name(this, "ObjectStateManager");
   }
@@ -2707,7 +2679,7 @@ var ObjectStateManager = class extends SingletonFactory11 {
   isRegistered(context, key) {
     return !!this.getFromId(context)?.has(key);
   }
-  replaceState(key, newContext, newValue, oldContext, watched) {
+  replaceState(key, newContext, newValue, oldContext, watched, ownerId) {
     let stateForObjectManagerForNewContext;
     const stateForObjectManagerForOldContext = this.getFromId(oldContext);
     if (newValue === void 0) {
@@ -2721,12 +2693,13 @@ var ObjectStateManager = class extends SingletonFactory11 {
       stateForObjectManagerForNewContext = stateForObjectManagerForOldContext;
     }
     if (stateForObjectManagerForNewContext) {
-      stateForObjectManagerForNewContext.set(key, newValue, watched);
+      stateForObjectManagerForNewContext.set(key, newValue, watched, ownerId);
     } else if (newValue !== void 0) {
       this.create(newContext).instance.create({
         key,
         value: newValue,
-        watched
+        watched,
+        ownerId
       });
     }
   }
@@ -2737,9 +2710,9 @@ var ObjectStateManager = class extends SingletonFactory11 {
     return new StateForObjectManager(this._deepClone, () => this.release(context));
   }
 };
-ObjectStateManager = _ts_decorate24([
-  Injectable24(),
-  _ts_param23(0, Inject22(RsXCoreInjectionTokens15.IDeepClone)),
+ObjectStateManager = _ts_decorate23([
+  Injectable23(),
+  _ts_param23(0, Inject22(RsXCoreInjectionTokens19.IDeepClone)),
   _ts_metadata23("design:type", Function),
   _ts_metadata23("design:paramtypes", [
     typeof IDeepClone === "undefined" ? Object : IDeepClone
@@ -2748,10 +2721,10 @@ ObjectStateManager = _ts_decorate24([
 
 // lib/state-manager/state-manager.ts
 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";
+import { Assertion, Inject as Inject23, Injectable as Injectable24, PENDING, RsXCoreInjectionTokens as RsXCoreInjectionTokens20, truePredicate as truePredicate6 } from "@rs-x/core";
 
 // lib/state-manager/state-change-subscription-manager/state-change-subsription-manager.ts
-import { SingletonFactory as SingletonFactory12 } from "@rs-x/core";
+import { KeyedInstanceFactory as KeyedInstanceFactory12 } from "@rs-x/core";
 var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
   static {
     __name(this, "StateChangeSubscriptionsForContextManager");
@@ -2782,7 +2755,7 @@ var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsFo
     };
   }
 };
-var StateChangeSubscriptionManager = class extends SingletonFactory12 {
+var StateChangeSubscriptionManager = class extends KeyedInstanceFactory12 {
   static {
     __name(this, "StateChangeSubscriptionManager");
   }
@@ -2818,13 +2791,13 @@ var StateChangeSubscriptionManager = class extends SingletonFactory12 {
 };
 
 // lib/state-manager/state-manager.ts
-function _ts_decorate25(decorators, target, key, desc) {
+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");
+__name(_ts_decorate24, "_ts_decorate");
 function _ts_metadata24(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -2848,6 +2821,8 @@ var StateManager = class {
   _endChangeCycle = new Subject5();
   _stateChangeSubscriptionManager;
   _pending = /* @__PURE__ */ new Map();
+  _stateEventSubscriptionsByContext = /* @__PURE__ */ new Map();
+  _stateEventSubscriptionPool = [];
   constructor(objectObserverManager, _objectStateManager, errorLog, guidFactory, _indexValueAccessor, _equalityService) {
     this._objectStateManager = _objectStateManager;
     this._indexValueAccessor = _indexValueAccessor;
@@ -2883,15 +2858,22 @@ var StateManager = class {
     });
     return id ? stateChangeSubscriptionsForContextManager.has(id) : false;
   }
-  watchState(context, index, indexWatchRule) {
-    if (!this.isWatched(context, index, indexWatchRule)) {
+  watchState(context, index, options) {
+    if (!this.isWatched(context, index, options?.indexWatchRule)) {
       const value = this.getState(context, index);
-      this.tryToSubscribeToChange(context, index, indexWatchRule);
+      this.tryToSubscribeToChange(context, index, options?.ownerId, options?.indexWatchRule);
       return value;
     } else {
-      return this.increaseStateReferenceCount(context, index, true);
+      return this.increaseStateReferenceCount(context, index, true, options?.ownerId);
     }
   }
+  subscribeStateEvents(context, index, listener) {
+    const subscription = this.acquireStateEventSubscription(context, index, listener);
+    this.addStateEventSubscription(context, index, subscription);
+    return () => {
+      this.removeStateEventSubscription(subscription.context, subscription.index, subscription);
+    };
+  }
   releaseState(context, index, indexWatchRule) {
     if (!this._objectStateManager.getFromId(context)?.has(index)) {
       return;
@@ -2901,20 +2883,32 @@ var StateManager = class {
   clear() {
     this._stateChangeSubscriptionManager.dispose();
     this._objectStateManager.dispose();
+    this._stateEventSubscriptionsByContext.clear();
+    this._stateEventSubscriptionPool.length = 0;
   }
   getState(context, index) {
     return this._objectStateManager.getFromId(context)?.getFromId(index)?.value;
   }
-  setState(context, index, value) {
-    this.internalSetState(context, index, value, {
-      context,
-      value: this.getState(context, index),
-      shouldEmitChange: truePredicate6
-    });
+  setState(context, index, value, ownerId) {
+    const isExternalSetState = ownerId === void 0;
+    if (isExternalSetState) {
+      this._startChangeCycle.next();
+    }
+    try {
+      this.internalSetState(context, index, value, {
+        context,
+        value: this.getState(context, index),
+        shouldEmitChange: truePredicate6
+      }, ownerId);
+    } finally {
+      if (isExternalSetState) {
+        this._endChangeCycle.next();
+      }
+    }
   }
-  internalSetState(context, index, value, transferValue) {
-    this.tryRebindingNestedState(value, transferValue.value);
-    this._objectStateManager.replaceState(index, context, value, transferValue.context, false);
+  internalSetState(context, index, value, transferValue, ownerId) {
+    this.tryRebindingNestedState(value, transferValue.value, ownerId);
+    this._objectStateManager.replaceState(index, context, value, transferValue.context, false, ownerId);
     if (!transferValue?.shouldEmitChange || transferValue.shouldEmitChange(context, index)) {
       this.emitChange(context, index, value, transferValue.value, transferValue.context);
     }
@@ -2939,40 +2933,50 @@ var StateManager = class {
     }
   }
   emitChange(context, index, newValue, oldValue, oldContext) {
-    if (this._equalityService.isEqual(newValue, oldValue)) {
+    if (newValue === oldValue || newValue !== newValue && oldValue !== oldValue) {
       return;
     }
-    this._changed.next({
+    const newValueIsObjectLike = newValue !== null && (typeof newValue === "object" || typeof newValue === "function");
+    const oldValueIsObjectLike = oldValue !== null && (typeof oldValue === "object" || typeof oldValue === "function");
+    if ((newValueIsObjectLike || oldValueIsObjectLike) && this._equalityService.isEqual(newValue, oldValue)) {
+      return;
+    }
+    const stateChange = {
       oldContext: oldContext ?? context,
       context,
       index,
       oldValue,
       newValue
-    });
+    };
+    this.emitStateChangeEvents(stateChange);
+    if (this.shouldPublish(this._changed)) {
+      this._changed.next(stateChange);
+    }
   }
-  updateState(newContext, oldContext, index, newValue, watched) {
-    this._objectStateManager.replaceState(index, newContext, newValue, oldContext, watched);
+  updateState(newContext, oldContext, index, newValue, watched, ownerId) {
+    this._objectStateManager.replaceState(index, newContext, newValue, oldContext, watched, ownerId);
   }
   canReleaseState(context, key) {
     return this._objectStateManager.getFromId(context)?.release(key).referenceCount === 0;
   }
-  increaseStateReferenceCount(context, index, watched) {
+  increaseStateReferenceCount(context, index, watched, ownerId) {
     const state = this.getState(context, index);
     this._objectStateManager.create(context).instance.create({
       value: state,
       key: index,
-      watched
+      watched,
+      ownerId
     });
     return state;
   }
-  tryToSubscribeToChange(context, index, indexWatchRule, transferedValue) {
+  tryToSubscribeToChange(context, index, ownerId, indexWatchRule, transferedValue) {
     this._stateChangeSubscriptionManager.create(context).instance.create({
       index,
       indexWatchRule,
-      onChanged: /* @__PURE__ */ __name((change) => this.onChange(change, true), "onChanged"),
+      onChanged: /* @__PURE__ */ __name((change) => this.onChange(change, true, ownerId), "onChanged"),
       init: /* @__PURE__ */ __name((observer) => {
         if (observer.value !== void 0) {
-          this.setInitialValue(context, index, observer.value, transferedValue, true);
+          this.setInitialValue(context, index, observer.value, transferedValue, true, ownerId);
         }
         observer.init();
       }, "init")
@@ -2985,65 +2989,91 @@ var StateManager = class {
       return this.getState(context, key);
     }
   }
-  getStateChanges(oldContext, newContext) {
+  getStateChanges(oldContext, newContext, parentOwnerId) {
     const oldState = this._objectStateManager.getFromId(oldContext);
     if (!oldState) {
       return [];
     }
-    return Array.from(oldState.ids()).map((index) => {
-      const { value: oldValue, watched } = oldState.getFromId(index) ?? {};
+    const stateChanges = [];
+    this.collectStateChanges(oldContext, newContext, parentOwnerId, oldState, stateChanges);
+    return stateChanges;
+  }
+  collectStateChanges(oldContext, newContext, parentOwnerId, oldState, changes) {
+    if (!oldState) {
+      return;
+    }
+    for (const index of oldState.ids()) {
+      const state = oldState.getFromId(index);
+      if (!state) {
+        continue;
+      }
+      const { value: oldValue, watched, ownerId } = state;
+      if (ownerId !== parentOwnerId) {
+        continue;
+      }
       const newValue = this.getValue(newContext, index);
-      if (oldContext === newContext && this._equalityService.isEqual(oldValue, newValue)) {
-        return [];
+      if (oldContext === newContext) {
+        if (oldValue === newValue || oldValue !== oldValue && newValue !== newValue) {
+          continue;
+        }
+        const newValueIsObjectLike = newValue !== null && (typeof newValue === "object" || typeof newValue === "function");
+        const oldValueIsObjectLike = oldValue !== null && (typeof oldValue === "object" || typeof oldValue === "function");
+        if ((newValueIsObjectLike || oldValueIsObjectLike) && this._equalityService.isEqual(oldValue, newValue)) {
+          continue;
+        }
       }
       if (newValue === PENDING) {
         this._pending.set(newContext, oldValue);
       }
-      const stateInfo = {
+      changes.push({
         oldContext,
         context: newContext,
         index,
         oldValue,
         newValue,
         watched
-      };
-      return newValue === PENDING ? [
-        stateInfo
-      ] : [
-        stateInfo,
-        ...this.getStateChanges(oldValue, newValue)
-      ];
-    }).reduce((a, b) => a.concat(b), []);
-  }
-  tryRebindingNestedState(newValue, oldValue) {
-    const stateChanges = this.getStateChanges(oldValue, newValue);
+      });
+      if (newValue === PENDING) {
+        continue;
+      }
+      this.collectStateChanges(oldValue, newValue, ownerId, this._objectStateManager.getFromId(oldValue), changes);
+    }
+  }
+  tryRebindingNestedState(newValue, oldValue, ownerId) {
+    const stateChanges = this.getStateChanges(oldValue, newValue, ownerId);
     if (stateChanges.length === 0) {
       return;
     }
-    const emitted = [];
+    const emittedByContext = /* @__PURE__ */ new Map();
     const shouldEmitChange = /* @__PURE__ */ __name((context, index) => {
-      if (emitted.some(([c, i]) => c === context && i === index)) {
+      let emittedIndexes = emittedByContext.get(context);
+      if (!emittedIndexes) {
+        emittedIndexes = /* @__PURE__ */ new Set();
+        emittedByContext.set(context, emittedIndexes);
+      }
+      if (emittedIndexes.has(index)) {
         return false;
       }
-      emitted.push([
-        context,
-        index
-      ]);
+      emittedIndexes.add(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({
+      const contextChange = {
         context: stateChange.context,
         oldContext: stateChange.oldContext,
         index: stateChange.index
-      });
+      };
+      this.emitContextChangedEvents(contextChange);
+      if (this.shouldPublish(this._contextChanged)) {
+        this._contextChanged.next(contextChange);
+      }
       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
-        });
+        }, ownerId);
         continue;
       }
       const instanceGroupInfos = this._stateChangeSubscriptionManager.instanceGroupInfoEntriesForContext(stateChange.oldContext);
@@ -3058,36 +3088,159 @@ var StateManager = class {
         if (indexWatchRule) {
           indexWatchRule.context = stateChange.context;
         }
-        this.tryToSubscribeToChange(stateChange.context, stateChange.index, indexWatchRule, rebindingOptions);
+        this.tryToSubscribeToChange(stateChange.context, stateChange.index, ownerId, indexWatchRule, rebindingOptions);
       }
     }
   }
-  setInitialValue(context, index, initialValue, transferedValue, watched) {
-    this.updateState(context, transferedValue?.context ?? context, index, initialValue, watched);
+  addStateEventSubscription(context, index, subscription) {
+    let subscriptionsByIndex = this._stateEventSubscriptionsByContext.get(context);
+    if (!subscriptionsByIndex) {
+      subscriptionsByIndex = /* @__PURE__ */ new Map();
+      this._stateEventSubscriptionsByContext.set(context, subscriptionsByIndex);
+    }
+    let subscriptions = subscriptionsByIndex.get(index);
+    if (!subscriptions) {
+      subscriptions = /* @__PURE__ */ new Set();
+      subscriptionsByIndex.set(index, subscriptions);
+    }
+    subscriptions.add(subscription);
+  }
+  removeStateEventSubscription(context, index, subscription, releaseToPool = true) {
+    if (!subscription.active) {
+      return;
+    }
+    const subscriptionsByIndex = this._stateEventSubscriptionsByContext.get(context);
+    if (!subscriptionsByIndex) {
+      if (releaseToPool) {
+        this.releaseStateEventSubscription(subscription);
+      }
+      return;
+    }
+    const subscriptions = subscriptionsByIndex.get(index);
+    if (!subscriptions) {
+      if (releaseToPool) {
+        this.releaseStateEventSubscription(subscription);
+      }
+      return;
+    }
+    subscriptions.delete(subscription);
+    if (subscriptions.size === 0) {
+      subscriptionsByIndex.delete(index);
+    }
+    if (subscriptionsByIndex.size === 0) {
+      this._stateEventSubscriptionsByContext.delete(context);
+    }
+    if (releaseToPool) {
+      this.releaseStateEventSubscription(subscription);
+    }
+  }
+  emitStateChangeEvents(change) {
+    const subscriptions = this._stateEventSubscriptionsByContext.get(change.context)?.get(change.index);
+    if (!subscriptions || subscriptions.size === 0) {
+      return;
+    }
+    for (const subscription of subscriptions) {
+      subscription.listener.onStateChange(change);
+    }
+  }
+  emitContextChangedEvents(change) {
+    const subscriptions = this._stateEventSubscriptionsByContext.get(change.oldContext)?.get(change.index);
+    if (!subscriptions || subscriptions.size === 0) {
+      return;
+    }
+    while (subscriptions.size > 0) {
+      const subscriptionIterator = subscriptions.values().next();
+      if (subscriptionIterator.done) {
+        break;
+      }
+      const subscription = subscriptionIterator.value;
+      this.removeStateEventSubscription(subscription.context, subscription.index, subscription, false);
+      subscription.context = change.context;
+      this.addStateEventSubscription(subscription.context, subscription.index, subscription);
+      subscription.listener.onContextChanged(change);
+    }
+  }
+  shouldPublish(subject) {
+    return subject.observed === void 0 || subject.observed;
+  }
+  acquireStateEventSubscription(context, index, listener) {
+    const subscription = this._stateEventSubscriptionPool.pop() ?? {
+      active: true,
+      context,
+      index,
+      listener
+    };
+    subscription.active = true;
+    subscription.context = context;
+    subscription.index = index;
+    subscription.listener = listener;
+    return subscription;
+  }
+  releaseStateEventSubscription(subscription) {
+    if (!subscription.active) {
+      return;
+    }
+    subscription.active = false;
+    this._stateEventSubscriptionPool.push(subscription);
+  }
+  setInitialValue(context, index, initialValue, transferedValue, watched, ownerId) {
+    this.updateState(context, transferedValue?.context ?? context, index, initialValue, watched, ownerId);
     if (!transferedValue?.shouldEmitChange || transferedValue.shouldEmitChange(context, index)) {
       this.emitChange(context, index, initialValue, transferedValue?.value, transferedValue?.context);
     }
   }
   getChainChanges(chain) {
-    if (!chain) {
+    if (!chain || chain.length === 0) {
       return [];
     }
-    const registeredChainParts = chain.filter((chainPart) => this._stateChangeSubscriptionManager.isRegistered(chainPart.context, chainPart.index));
-    return registeredChainParts.map((chainPart) => ({
-      ...chainPart,
-      oldValue: this.getOldValue(chainPart.context, chainPart.index),
-      value: this.getValue(chainPart.context, chainPart.index)
-    }));
+    const chainChanges = [];
+    for (let i = 0; i < chain.length; i++) {
+      const chainPart = chain[i];
+      const { context, index } = chainPart;
+      if (!this._stateChangeSubscriptionManager.isRegistered(context, index)) {
+        continue;
+      }
+      chainChanges.push({
+        context,
+        index,
+        oldValue: this.getOldValue(context, index),
+        value: this.getValue(context, index)
+      });
+    }
+    return chainChanges;
   }
-  getCurrentValue(context, id) {
-    const value = this._pending.get(context);
-    if (value !== void 0) {
+  getCurrentValue(context, index) {
+    if (this._pending.has(context)) {
+      const value = this._pending.get(context);
       this._pending.delete(context);
       return value;
     }
-    return this.getState(context, id);
+    return this.getState(context, index);
   }
-  onChange(change, watched = false) {
+  onChange(change, watched = false, ownerId) {
+    const chain = change.chain;
+    if (!chain || chain.length === 0) {
+      return;
+    }
+    if (chain.length === 1) {
+      const chainPart = chain[0];
+      const { context, index } = chainPart;
+      if (!this._stateChangeSubscriptionManager.isRegistered(context, index)) {
+        return;
+      }
+      const value = this.getValue(context, index);
+      const oldValue = this.getOldValue(context, index);
+      this._startChangeCycle.next();
+      try {
+        const currentValue = this.getCurrentValue(context, index);
+        this.tryRebindingNestedState(change.newValue, currentValue, ownerId);
+        this.updateState(context, context, index, value, watched, ownerId);
+        this.emitChange(context, index, value, oldValue);
+      } finally {
+        this._endChangeCycle.next();
+      }
+      return;
+    }
     const chainChanges = this.getChainChanges(change.chain);
     if (chainChanges.length === 0) {
       return;
@@ -3096,22 +3249,28 @@ var StateManager = class {
     try {
       const chainLeaf = chainChanges[chainChanges.length - 1];
       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));
+      this.tryRebindingNestedState(change.newValue, currentValue, ownerId);
+      for (let i = 0; i < chainChanges.length; i++) {
+        const chainChange = chainChanges[i];
+        this.updateState(chainChange.context, chainChange.context, chainChange.index, chainChange.value, watched, ownerId);
+      }
+      for (let i = 0; i < chainChanges.length; i++) {
+        const chainChange = chainChanges[i];
+        this.emitChange(chainChange.context, chainChange.index, chainChange.value, chainChange.oldValue);
+      }
     } finally {
       this._endChangeCycle.next();
     }
   }
 };
-StateManager = _ts_decorate25([
-  Injectable25(),
+StateManager = _ts_decorate24([
+  Injectable24(),
   _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_param24(2, Inject23(RsXCoreInjectionTokens20.IErrorLog)),
+  _ts_param24(3, Inject23(RsXCoreInjectionTokens20.IGuidFactory)),
+  _ts_param24(4, Inject23(RsXCoreInjectionTokens20.IIndexValueAccessor)),
+  _ts_param24(5, Inject23(RsXCoreInjectionTokens20.IEqualityService)),
   _ts_metadata24("design:type", Function),
   _ts_metadata24("design:paramtypes", [
     typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager,
@@ -3176,7 +3335,6 @@ var RsXStateManagerModule = new ContainerModule((options) => {
   options.bind(RsXStateManagerInjectionTokens.IDateProxyFactory).to(DateProxyFactory).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IPromiseProxyFactory).to(PromiseProxyFactory).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IObservableProxyFactory).to(ObservableProxyFactory).inSingletonScope();
-  options.bind(RsXStateManagerInjectionTokens.IProxyRegistry).to(ProxyRegistry).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager).to(ObjectPropertyObserverProxyPairManager).inSingletonScope();
   registerMultiInjectServices(options, RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryList, defaultObjectObserverProxyPairFactoryList);
   registerMultiInjectServices(options, RsXStateManagerInjectionTokens.IPropertyObserverProxyPairFactoryList, defaultPropertyObserverProxyPairFactoryList);
@@ -3226,7 +3384,6 @@ export {
   PlainObjectObserverProxyPairFactory,
   PromiseObserverProxyPairFactory,
   PromiseProxyFactory,
-  ProxyRegistry,
   RsXStateManagerInjectionTokens,
   RsXStateManagerModule,
   SetObserverProxyPairFactory,