@rs-x/state-manager 1.0.2 → 2.0.0-next.1

package/dist/index.js

@@ -61,17 +61,18 @@ var AbstractObserver = class {
 };
 
 // lib/grouped-change-subscriptions-for-context-manager.ts
-import { GuidKeyedInstanceFactory } from "@rs-x/core";
-var GroupedChangeSubscriptionsForContextManager = class extends GuidKeyedInstanceFactory {
+import { GroupedKeyedInstanceFactory } from "@rs-x/core";
+var GroupedChangeSubscriptionsForContextManager = class extends GroupedKeyedInstanceFactory {
   static {
     __name(this, "GroupedChangeSubscriptionsForContextManager");
   }
   _context;
   releaseContext;
   _errorLog;
+  _nextId = 0;
   _subscriptions = /* @__PURE__ */ new Map();
-  constructor(_context, releaseContext, _errorLog, guidFactory) {
-    super(guidFactory), this._context = _context, this.releaseContext = releaseContext, this._errorLog = _errorLog;
+  constructor(_context, releaseContext, _errorLog) {
+    super(), this._context = _context, this.releaseContext = releaseContext, this._errorLog = _errorLog;
   }
   get context() {
     return this._context;
@@ -108,25 +109,142 @@ var GroupedChangeSubscriptionsForContextManager = class extends GuidKeyedInstanc
   onReleased() {
     this.releaseContext();
   }
+  createUniqueId(_data) {
+    return this._nextId++;
+  }
 };
 
-// lib/index-watch-rule-registry/index-watch-rule.ts
-import { truePredicate } from "@rs-x/core";
+// lib/index-watch-rule/index-watch-rule.ts
 var IndexWatchRule = class {
   static {
     __name(this, "IndexWatchRule");
   }
+  id;
   context;
   predicate;
-  constructor(context, predicate) {
+  constructor(id, context, predicate) {
+    this.id = id;
     this.context = context;
     this.predicate = predicate;
   }
+  dispose() {
+  }
   test(index, target) {
     return this.predicate(index, target, this.context);
   }
 };
-var watchIndexRecursiveRule = new IndexWatchRule(void 0, truePredicate);
+
+// lib/index-watch-rule/index-watch-rule.factory.ts
+import { Injectable, KeyedInstanceFactory } from "@rs-x/core";
+function _ts_decorate(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_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var IndexWatchRule2 = class IndexWatchRule3 {
+  static {
+    __name(this, "IndexWatchRule");
+  }
+  id;
+  context;
+  _owner;
+  _index;
+  _isDisposed = false;
+  constructor(id, context, _owner, _index) {
+    this.id = id;
+    this.context = context;
+    this._owner = _owner;
+    this._index = _index;
+  }
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    if (!this._owner.canDispose || this._owner.canDispose()) {
+      this._isDisposed = true;
+    }
+    this._owner.release();
+  }
+  test(index, target) {
+    return index === this._index && this.context === target;
+  }
+};
+var IndexWatchRuleFactoryForContext = class IndexWatchRuleFactoryForContext2 extends KeyedInstanceFactory {
+  static {
+    __name(this, "IndexWatchRuleFactoryForContext");
+  }
+  _context;
+  releaseContext;
+  constructor(_context, releaseContext) {
+    super(), this._context = _context, this.releaseContext = releaseContext;
+  }
+  getId(index) {
+    return this.createId(index);
+  }
+  createId(index) {
+    return index;
+  }
+  createInstance(index, id) {
+    return new IndexWatchRule2(id, this._context, {
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    }, index);
+  }
+  onReleased() {
+    if (this.isEmpty) {
+      this.releaseContext();
+    }
+  }
+};
+var IndexWatchRuleManager = class IndexWatchRuleManager2 extends KeyedInstanceFactory {
+  static {
+    __name(this, "IndexWatchRuleManager");
+  }
+  constructor() {
+    super();
+  }
+  getId(context) {
+    return context;
+  }
+  createId(context) {
+    return context;
+  }
+  createInstance(context, id) {
+    return new IndexWatchRuleFactoryForContext(context, () => this.release(id));
+  }
+};
+var IndexWatchRuleFactory = class {
+  static {
+    __name(this, "IndexWatchRuleFactory");
+  }
+  _identifierIndexWatchRuleManager;
+  constructor() {
+    this._identifierIndexWatchRuleManager = new IndexWatchRuleManager();
+  }
+  create(context, index) {
+    return this._identifierIndexWatchRuleManager.createAndGetInstance(context).createAndGetInstance(index);
+  }
+};
+IndexWatchRuleFactory = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [])
+], IndexWatchRuleFactory);
+
+// lib/index-watch-rule/watch-index-recursive-rule.ts
+import { emptyFunction, truePredicate } from "@rs-x/core";
+var watchIndexRecursiveRule = {
+  id: "b95cf4e7-b6d3-475e-af41-fb78d0d58baa",
+  context: void 0,
+  dispose: emptyFunction,
+  test: truePredicate
+};
 
 // lib/object-observer/factories/abstract-object-observer-proxy-pair.factory.ts
 import { truePredicate as truePredicate2 } from "@rs-x/core";
@@ -309,54 +427,56 @@ var AbstractObjectObserverProxyPairFactory = class {
 };
 
 // lib/object-observer/factories/array-observer-proxy-pair.factory.ts
-import { Inject, Injectable, RsXCoreInjectionTokens } from "@rs-x/core";
+import { Inject, Injectable as Injectable2, RsXCoreInjectionTokens } from "@rs-x/core";
 
 // lib/rs-x-state-manager-injection-tokens.ts
 var RsXStateManagerInjectionTokens = {
-  IArrayProxyFactory: Symbol("IArrayProxyFactory"),
-  IMapProxyFactory: Symbol("IMapProxyFactory"),
-  ISetProxyFactory: Symbol("ISetProxyFactory"),
-  IDateProxyFactory: Symbol("IDateProxyFactory"),
-  IPromiseProxyFactory: Symbol("IPromiseProxyFactory"),
-  IObservableProxyFactory: Symbol("IObservableProxyFactory"),
-  IObjectPropertyObserverProxyPairManager: Symbol("IObjectPropertyObserverProxyPairManager"),
-  IPlainObjectObserverProxyPairFactory: Symbol("IPlainObjectObserverProxyPairFactory"),
-  IDateObserverProxyPairFactory: Symbol("IDateObserverProxyPairFactory"),
-  IArrayObserverProxyPairFactory: Symbol("IArrayObserverProxyPairFactory"),
-  PromiseObserverProxyPairFactory: Symbol("PromiseObserverProxyPairFactory"),
-  ObservableObserverProxyPairFactory: Symbol("ObservableObserverProxyPairFactory"),
-  IMapObserverProxyPairFactory: Symbol("IMapObserverProxyPairFactory"),
-  ISetObserverProxyPairFactory: Symbol("ISetObserverProxyPairFactory"),
-  IDatePropertyObserverProxyPairFactory: Symbol("IDatePropertyObserverProxyPairFactory"),
-  IObjectObserverProxyPairFactoryList: Symbol("IObjectObserverProxyPairFactoryList"),
-  IObjectObserverProxyPairFactoryProvider: Symbol("IObjectObserverProxyPairFactoryProvider"),
-  IObjectObserverProxyPairManager: Symbol("IObjectObserverProxyPairManager"),
-  IObjectPropertyObserverManager: Symbol("IObjectPropertyObserverManager"),
-  ICollectionItemObserverManager: Symbol("ICollectionItemObserverManager"),
-  ISetItemObserverManager: Symbol("ISetItemObserverManager"),
-  IDatePropertyObserverManager: Symbol("IDatePropertyObserverManager"),
-  IPropertyObserverProxyPairFactoryList: Symbol("IPropertyObserverProxyPairFactoryList"),
-  NonIterableObjectPropertyObserverProxyPairFactory: Symbol("NonIterableObjectPropertyObserverProxyPairFactory"),
-  ICollectionItemObserverProxyPairFactory: Symbol("ICollectionItemObserverProxyPairFactory"),
-  IObjectStateManager: Symbol("IObjectStateManager"),
-  IPropertyObserverProxyPairFactoryProvider: Symbol("IPropertyObserverProxyPairFactoryProvider"),
-  IPropertyObserverProxyPairFactoryProviderFactory: Symbol("IPropertyObserverProxyPairFactoryProviderFactory"),
-  IObjectObserverProxyPairFactoryProviderFactory: Symbol("IObjectObserverProxyPairFactoryProviderFactory"),
-  IStateManager: Symbol("IStateManager")
+  IArrayProxyFactory: /* @__PURE__ */ Symbol("IArrayProxyFactory"),
+  IMapProxyFactory: /* @__PURE__ */ Symbol("IMapProxyFactory"),
+  ISetProxyFactory: /* @__PURE__ */ Symbol("ISetProxyFactory"),
+  IDateProxyFactory: /* @__PURE__ */ Symbol("IDateProxyFactory"),
+  IPromiseProxyFactory: /* @__PURE__ */ Symbol("IPromiseProxyFactory"),
+  IObservableProxyFactory: /* @__PURE__ */ Symbol("IObservableProxyFactory"),
+  IObjectPropertyObserverProxyPairManager: /* @__PURE__ */ Symbol("IObjectPropertyObserverProxyPairManager"),
+  IPlainObjectObserverProxyPairFactory: /* @__PURE__ */ Symbol("IPlainObjectObserverProxyPairFactory"),
+  IDateObserverProxyPairFactory: /* @__PURE__ */ Symbol("IDateObserverProxyPairFactory"),
+  IArrayObserverProxyPairFactory: /* @__PURE__ */ Symbol("IArrayObserverProxyPairFactory"),
+  PromiseObserverProxyPairFactory: /* @__PURE__ */ Symbol("PromiseObserverProxyPairFactory"),
+  ObservableObserverProxyPairFactory: /* @__PURE__ */ Symbol("ObservableObserverProxyPairFactory"),
+  IMapObserverProxyPairFactory: /* @__PURE__ */ Symbol("IMapObserverProxyPairFactory"),
+  ISetObserverProxyPairFactory: /* @__PURE__ */ Symbol("ISetObserverProxyPairFactory"),
+  IDatePropertyObserverProxyPairFactory: /* @__PURE__ */ Symbol("IDatePropertyObserverProxyPairFactory"),
+  IObjectObserverProxyPairFactoryList: /* @__PURE__ */ Symbol("IObjectObserverProxyPairFactoryList"),
+  IObjectObserverProxyPairFactoryProvider: /* @__PURE__ */ Symbol("IObjectObserverProxyPairFactoryProvider"),
+  IObjectObserverProxyPairManager: /* @__PURE__ */ Symbol("IObjectObserverProxyPairManager"),
+  IObjectPropertyObserverManager: /* @__PURE__ */ Symbol("IObjectPropertyObserverManager"),
+  ICollectionItemObserverManager: /* @__PURE__ */ Symbol("ICollectionItemObserverManager"),
+  ISetItemObserverManager: /* @__PURE__ */ Symbol("ISetItemObserverManager"),
+  IDatePropertyObserverManager: /* @__PURE__ */ Symbol("IDatePropertyObserverManager"),
+  IPropertyObserverProxyPairFactoryList: /* @__PURE__ */ Symbol("IPropertyObserverProxyPairFactoryList"),
+  NonIterableObjectPropertyObserverProxyPairFactory: /* @__PURE__ */ Symbol("NonIterableObjectPropertyObserverProxyPairFactory"),
+  ICollectionItemObserverProxyPairFactory: /* @__PURE__ */ Symbol("ICollectionItemObserverProxyPairFactory"),
+  IObjectStateManager: /* @__PURE__ */ Symbol("IObjectStateManager"),
+  IPropertyObserverProxyPairFactoryProvider: /* @__PURE__ */ Symbol("IPropertyObserverProxyPairFactoryProvider"),
+  IPropertyObserverProxyPairFactoryProviderFactory: /* @__PURE__ */ Symbol("IPropertyObserverProxyPairFactoryProviderFactory"),
+  IObjectObserverProxyPairFactoryProviderFactory: /* @__PURE__ */ Symbol("IObjectObserverProxyPairFactoryProviderFactory"),
+  IStateManager: /* @__PURE__ */ Symbol("IStateManager"),
+  IWatchFactory: /* @__PURE__ */ Symbol("IWatchFactory"),
+  IIndexWatchRuleFactory: /* @__PURE__ */ Symbol("IIndexWatchRuleFactory")
 };
 
 // lib/object-observer/factories/array-observer-proxy-pair.factory.ts
-function _ts_decorate(decorators, target, key, desc) {
+function _ts_decorate2(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_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata, "_ts_metadata");
+__name(_ts_metadata2, "_ts_metadata");
 function _ts_param(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -380,14 +500,14 @@ var ArrayObserverProxyPairFactory = class extends AbstractObjectObserverProxyPai
     }).instance;
   }
 };
-ArrayObserverProxyPairFactory = _ts_decorate([
-  Injectable(),
+ArrayObserverProxyPairFactory = _ts_decorate2([
+  Injectable2(),
   _ts_param(0, Inject(RsXStateManagerInjectionTokens.IArrayProxyFactory)),
   _ts_param(1, Inject(RsXCoreInjectionTokens.IErrorLog)),
   _ts_param(2, Inject(RsXCoreInjectionTokens.IArrayIndexAccessor)),
   _ts_param(3, Inject(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof IArrayProxyFactory === "undefined" ? Object : IArrayProxyFactory,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IArrayIndexAccessor === "undefined" ? Object : IArrayIndexAccessor,
@@ -396,18 +516,18 @@ ArrayObserverProxyPairFactory = _ts_decorate([
 ], ArrayObserverProxyPairFactory);
 
 // lib/object-observer/factories/date-observer-proxy-pair.factory.ts
-import { Inject as Inject2, Injectable as Injectable2 } from "@rs-x/core";
-function _ts_decorate2(decorators, target, key, desc) {
+import { Inject as Inject2, Injectable as Injectable3 } from "@rs-x/core";
+function _ts_decorate3(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_decorate2, "_ts_decorate");
-function _ts_metadata2(k, v) {
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata2, "_ts_metadata");
+__name(_ts_metadata3, "_ts_metadata");
 function _ts_param2(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -433,28 +553,28 @@ var DateObserverProxyPairFactory = class {
     return object instanceof Date;
   }
 };
-DateObserverProxyPairFactory = _ts_decorate2([
-  Injectable2(),
+DateObserverProxyPairFactory = _ts_decorate3([
+  Injectable3(),
   _ts_param2(0, Inject2(RsXStateManagerInjectionTokens.IDateProxyFactory)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof IDateProxyFactory === "undefined" ? Object : IDateProxyFactory
   ])
 ], DateObserverProxyPairFactory);
 
 // lib/object-observer/factories/map-observer-proxy-pair.factory.ts
-import { Inject as Inject3, Injectable as Injectable3, RsXCoreInjectionTokens as RsXCoreInjectionTokens2 } from "@rs-x/core";
-function _ts_decorate3(decorators, target, key, desc) {
+import { Inject as Inject3, Injectable as Injectable4, RsXCoreInjectionTokens as RsXCoreInjectionTokens2 } 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);
   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_decorate3, "_ts_decorate");
-function _ts_metadata3(k, v) {
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata3, "_ts_metadata");
+__name(_ts_metadata4, "_ts_metadata");
 function _ts_param3(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -478,14 +598,14 @@ var MapObserverProxyPairFactory = class extends AbstractObjectObserverProxyPairF
     }).instance;
   }
 };
-MapObserverProxyPairFactory = _ts_decorate3([
-  Injectable3(),
+MapObserverProxyPairFactory = _ts_decorate4([
+  Injectable4(),
   _ts_param3(0, Inject3(RsXStateManagerInjectionTokens.IMapProxyFactory)),
   _ts_param3(1, Inject3(RsXCoreInjectionTokens2.IErrorLog)),
   _ts_param3(2, Inject3(RsXCoreInjectionTokens2.IMapKeyAccessor)),
   _ts_param3(3, Inject3(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     typeof IMapProxyFactory === "undefined" ? Object : IMapProxyFactory,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IMapKeyAccessor === "undefined" ? Object : IMapKeyAccessor,
@@ -495,18 +615,18 @@ MapObserverProxyPairFactory = _ts_decorate3([
 
 // lib/object-observer/factories/observable-observer-proxy-pair.factory.ts
 import { isObservable } from "rxjs";
-import { Inject as Inject4, Injectable as Injectable4 } from "@rs-x/core";
-function _ts_decorate4(decorators, target, key, desc) {
+import { Inject as Inject4, Injectable as Injectable5 } 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);
   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_decorate4, "_ts_decorate");
-function _ts_metadata4(k, v) {
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata4, "_ts_metadata");
+__name(_ts_metadata5, "_ts_metadata");
 function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -532,28 +652,28 @@ var ObservableObserverProxyPairFactory = class {
     return isObservable(object);
   }
 };
-ObservableObserverProxyPairFactory = _ts_decorate4([
-  Injectable4(),
+ObservableObserverProxyPairFactory = _ts_decorate5([
+  Injectable5(),
   _ts_param4(0, Inject4(RsXStateManagerInjectionTokens.IObservableProxyFactory)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     typeof IObservableProxyFactory === "undefined" ? Object : IObservableProxyFactory
   ])
 ], ObservableObserverProxyPairFactory);
 
 // lib/object-observer/factories/plain-object-observer-proxy-pair.factory.ts
-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) {
+import { Inject as Inject5, Injectable as Injectable6, RsXCoreInjectionTokens as RsXCoreInjectionTokens3, truePredicate as truePredicate3, Type as Type3 } from "@rs-x/core";
+function _ts_decorate6(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_decorate5, "_ts_decorate");
-function _ts_metadata5(k, v) {
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata5, "_ts_metadata");
+__name(_ts_metadata6, "_ts_metadata");
 function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -595,13 +715,13 @@ var PlainObjectObserverProxyPairFactory = class extends AbstractObjectObserverPr
     };
   }
 };
-PlainObjectObserverProxyPairFactory = _ts_decorate5([
-  Injectable5(),
+PlainObjectObserverProxyPairFactory = _ts_decorate6([
+  Injectable6(),
   _ts_param5(0, Inject5(RsXCoreInjectionTokens3.IErrorLog)),
   _ts_param5(1, Inject5(RsXCoreInjectionTokens3.IPropertyValueAccessor)),
   _ts_param5(2, Inject5(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IPropertyValueAccessor === "undefined" ? Object : IPropertyValueAccessor,
     typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager
@@ -609,18 +729,18 @@ PlainObjectObserverProxyPairFactory = _ts_decorate5([
 ], PlainObjectObserverProxyPairFactory);
 
 // lib/object-observer/factories/promise-observer-proxy-pair.factory.ts
-import { Inject as Inject6, Injectable as Injectable6 } from "@rs-x/core";
-function _ts_decorate6(decorators, target, key, desc) {
+import { Inject as Inject6, Injectable as Injectable7 } from "@rs-x/core";
+function _ts_decorate7(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_decorate6, "_ts_decorate");
-function _ts_metadata6(k, v) {
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata7(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata6, "_ts_metadata");
+__name(_ts_metadata7, "_ts_metadata");
 function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -646,28 +766,28 @@ var PromiseObserverProxyPairFactory = class {
     return object instanceof Promise;
   }
 };
-PromiseObserverProxyPairFactory = _ts_decorate6([
-  Injectable6(),
+PromiseObserverProxyPairFactory = _ts_decorate7([
+  Injectable7(),
   _ts_param6(0, Inject6(RsXStateManagerInjectionTokens.IPromiseProxyFactory)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     typeof IPromiseProxyFactory === "undefined" ? Object : IPromiseProxyFactory
   ])
 ], PromiseObserverProxyPairFactory);
 
 // lib/object-observer/factories/set-observer-proxy-pair.factory.ts
-import { Inject as Inject7, Injectable as Injectable7, RsXCoreInjectionTokens as RsXCoreInjectionTokens4 } from "@rs-x/core";
-function _ts_decorate7(decorators, target, key, desc) {
+import { Inject as Inject7, Injectable as Injectable8, RsXCoreInjectionTokens as RsXCoreInjectionTokens4 } from "@rs-x/core";
+function _ts_decorate8(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_decorate7, "_ts_decorate");
-function _ts_metadata7(k, v) {
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata8(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata7, "_ts_metadata");
+__name(_ts_metadata8, "_ts_metadata");
 function _ts_param7(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -691,14 +811,14 @@ var SetObserverProxyPairFactory = class extends AbstractObjectObserverProxyPairF
     }).instance;
   }
 };
-SetObserverProxyPairFactory = _ts_decorate7([
-  Injectable7(),
+SetObserverProxyPairFactory = _ts_decorate8([
+  Injectable8(),
   _ts_param7(0, Inject7(RsXStateManagerInjectionTokens.ISetProxyFactory)),
   _ts_param7(1, Inject7(RsXCoreInjectionTokens4.IErrorLog)),
   _ts_param7(2, Inject7(RsXCoreInjectionTokens4.ISetKeyAccessor)),
   _ts_param7(3, Inject7(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
     typeof ISetProxyFactory === "undefined" ? Object : ISetProxyFactory,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof ISetKeyAccessor === "undefined" ? Object : ISetKeyAccessor,
@@ -707,18 +827,18 @@ SetObserverProxyPairFactory = _ts_decorate7([
 ], SetObserverProxyPairFactory);
 
 // lib/object-observer/object-observer-proxy-pair-factory.provider.ts
-import { Injectable as Injectable8, MultiInject } from "@rs-x/core";
-function _ts_decorate8(decorators, target, key, desc) {
+import { Injectable as Injectable9, MultiInject } 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);
   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_decorate8, "_ts_decorate");
-function _ts_metadata8(k, v) {
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata9(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
+__name(_ts_metadata9, "_ts_metadata");
 function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -736,42 +856,43 @@ var ObjectObserverProxyPairFactoryProvider = class {
     ].sort((a, b) => b.priority - a.priority);
   }
 };
-ObjectObserverProxyPairFactoryProvider = _ts_decorate8([
-  Injectable8(),
+ObjectObserverProxyPairFactoryProvider = _ts_decorate9([
+  Injectable9(),
   _ts_param8(0, MultiInject(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryList)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
     Object
   ])
 ], ObjectObserverProxyPairFactoryProvider);
 
 // lib/object-observer/object-observer-proxy-pair-manager.ts
-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) {
+import { GroupedKeyedInstanceFactory as GroupedKeyedInstanceFactory2, Inject as Inject8, Injectable as Injectable10, InvalidOperationException, RsXCoreInjectionTokens as RsXCoreInjectionTokens5, Type as Type4 } 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);
   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_decorate9, "_ts_decorate");
-function _ts_metadata9(k, v) {
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata9, "_ts_metadata");
+__name(_ts_metadata10, "_ts_metadata");
 function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param9, "_ts_param");
-var ObjectObserverProxyPairManager = class extends GuidKeyedInstanceFactory2 {
+var ObjectObserverProxyPairManager = class extends GroupedKeyedInstanceFactory2 {
   static {
     __name(this, "ObjectObserverProxyPairManager");
   }
   getObserverFactoryProvider;
   _proxyRegistry;
-  constructor(getObserverFactoryProvider, _proxyRegistry, guidFactory) {
-    super(guidFactory), this.getObserverFactoryProvider = getObserverFactoryProvider, this._proxyRegistry = _proxyRegistry;
+  _nextId = 0;
+  constructor(getObserverFactoryProvider, _proxyRegistry) {
+    super(), this.getObserverFactoryProvider = getObserverFactoryProvider, this._proxyRegistry = _proxyRegistry;
   }
   getGroupId(data) {
     return data.target;
@@ -795,48 +916,50 @@ var ObjectObserverProxyPairManager = class extends GuidKeyedInstanceFactory2 {
   releaseInstance(observerProxyPair) {
     observerProxyPair.observer.dispose();
   }
+  createUniqueId(_data) {
+    return this._nextId++;
+  }
 };
-ObjectObserverProxyPairManager = _ts_decorate9([
-  Injectable9(),
+ObjectObserverProxyPairManager = _ts_decorate10([
+  Injectable10(),
   _ts_param9(0, Inject8(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProviderFactory)),
   _ts_param9(1, Inject8(RsXCoreInjectionTokens5.IProxyRegistry)),
-  _ts_param9(2, Inject8(RsXCoreInjectionTokens5.IGuidFactory)),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     Function,
-    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], ObjectObserverProxyPairManager);
 
 // lib/object-property-observer-proxy-pair-manager.ts
-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) {
+import { GroupedKeyedInstanceFactory as GroupedKeyedInstanceFactory3, Injectable as Injectable11, KeyedInstanceFactory as KeyedInstanceFactory2, MultiInject as MultiInject2, Type as Type5, UnsupportedException } 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);
   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_decorate10, "_ts_decorate");
-function _ts_metadata10(k, v) {
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata10, "_ts_metadata");
+__name(_ts_metadata11, "_ts_metadata");
 function _ts_param10(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param10, "_ts_param");
-var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 extends GuidKeyedInstanceFactory3 {
+var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 extends GroupedKeyedInstanceFactory3 {
   static {
     __name(this, "PropertyObserverProxyPairManager");
   }
   _object;
   _observerFactories;
   releaseContext;
-  constructor(guidFactory, _object, _observerFactories, releaseContext) {
-    super(guidFactory), this._object = _object, this._observerFactories = _observerFactories, this.releaseContext = releaseContext;
+  _nextId = 0;
+  constructor(_object, _observerFactories, releaseContext) {
+    super(), this._object = _object, this._observerFactories = _observerFactories, this.releaseContext = releaseContext;
   }
   getGroupId(data) {
     return data.index;
@@ -859,6 +982,9 @@ var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 e
   onReleased() {
     this.releaseContext();
   }
+  createUniqueId(_data) {
+    return this._nextId++;
+  }
   getObserverFactory(propertyInfo) {
     const observerFactory = this._observerFactories.find((observerFactory2) => observerFactory2.applies(this._object, propertyInfo));
     if (!observerFactory) {
@@ -867,14 +993,13 @@ var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 e
     return observerFactory;
   }
 };
-var ObjectPropertyObserverProxyPairManager = class extends KeyedInstanceFactory {
+var ObjectPropertyObserverProxyPairManager = class extends KeyedInstanceFactory2 {
   static {
     __name(this, "ObjectPropertyObserverProxyPairManager");
   }
   _factories;
-  _guidFactory;
-  constructor(_factories, _guidFactory) {
-    super(), this._factories = _factories, this._guidFactory = _guidFactory;
+  constructor(_factories) {
+    super(), this._factories = _factories;
   }
   getId(context) {
     return context;
@@ -883,33 +1008,31 @@ var ObjectPropertyObserverProxyPairManager = class extends KeyedInstanceFactory
     return context;
   }
   createInstance(context) {
-    return new PropertyObserverProxyPairManager(this._guidFactory, context, this._factories, () => this.release(context));
+    return new PropertyObserverProxyPairManager(context, this._factories, () => this.release(context));
   }
 };
-ObjectPropertyObserverProxyPairManager = _ts_decorate10([
-  Injectable10(),
+ObjectPropertyObserverProxyPairManager = _ts_decorate11([
+  Injectable11(),
   _ts_param10(0, MultiInject2(RsXStateManagerInjectionTokens.IPropertyObserverProxyPairFactoryList)),
-  _ts_param10(1, Inject9(RsXCoreInjectionTokens6.IGuidFactory)),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
-    Array,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    Array
   ])
 ], ObjectPropertyObserverProxyPairManager);
 
 // lib/property-observer/factories/collection-item/collection-item-observer-manager.ts
-import { Inject as Inject10, Injectable as Injectable11, KeyedInstanceFactory as KeyedInstanceFactory2, RsXCoreInjectionTokens as RsXCoreInjectionTokens7 } from "@rs-x/core";
-function _ts_decorate11(decorators, target, key, desc) {
+import { Inject as Inject9, Injectable as Injectable12, KeyedInstanceFactory as KeyedInstanceFactory3, RsXCoreInjectionTokens as RsXCoreInjectionTokens6 } from "@rs-x/core";
+function _ts_decorate12(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_decorate11, "_ts_decorate");
-function _ts_metadata11(k, v) {
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata12(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata11, "_ts_metadata");
+__name(_ts_metadata12, "_ts_metadata");
 function _ts_param11(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -960,7 +1083,7 @@ var CollectionIndexObserver = class CollectionIndexObserver2 extends AbstractObs
     }
   }, "onChanged");
 };
-var CollectionIndexObserverManager = class CollectionIndexObserverManager2 extends KeyedInstanceFactory2 {
+var CollectionIndexObserverManager = class CollectionIndexObserverManager2 extends KeyedInstanceFactory3 {
   static {
     __name(this, "CollectionIndexObserverManager");
   }
@@ -992,7 +1115,7 @@ var CollectionIndexObserverManager = class CollectionIndexObserverManager2 exten
     this.releaseObject();
   }
 };
-var CollectionItemObserverManager = class extends KeyedInstanceFactory2 {
+var CollectionItemObserverManager = class extends KeyedInstanceFactory3 {
   static {
     __name(this, "CollectionItemObserverManager");
   }
@@ -1016,14 +1139,14 @@ var CollectionItemObserverManager = class extends KeyedInstanceFactory2 {
     collectionIndexObserverManager.dispose();
   }
 };
-CollectionItemObserverManager = _ts_decorate11([
-  Injectable11(),
-  _ts_param11(0, Inject10(RsXCoreInjectionTokens7.IErrorLog)),
-  _ts_param11(1, Inject10(RsXCoreInjectionTokens7.IEqualityService)),
-  _ts_param11(2, Inject10(RsXCoreInjectionTokens7.IIndexValueAccessor)),
-  _ts_param11(3, Inject10(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+CollectionItemObserverManager = _ts_decorate12([
+  Injectable12(),
+  _ts_param11(0, Inject9(RsXCoreInjectionTokens6.IErrorLog)),
+  _ts_param11(1, Inject9(RsXCoreInjectionTokens6.IEqualityService)),
+  _ts_param11(2, Inject9(RsXCoreInjectionTokens6.IIndexValueAccessor)),
+  _ts_param11(3, Inject9(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
     typeof IEqualityService === "undefined" ? Object : IEqualityService,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
@@ -1032,20 +1155,20 @@ CollectionItemObserverManager = _ts_decorate11([
 ], CollectionItemObserverManager);
 
 // lib/property-observer/factories/collection-item/collection-item-observer-proxy-pair.factory.ts
-import { Inject as Inject11, Injectable as Injectable12, RsXCoreInjectionTokens as RsXCoreInjectionTokens8, truePredicate as truePredicate4 } from "@rs-x/core";
+import { Inject as Inject10, Injectable as Injectable13, RsXCoreInjectionTokens as RsXCoreInjectionTokens7, truePredicate as truePredicate4 } from "@rs-x/core";
 
 // lib/property-observer/factories/indexed-value-observer-proxy-pair/indexed-value-observer-proxy-pair.factory.ts
 import { Type as Type6, UnexpectedException } from "@rs-x/core";
 
 // lib/property-observer/factories/indexed-value-observer-proxy-pair/index-change-subscription-manager.ts
-import { KeyedInstanceFactory as KeyedInstanceFactory3 } from "@rs-x/core";
+import { KeyedInstanceFactory as KeyedInstanceFactory4 } from "@rs-x/core";
 var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
   static {
     __name(this, "IndexChangeSubscriptionsForContextManager");
   }
   _indexSetObserverManager;
-  constructor(context, releaseContext, _indexSetObserverManager, errorLog, guidFactory) {
-    super(context, releaseContext, errorLog, guidFactory), this._indexSetObserverManager = _indexSetObserverManager;
+  constructor(context, releaseContext, _indexSetObserverManager, errorLog) {
+    super(context, releaseContext, errorLog), this._indexSetObserverManager = _indexSetObserverManager;
   }
   getGroupId(data) {
     return data.index;
@@ -1080,15 +1203,14 @@ var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsFo
     return observer;
   }
 };
-var IndexChangeSubscriptionManager = class extends KeyedInstanceFactory3 {
+var IndexChangeSubscriptionManager = class extends KeyedInstanceFactory4 {
   static {
     __name(this, "IndexChangeSubscriptionManager");
   }
   _indexSetObserverManager;
   _errorLog;
-  _guidFactory;
-  constructor(_indexSetObserverManager, _errorLog, _guidFactory) {
-    super(), this._indexSetObserverManager = _indexSetObserverManager, this._errorLog = _errorLog, this._guidFactory = _guidFactory;
+  constructor(_indexSetObserverManager, _errorLog) {
+    super(), this._indexSetObserverManager = _indexSetObserverManager, this._errorLog = _errorLog;
   }
   getId(context) {
     return context;
@@ -1097,7 +1219,7 @@ var IndexChangeSubscriptionManager = class extends KeyedInstanceFactory3 {
     return context;
   }
   createInstance(context) {
-    return new IndexChangeSubscriptionsForContextManager(context, () => this.release(context), this._indexSetObserverManager, this._errorLog, this._guidFactory);
+    return new IndexChangeSubscriptionsForContextManager(context, () => this.release(context), this._indexSetObserverManager, this._errorLog);
   }
   releaseInstance(instance, id) {
     super.releaseInstance(instance, id);
@@ -1116,13 +1238,13 @@ var IndexObserverProxyPairFactory = class {
   _valueMetadata;
   mustHandleChange;
   _indexChangeSubscriptionManager;
-  constructor(_objectObserveryManager, indexSetObserverManager, errorLog, guidFactory, _indexValueAccessor, _proxyRegister, _valueMetadata, mustHandleChange) {
+  constructor(_objectObserveryManager, indexSetObserverManager, errorLog, _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);
+    this._indexChangeSubscriptionManager = new IndexChangeSubscriptionManager(indexSetObserverManager, errorLog);
   }
   dispose() {
     this._indexChangeSubscriptionManager.dispose();
@@ -1145,7 +1267,7 @@ var IndexObserverProxyPairFactory = class {
     return this.proxifyIndexValue(value, indexWatchRule, propertyInfo.initializeManually, setValue);
   }
   createGroupObserver(owner, object, index, initialValue, initializeManually, indexValueObserver, indexWatchRule) {
-    const indexChangeSubscriptionsForContextManager = this._indexChangeSubscriptionManager.create(object).instance;
+    const indexChangeSubscriptionsForContextManager = this._indexChangeSubscriptionManager.createAndGetInstance(object);
     const { id } = indexChangeSubscriptionsForContextManager.create({
       index,
       initialValue,
@@ -1204,17 +1326,17 @@ var IndexObserverProxyPairFactory = class {
 };
 
 // lib/property-observer/factories/collection-item/collection-item-observer-proxy-pair.factory.ts
-function _ts_decorate12(decorators, target, key, desc) {
+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);
   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_decorate12, "_ts_decorate");
-function _ts_metadata12(k, v) {
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata13(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata12, "_ts_metadata");
+__name(_ts_metadata13, "_ts_metadata");
 function _ts_param12(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1225,28 +1347,26 @@ var CollectionItemObserverProxyPairFactory = class extends IndexObserverProxyPai
   static {
     __name(this, "CollectionItemObserverProxyPairFactory");
   }
-  constructor(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata) {
-    super(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata, truePredicate4);
+  constructor(objectObserverManager, collectionItemObserverManager, errorLog, indexValueAccessor, proxyRegister, valueMetadata) {
+    super(objectObserverManager, collectionItemObserverManager, errorLog, indexValueAccessor, proxyRegister, valueMetadata, truePredicate4);
   }
   applies(object) {
     return object instanceof Map || object instanceof Array || object instanceof Set;
   }
 };
-CollectionItemObserverProxyPairFactory = _ts_decorate12([
-  Injectable12(),
-  _ts_param12(0, Inject11(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
-  _ts_param12(1, Inject11(RsXStateManagerInjectionTokens.ICollectionItemObserverManager)),
-  _ts_param12(2, Inject11(RsXCoreInjectionTokens8.IErrorLog)),
-  _ts_param12(3, Inject11(RsXCoreInjectionTokens8.IGuidFactory)),
-  _ts_param12(4, Inject11(RsXCoreInjectionTokens8.IIndexValueAccessor)),
-  _ts_param12(5, Inject11(RsXCoreInjectionTokens8.IProxyRegistry)),
-  _ts_param12(6, Inject11(RsXCoreInjectionTokens8.IValueMetadata)),
-  _ts_metadata12("design:type", Function),
-  _ts_metadata12("design:paramtypes", [
+CollectionItemObserverProxyPairFactory = _ts_decorate13([
+  Injectable13(),
+  _ts_param12(0, Inject10(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_param12(1, Inject10(RsXStateManagerInjectionTokens.ICollectionItemObserverManager)),
+  _ts_param12(2, Inject10(RsXCoreInjectionTokens7.IErrorLog)),
+  _ts_param12(3, Inject10(RsXCoreInjectionTokens7.IIndexValueAccessor)),
+  _ts_param12(4, Inject10(RsXCoreInjectionTokens7.IProxyRegistry)),
+  _ts_param12(5, Inject10(RsXCoreInjectionTokens7.IValueMetadata)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
     typeof ICollectionItemObserverManager === "undefined" ? Object : ICollectionItemObserverManager,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
     typeof IValueMetadata === "undefined" ? Object : IValueMetadata
@@ -1254,18 +1374,18 @@ CollectionItemObserverProxyPairFactory = _ts_decorate12([
 ], CollectionItemObserverProxyPairFactory);
 
 // lib/property-observer/factories/date-property/data-property-observer-manager.ts
-import { Inject as Inject12, Injectable as Injectable13, KeyedInstanceFactory as KeyedInstanceFactory4, RsXCoreInjectionTokens as RsXCoreInjectionTokens9 } from "@rs-x/core";
-function _ts_decorate13(decorators, target, key, desc) {
+import { Inject as Inject11, Injectable as Injectable14, KeyedInstanceFactory as KeyedInstanceFactory5, RsXCoreInjectionTokens as RsXCoreInjectionTokens8 } from "@rs-x/core";
+function _ts_decorate14(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_decorate13, "_ts_decorate");
-function _ts_metadata13(k, v) {
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata14(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata13, "_ts_metadata");
+__name(_ts_metadata14, "_ts_metadata");
 function _ts_param13(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1305,17 +1425,18 @@ var DatePropertyObserver = class DatePropertyObserver2 extends AbstractObserver
     this._oldValue = change.newValue;
   }, "onDateChanged");
 };
-var ProperForDataObserverManager = class ProperForDataObserverManager2 extends KeyedInstanceFactory4 {
+var ProperForDataObserverManager = class ProperForDataObserverManager2 extends KeyedInstanceFactory5 {
   static {
     __name(this, "ProperForDataObserverManager");
   }
   _date;
   _dateProxyFactory;
   _datePropertyAccessor;
+  _indexWatchRuleFactory;
   _errorLog;
   releaseObject;
-  constructor(_date, _dateProxyFactory, _datePropertyAccessor, _errorLog, releaseObject) {
-    super(), this._date = _date, this._dateProxyFactory = _dateProxyFactory, this._datePropertyAccessor = _datePropertyAccessor, this._errorLog = _errorLog, this.releaseObject = releaseObject;
+  constructor(_date, _dateProxyFactory, _datePropertyAccessor, _indexWatchRuleFactory, _errorLog, releaseObject) {
+    super(), this._date = _date, this._dateProxyFactory = _dateProxyFactory, this._datePropertyAccessor = _datePropertyAccessor, this._indexWatchRuleFactory = _indexWatchRuleFactory, this._errorLog = _errorLog, this.releaseObject = releaseObject;
   }
   getId(data) {
     return data.index;
@@ -1324,8 +1445,7 @@ var ProperForDataObserverManager = class ProperForDataObserverManager2 extends K
     return data.index;
   }
   createInstance(data, index) {
-    const indexWatchPredicate = /* @__PURE__ */ __name((targetIndex, target, context) => targetIndex === index && target === context, "indexWatchPredicate");
-    const indexWatchRule = new IndexWatchRule(this._date, indexWatchPredicate);
+    const indexWatchRule = this._indexWatchRuleFactory.create(this._date, index);
     const dateObserver = this._dateProxyFactory.create({
       date: this._date,
       indexWatchRule
@@ -1342,15 +1462,16 @@ var ProperForDataObserverManager = class ProperForDataObserverManager2 extends K
     this.releaseObject();
   }
 };
-var DatePropertyObserverManager = class extends KeyedInstanceFactory4 {
+var DatePropertyObserverManager = class extends KeyedInstanceFactory5 {
   static {
     __name(this, "DatePropertyObserverManager");
   }
   _dateProxyFactory;
   _errorLog;
   _datePropertyAccessor;
-  constructor(_dateProxyFactory, _errorLog, _datePropertyAccessor) {
-    super(), this._dateProxyFactory = _dateProxyFactory, this._errorLog = _errorLog, this._datePropertyAccessor = _datePropertyAccessor;
+  _indexWatchRuleFactory;
+  constructor(_dateProxyFactory, _errorLog, _datePropertyAccessor, _indexWatchRuleFactory) {
+    super(), this._dateProxyFactory = _dateProxyFactory, this._errorLog = _errorLog, this._datePropertyAccessor = _datePropertyAccessor, this._indexWatchRuleFactory = _indexWatchRuleFactory;
   }
   getId(date) {
     return date;
@@ -1359,38 +1480,40 @@ var DatePropertyObserverManager = class extends KeyedInstanceFactory4 {
     return date;
   }
   createInstance(date) {
-    return new ProperForDataObserverManager(date, this._dateProxyFactory, this._datePropertyAccessor, this._errorLog, () => this.release(date));
+    return new ProperForDataObserverManager(date, this._dateProxyFactory, this._datePropertyAccessor, this._indexWatchRuleFactory, this._errorLog, () => this.release(date));
   }
   releaseInstance(properForDataObserverManager) {
     properForDataObserverManager.dispose();
   }
 };
-DatePropertyObserverManager = _ts_decorate13([
-  Injectable13(),
-  _ts_param13(0, Inject12(RsXStateManagerInjectionTokens.IDateProxyFactory)),
-  _ts_param13(1, Inject12(RsXCoreInjectionTokens9.IErrorLog)),
-  _ts_param13(2, Inject12(RsXCoreInjectionTokens9.IDatePropertyAccessor)),
-  _ts_metadata13("design:type", Function),
-  _ts_metadata13("design:paramtypes", [
+DatePropertyObserverManager = _ts_decorate14([
+  Injectable14(),
+  _ts_param13(0, Inject11(RsXStateManagerInjectionTokens.IDateProxyFactory)),
+  _ts_param13(1, Inject11(RsXCoreInjectionTokens8.IErrorLog)),
+  _ts_param13(2, Inject11(RsXCoreInjectionTokens8.IDatePropertyAccessor)),
+  _ts_param13(3, Inject11(RsXStateManagerInjectionTokens.IIndexWatchRuleFactory)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof IDateProxyFactory === "undefined" ? Object : IDateProxyFactory,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
-    typeof IDatePropertyAccessor === "undefined" ? Object : IDatePropertyAccessor
+    typeof IDatePropertyAccessor === "undefined" ? Object : IDatePropertyAccessor,
+    typeof IIndexWatchRuleFactory === "undefined" ? Object : IIndexWatchRuleFactory
   ])
 ], DatePropertyObserverManager);
 
 // lib/property-observer/factories/date-property/date-property-observer-proxy-pair.factory.ts
-import { Inject as Inject13, Injectable as Injectable14, RsXCoreInjectionTokens as RsXCoreInjectionTokens10, truePredicate as truePredicate5 } from "@rs-x/core";
-function _ts_decorate14(decorators, target, key, desc) {
+import { Inject as Inject12, Injectable as Injectable15, RsXCoreInjectionTokens as RsXCoreInjectionTokens9, truePredicate as truePredicate5 } from "@rs-x/core";
+function _ts_decorate15(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_decorate14, "_ts_decorate");
-function _ts_metadata14(k, v) {
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata15(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata14, "_ts_metadata");
+__name(_ts_metadata15, "_ts_metadata");
 function _ts_param14(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1401,28 +1524,26 @@ var DatePropertyObserverProxyPairFactory = class extends IndexObserverProxyPairF
   static {
     __name(this, "DatePropertyObserverProxyPairFactory");
   }
-  constructor(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister, valueMetadata) {
-    super(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister, valueMetadata, truePredicate5);
+  constructor(objectObserverManager, datePropertyObserverManager, errorLog, datePropertyAccessor, proxyRegister, valueMetadata) {
+    super(objectObserverManager, datePropertyObserverManager, errorLog, datePropertyAccessor, proxyRegister, valueMetadata, truePredicate5);
   }
   applies(object) {
     return object instanceof Date;
   }
 };
-DatePropertyObserverProxyPairFactory = _ts_decorate14([
-  Injectable14(),
-  _ts_param14(0, Inject13(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
-  _ts_param14(1, Inject13(RsXStateManagerInjectionTokens.IDatePropertyObserverManager)),
-  _ts_param14(2, Inject13(RsXCoreInjectionTokens10.IErrorLog)),
-  _ts_param14(3, Inject13(RsXCoreInjectionTokens10.IGuidFactory)),
-  _ts_param14(4, Inject13(RsXCoreInjectionTokens10.IIndexValueAccessor)),
-  _ts_param14(5, Inject13(RsXCoreInjectionTokens10.IProxyRegistry)),
-  _ts_param14(6, Inject13(RsXCoreInjectionTokens10.IValueMetadata)),
-  _ts_metadata14("design:type", Function),
-  _ts_metadata14("design:paramtypes", [
+DatePropertyObserverProxyPairFactory = _ts_decorate15([
+  Injectable15(),
+  _ts_param14(0, Inject12(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_param14(1, Inject12(RsXStateManagerInjectionTokens.IDatePropertyObserverManager)),
+  _ts_param14(2, Inject12(RsXCoreInjectionTokens9.IErrorLog)),
+  _ts_param14(3, Inject12(RsXCoreInjectionTokens9.IIndexValueAccessor)),
+  _ts_param14(4, Inject12(RsXCoreInjectionTokens9.IProxyRegistry)),
+  _ts_param14(5, Inject12(RsXCoreInjectionTokens9.IValueMetadata)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
     typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
     typeof IDatePropertyObserverManager === "undefined" ? Object : IDatePropertyObserverManager,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
     typeof IValueMetadata === "undefined" ? Object : IValueMetadata
@@ -1430,18 +1551,18 @@ DatePropertyObserverProxyPairFactory = _ts_decorate14([
 ], DatePropertyObserverProxyPairFactory);
 
 // lib/property-observer/factories/non-iterable-object-property/non-iterable-object-property-observer-proxy-pair.factory.ts
-import { Inject as Inject14, Injectable as Injectable15, RsXCoreInjectionTokens as RsXCoreInjectionTokens11, Type as Type7 } from "@rs-x/core";
-function _ts_decorate15(decorators, target, key, desc) {
+import { Inject as Inject13, Injectable as Injectable16, RsXCoreInjectionTokens as RsXCoreInjectionTokens10, Type as Type7 } 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);
   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_decorate15, "_ts_decorate");
-function _ts_metadata15(k, v) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata16(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata15, "_ts_metadata");
+__name(_ts_metadata16, "_ts_metadata");
 function _ts_param15(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1452,8 +1573,8 @@ var NonIterableObjectPropertyObserverProxyPairFactory = class extends IndexObser
   static {
     __name(this, "NonIterableObjectPropertyObserverProxyPairFactory");
   }
-  constructor(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata) {
-    super(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, valueMetadata);
+  constructor(objectObserveryManager, objectPropertyObserverManager, errorLog, indexValueAccessor, proxyRegister, valueMetadata) {
+    super(objectObserveryManager, objectPropertyObserverManager, errorLog, indexValueAccessor, proxyRegister, valueMetadata);
   }
   applies(object, propertyInfo) {
     return !(Array.isArray(object) || object instanceof Date || object instanceof Map || object instanceof Set) && Type7.isString(propertyInfo.index) && !Type7.isMethod((Type7.toObject(object) ?? {})[propertyInfo.index]);
@@ -1462,21 +1583,19 @@ var NonIterableObjectPropertyObserverProxyPairFactory = class extends IndexObser
     object[key] = value;
   }
 };
-NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate15([
-  Injectable15(),
-  _ts_param15(0, Inject14(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
-  _ts_param15(1, Inject14(RsXStateManagerInjectionTokens.IObjectPropertyObserverManager)),
-  _ts_param15(2, Inject14(RsXCoreInjectionTokens11.IErrorLog)),
-  _ts_param15(3, Inject14(RsXCoreInjectionTokens11.IGuidFactory)),
-  _ts_param15(4, Inject14(RsXCoreInjectionTokens11.IIndexValueAccessor)),
-  _ts_param15(5, Inject14(RsXCoreInjectionTokens11.IProxyRegistry)),
-  _ts_param15(6, Inject14(RsXCoreInjectionTokens11.IValueMetadata)),
-  _ts_metadata15("design:type", Function),
-  _ts_metadata15("design:paramtypes", [
+NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate16([
+  Injectable16(),
+  _ts_param15(0, Inject13(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_param15(1, Inject13(RsXStateManagerInjectionTokens.IObjectPropertyObserverManager)),
+  _ts_param15(2, Inject13(RsXCoreInjectionTokens10.IErrorLog)),
+  _ts_param15(3, Inject13(RsXCoreInjectionTokens10.IIndexValueAccessor)),
+  _ts_param15(4, Inject13(RsXCoreInjectionTokens10.IProxyRegistry)),
+  _ts_param15(5, Inject13(RsXCoreInjectionTokens10.IValueMetadata)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
     typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
     typeof IObjectPropertyObserverManager === "undefined" ? Object : IObjectPropertyObserverManager,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
     typeof IValueMetadata === "undefined" ? Object : IValueMetadata
@@ -1485,18 +1604,18 @@ 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, KeyedInstanceFactory as KeyedInstanceFactory5, PropertyDescriptorType, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, Type as Type8 } from "@rs-x/core";
-function _ts_decorate16(decorators, target, key, desc) {
+import { Inject as Inject14, Injectable as Injectable17, InvalidOperationException as InvalidOperationException2, KeyedInstanceFactory as KeyedInstanceFactory6, PropertyDescriptorType, RsXCoreInjectionTokens as RsXCoreInjectionTokens11, Type as Type8 } 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);
   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_decorate16, "_ts_decorate");
-function _ts_metadata16(k, v) {
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata17(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata16, "_ts_metadata");
+__name(_ts_metadata17, "_ts_metadata");
 function _ts_param16(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1617,7 +1736,7 @@ var PropertObserver = class PropertObserver2 extends AbstractObserver {
     return newDescriptor;
   }
 };
-var PropertyObserverManager = class PropertyObserverManager2 extends KeyedInstanceFactory5 {
+var PropertyObserverManager = class PropertyObserverManager2 extends KeyedInstanceFactory6 {
   static {
     __name(this, "PropertyObserverManager");
   }
@@ -1646,7 +1765,7 @@ var PropertyObserverManager = class PropertyObserverManager2 extends KeyedInstan
     observer.dispose();
   }
 };
-var ObjectPropertyObserverManager = class extends KeyedInstanceFactory5 {
+var ObjectPropertyObserverManager = class extends KeyedInstanceFactory6 {
   static {
     __name(this, "ObjectPropertyObserverManager");
   }
@@ -1667,29 +1786,29 @@ var ObjectPropertyObserverManager = class extends KeyedInstanceFactory5 {
     propertyObserverManager.dispose();
   }
 };
-ObjectPropertyObserverManager = _ts_decorate16([
-  Injectable16(),
-  _ts_param16(0, Inject15(RsXCoreInjectionTokens12.IProxyRegistry)),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+ObjectPropertyObserverManager = _ts_decorate17([
+  Injectable17(),
+  _ts_param16(0, Inject14(RsXCoreInjectionTokens11.IProxyRegistry)),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], ObjectPropertyObserverManager);
 
 // lib/proxies/array-proxy/array-proxy.factory.ts
 import { Subject as Subject3 } from "rxjs";
-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) {
+import { Inject as Inject15, Injectable as Injectable18, KeyedInstanceFactory as KeyedInstanceFactory7, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, Type as Type9 } 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_decorate17, "_ts_decorate");
-function _ts_metadata17(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_metadata17, "_ts_metadata");
+__name(_ts_metadata18, "_ts_metadata");
 function _ts_param17(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -1833,7 +1952,7 @@ var ArrayProxy = class ArrayProxy2 extends AbstractObserver {
     }
   }
 };
-var ArrayProxyFactory = class extends KeyedInstanceFactory6 {
+var ArrayProxyFactory = class extends KeyedInstanceFactory7 {
   static {
     __name(this, "ArrayProxyFactory");
   }
@@ -1866,29 +1985,29 @@ var ArrayProxyFactory = class extends KeyedInstanceFactory6 {
     arrayObserverWithProxy.observer.dispose();
   }
 };
-ArrayProxyFactory = _ts_decorate17([
-  Injectable17(),
-  _ts_param17(0, Inject16(RsXCoreInjectionTokens13.IProxyRegistry)),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+ArrayProxyFactory = _ts_decorate18([
+  Injectable18(),
+  _ts_param17(0, Inject15(RsXCoreInjectionTokens12.IProxyRegistry)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], ArrayProxyFactory);
 
 // lib/proxies/date-proxy/date-proxy.factory.ts
 import { Subject as Subject4 } from "rxjs";
-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) {
+import { GroupedKeyedInstanceFactory as GroupedKeyedInstanceFactory4, Inject as Inject16, Injectable as Injectable19, RsXCoreInjectionTokens as RsXCoreInjectionTokens13, Type as Type10 } 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_decorate18, "_ts_decorate");
-function _ts_metadata18(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_metadata18, "_ts_metadata");
+__name(_ts_metadata19, "_ts_metadata");
 function _ts_param18(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2109,16 +2228,18 @@ var DateProxy = class DateProxy2 extends AbstractObserver {
   }
   disposeInternal() {
     this._proxyRegistry.unregister(this.value);
+    this.indexWatchRule?.dispose();
     this.target = Type10.cast(void 0);
   }
 };
-var DateProxyFactory = class extends GuidKeyedInstanceFactory4 {
+var DateProxyFactory = class extends GroupedKeyedInstanceFactory4 {
   static {
     __name(this, "DateProxyFactory");
   }
   _proxyRegistry;
-  constructor(guidFactory, _proxyRegistry) {
-    super(guidFactory), this._proxyRegistry = _proxyRegistry;
+  _nextId = 0;
+  constructor(_proxyRegistry) {
+    super(), this._proxyRegistry = _proxyRegistry;
   }
   getGroupId(data) {
     return data.date;
@@ -2140,31 +2261,32 @@ var DateProxyFactory = class extends GuidKeyedInstanceFactory4 {
       proxyTarget: dateProxyData.date
     };
   }
+  createUniqueId(_data) {
+    return this._nextId++;
+  }
 };
-DateProxyFactory = _ts_decorate18([
-  Injectable18(),
-  _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,
+DateProxyFactory = _ts_decorate19([
+  Injectable19(),
+  _ts_param18(0, Inject16(RsXCoreInjectionTokens13.IProxyRegistry)),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], DateProxyFactory);
 
 // lib/proxies/map-proxy/map-proxy.factory.ts
-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) {
+import { Inject as Inject17, Injectable as Injectable20, KeyedInstanceFactory as KeyedInstanceFactory8, RsXCoreInjectionTokens as RsXCoreInjectionTokens14, Type as Type11 } 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_decorate19, "_ts_decorate");
-function _ts_metadata19(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_metadata19, "_ts_metadata");
+__name(_ts_metadata20, "_ts_metadata");
 function _ts_param19(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2244,7 +2366,7 @@ var MapProxy = class extends AbstractObserver {
     });
   }
 };
-var MapProxyFactory = class extends KeyedInstanceFactory7 {
+var MapProxyFactory = class extends KeyedInstanceFactory8 {
   static {
     __name(this, "MapProxyFactory");
   }
@@ -2276,29 +2398,29 @@ var MapProxyFactory = class extends KeyedInstanceFactory7 {
     mapObserverWithProxy.observer.dispose();
   }
 };
-MapProxyFactory = _ts_decorate19([
-  Injectable19(),
-  _ts_param19(0, Inject18(RsXCoreInjectionTokens15.IProxyRegistry)),
-  _ts_metadata19("design:type", Function),
-  _ts_metadata19("design:paramtypes", [
+MapProxyFactory = _ts_decorate20([
+  Injectable20(),
+  _ts_param19(0, Inject17(RsXCoreInjectionTokens14.IProxyRegistry)),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], MapProxyFactory);
 
 // lib/proxies/observable-proxy/observable-proxy.factory.ts
 import { ReplaySubject as ReplaySubject2 } from "rxjs";
-import { Inject as Inject19, Injectable as Injectable20, KeyedInstanceFactory as KeyedInstanceFactory8, RsXCoreInjectionTokens as RsXCoreInjectionTokens16 } from "@rs-x/core";
-function _ts_decorate20(decorators, target, key, desc) {
+import { Inject as Inject18, Injectable as Injectable21, KeyedInstanceFactory as KeyedInstanceFactory9, RsXCoreInjectionTokens as RsXCoreInjectionTokens15 } 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_decorate20, "_ts_decorate");
-function _ts_metadata20(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_metadata20, "_ts_metadata");
+__name(_ts_metadata21, "_ts_metadata");
 function _ts_param20(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2342,7 +2464,7 @@ var ObservableProxy = class ObservableProxy2 extends AbstractObserver {
     });
   }, "emitObservableChange");
 };
-var ObservableProxyFactory = class extends KeyedInstanceFactory8 {
+var ObservableProxyFactory = class extends KeyedInstanceFactory9 {
   static {
     __name(this, "ObservableProxyFactory");
   }
@@ -2374,29 +2496,29 @@ var ObservableProxyFactory = class extends KeyedInstanceFactory8 {
     observableObserverWithProxy.observer.dispose();
   }
 };
-ObservableProxyFactory = _ts_decorate20([
-  Injectable20(),
-  _ts_param20(0, Inject19(RsXCoreInjectionTokens16.IObservableAccessor)),
-  _ts_metadata20("design:type", Function),
-  _ts_metadata20("design:paramtypes", [
+ObservableProxyFactory = _ts_decorate21([
+  Injectable21(),
+  _ts_param20(0, Inject18(RsXCoreInjectionTokens15.IObservableAccessor)),
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
     typeof IObservableAccessor === "undefined" ? Object : IObservableAccessor
   ])
 ], ObservableProxyFactory);
 
 // lib/proxies/promise-proxy/promise-proxy.factory.ts
 import { ReplaySubject as ReplaySubject3 } from "rxjs";
-import { Inject as Inject20, Injectable as Injectable21, KeyedInstanceFactory as KeyedInstanceFactory9, RsXCoreInjectionTokens as RsXCoreInjectionTokens17 } from "@rs-x/core";
-function _ts_decorate21(decorators, target, key, desc) {
+import { Inject as Inject19, Injectable as Injectable22, KeyedInstanceFactory as KeyedInstanceFactory10, RsXCoreInjectionTokens as RsXCoreInjectionTokens16 } 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_decorate21, "_ts_decorate");
-function _ts_metadata21(k, v) {
+__name(_ts_decorate22, "_ts_decorate");
+function _ts_metadata22(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata21, "_ts_metadata");
+__name(_ts_metadata22, "_ts_metadata");
 function _ts_param21(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2428,7 +2550,7 @@ var PromiseObserver = class PromiseObserver2 extends AbstractObserver {
     });
   }, "onValueResolved");
 };
-var PromiseProxyFactory = class extends KeyedInstanceFactory9 {
+var PromiseProxyFactory = class extends KeyedInstanceFactory10 {
   static {
     __name(this, "PromiseProxyFactory");
   }
@@ -2460,28 +2582,28 @@ var PromiseProxyFactory = class extends KeyedInstanceFactory9 {
     promiseObserverWithProxy.observer.dispose();
   }
 };
-PromiseProxyFactory = _ts_decorate21([
-  Injectable21(),
-  _ts_param21(0, Inject20(RsXCoreInjectionTokens17.IPromiseAccessor)),
-  _ts_metadata21("design:type", Function),
-  _ts_metadata21("design:paramtypes", [
+PromiseProxyFactory = _ts_decorate22([
+  Injectable22(),
+  _ts_param21(0, Inject19(RsXCoreInjectionTokens16.IPromiseAccessor)),
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
     typeof IPromiseAccessor === "undefined" ? Object : IPromiseAccessor
   ])
 ], PromiseProxyFactory);
 
 // 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) {
+import { Inject as Inject20, Injectable as Injectable23, KeyedInstanceFactory as KeyedInstanceFactory11, RsXCoreInjectionTokens as RsXCoreInjectionTokens17, 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_decorate22, "_ts_decorate");
-function _ts_metadata22(k, v) {
+__name(_ts_decorate23, "_ts_decorate");
+function _ts_metadata23(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata22, "_ts_metadata");
+__name(_ts_metadata23, "_ts_metadata");
 function _ts_param22(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2549,7 +2671,7 @@ var SetProxy = class extends AbstractObserver {
     });
   }
 };
-var SetProxyFactory = class extends KeyedInstanceFactory10 {
+var SetProxyFactory = class extends KeyedInstanceFactory11 {
   static {
     __name(this, "SetProxyFactory");
   }
@@ -2581,11 +2703,11 @@ var SetProxyFactory = class extends KeyedInstanceFactory10 {
     setObserverWithProxy.observer.dispose();
   }
 };
-SetProxyFactory = _ts_decorate22([
-  Injectable22(),
-  _ts_param22(0, Inject21(RsXCoreInjectionTokens18.IProxyRegistry)),
-  _ts_metadata22("design:type", Function),
-  _ts_metadata22("design:paramtypes", [
+SetProxyFactory = _ts_decorate23([
+  Injectable23(),
+  _ts_param22(0, Inject20(RsXCoreInjectionTokens17.IProxyRegistry)),
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
     typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], SetProxyFactory);
@@ -2594,25 +2716,25 @@ SetProxyFactory = _ts_decorate22([
 import { ContainerModule, InjectionContainer, registerMultiInjectServices, RsXCoreModule } from "@rs-x/core";
 
 // lib/state-manager/object-state-manager.ts
-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) {
+import { Inject as Inject21, Injectable as Injectable24, KeyedInstanceFactory as KeyedInstanceFactory12, RsXCoreInjectionTokens as RsXCoreInjectionTokens18, 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_decorate23, "_ts_decorate");
-function _ts_metadata23(k, v) {
+__name(_ts_decorate24, "_ts_decorate");
+function _ts_metadata24(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata23, "_ts_metadata");
+__name(_ts_metadata24, "_ts_metadata");
 function _ts_param23(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param23, "_ts_param");
-var StateForObjectManager = class extends KeyedInstanceFactory11 {
+var StateForObjectManager = class extends KeyedInstanceFactory12 {
   static {
     __name(this, "StateForObjectManager");
   }
@@ -2665,7 +2787,7 @@ var StateForObjectManager = class extends KeyedInstanceFactory11 {
     this.releaseContext();
   }
 };
-var ObjectStateManager = class extends KeyedInstanceFactory11 {
+var ObjectStateManager = class extends KeyedInstanceFactory12 {
   static {
     __name(this, "ObjectStateManager");
   }
@@ -2695,7 +2817,7 @@ var ObjectStateManager = class extends KeyedInstanceFactory11 {
     if (stateForObjectManagerForNewContext) {
       stateForObjectManagerForNewContext.set(key, newValue, watched, ownerId);
     } else if (newValue !== void 0) {
-      this.create(newContext).instance.create({
+      this.createAndGetInstance(newContext).create({
         key,
         value: newValue,
         watched,
@@ -2710,28 +2832,28 @@ var ObjectStateManager = class extends KeyedInstanceFactory11 {
     return new StateForObjectManager(this._deepClone, () => this.release(context));
   }
 };
-ObjectStateManager = _ts_decorate23([
-  Injectable23(),
-  _ts_param23(0, Inject22(RsXCoreInjectionTokens19.IDeepClone)),
-  _ts_metadata23("design:type", Function),
-  _ts_metadata23("design:paramtypes", [
+ObjectStateManager = _ts_decorate24([
+  Injectable24(),
+  _ts_param23(0, Inject21(RsXCoreInjectionTokens18.IDeepClone)),
+  _ts_metadata24("design:type", Function),
+  _ts_metadata24("design:paramtypes", [
     typeof IDeepClone === "undefined" ? Object : IDeepClone
   ])
 ], ObjectStateManager);
 
 // lib/state-manager/state-manager.ts
 import { Subject as Subject5 } from "rxjs";
-import { Assertion, Inject as Inject23, Injectable as Injectable24, PENDING, RsXCoreInjectionTokens as RsXCoreInjectionTokens20, truePredicate as truePredicate6 } from "@rs-x/core";
+import { Assertion, Inject as Inject22, Injectable as Injectable25, PENDING, RsXCoreInjectionTokens as RsXCoreInjectionTokens19, truePredicate as truePredicate6 } from "@rs-x/core";
 
 // lib/state-manager/state-change-subscription-manager/state-change-subsription-manager.ts
-import { KeyedInstanceFactory as KeyedInstanceFactory12 } from "@rs-x/core";
+import { KeyedInstanceFactory as KeyedInstanceFactory13 } from "@rs-x/core";
 var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
   static {
     __name(this, "StateChangeSubscriptionsForContextManager");
   }
   _objectObserverManager;
-  constructor(context, releaseContext, _objectObserverManager, errorLog, guidFactory) {
-    super(context, releaseContext, errorLog, guidFactory), this._objectObserverManager = _objectObserverManager;
+  constructor(context, releaseContext, _objectObserverManager, errorLog) {
+    super(context, releaseContext, errorLog), this._objectObserverManager = _objectObserverManager;
   }
   getGroupId(data) {
     return data.index;
@@ -2740,30 +2862,29 @@ var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsFo
     return data.indexWatchRule;
   }
   createObserver(context, data, id) {
-    const objectObserver = this._objectObserverManager.create(context).instance;
-    const observer = objectObserver.create({
+    const objectObserver = this._objectObserverManager.createAndGetInstance(context);
+    const observer = objectObserver.createAndGetInstance({
       index: data.index,
       initializeManually: true,
       indexWatchRule: data.indexWatchRule,
       owner: {
         release: /* @__PURE__ */ __name(() => this.release(id), "release")
       }
-    }).instance.observer;
+    }).observer;
     return {
       observer,
       subscriptionData: void 0
     };
   }
 };
-var StateChangeSubscriptionManager = class extends KeyedInstanceFactory12 {
+var StateChangeSubscriptionManager = class extends KeyedInstanceFactory13 {
   static {
     __name(this, "StateChangeSubscriptionManager");
   }
   _objectObserverManager;
   _errorLog;
-  _guidFactory;
-  constructor(_objectObserverManager, _errorLog, _guidFactory) {
-    super(), this._objectObserverManager = _objectObserverManager, this._errorLog = _errorLog, this._guidFactory = _guidFactory;
+  constructor(_objectObserverManager, _errorLog) {
+    super(), this._objectObserverManager = _objectObserverManager, this._errorLog = _errorLog;
   }
   getId(context) {
     return context;
@@ -2782,7 +2903,7 @@ var StateChangeSubscriptionManager = class extends KeyedInstanceFactory12 {
     return context;
   }
   createInstance(context, id) {
-    return new StateChangeSubscriptionsForContextManager(context, () => this.release(id), this._objectObserverManager, this._errorLog, this._guidFactory);
+    return new StateChangeSubscriptionsForContextManager(context, () => this.release(id), this._objectObserverManager, this._errorLog);
   }
   releaseInstance(instance, id) {
     super.releaseInstance(instance, id);
@@ -2791,17 +2912,17 @@ var StateChangeSubscriptionManager = class extends KeyedInstanceFactory12 {
 };
 
 // lib/state-manager/state-manager.ts
-function _ts_decorate24(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_decorate24, "_ts_decorate");
-function _ts_metadata24(k, v) {
+__name(_ts_decorate25, "_ts_decorate");
+function _ts_metadata25(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata24, "_ts_metadata");
+__name(_ts_metadata25, "_ts_metadata");
 function _ts_param24(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
@@ -2815,6 +2936,7 @@ var StateManager = class {
   _objectStateManager;
   _indexValueAccessor;
   _equalityService;
+  _proxyRegistry;
   _changed = new Subject5();
   _contextChanged = new Subject5();
   _startChangeCycle = new Subject5();
@@ -2823,11 +2945,12 @@ var StateManager = class {
   _pending = /* @__PURE__ */ new Map();
   _stateEventSubscriptionsByContext = /* @__PURE__ */ new Map();
   _stateEventSubscriptionPool = [];
-  constructor(objectObserverManager, _objectStateManager, errorLog, guidFactory, _indexValueAccessor, _equalityService) {
+  constructor(objectObserverManager, _objectStateManager, errorLog, _indexValueAccessor, _equalityService, _proxyRegistry) {
     this._objectStateManager = _objectStateManager;
     this._indexValueAccessor = _indexValueAccessor;
     this._equalityService = _equalityService;
-    this._stateChangeSubscriptionManager = new StateChangeSubscriptionManager(objectObserverManager, errorLog, guidFactory);
+    this._proxyRegistry = _proxyRegistry;
+    this._stateChangeSubscriptionManager = new StateChangeSubscriptionManager(objectObserverManager, errorLog);
   }
   get changed() {
     return this._changed;
@@ -2844,7 +2967,7 @@ var StateManager = class {
   toString() {
     return this._objectStateManager.toString();
   }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return `${this.constructor.name}`;
   }
   isWatched(context, index, indexWatchRule) {
@@ -2856,12 +2979,12 @@ var StateManager = class {
       index,
       indexWatchRule
     });
-    return id ? stateChangeSubscriptionsForContextManager.has(id) : false;
+    return id !== void 0 ? stateChangeSubscriptionsForContextManager.has(id) : false;
   }
   watchState(context, index, options) {
     if (!this.isWatched(context, index, options?.indexWatchRule)) {
       const value = this.getState(context, index);
-      this.tryToSubscribeToChange(context, index, options?.ownerId, options?.indexWatchRule);
+      this.tryToSubscribeToChange(context, index, options?.ownerId, options?.indexWatchRule, void 0, options?.suppressInitialChangeEmit ?? false);
       return value;
     } else {
       return this.increaseStateReferenceCount(context, index, true, options?.ownerId);
@@ -2891,8 +3014,13 @@ var StateManager = class {
   }
   setState(context, index, value, ownerId) {
     const isExternalSetState = ownerId === void 0;
+    const changeCycleIndex = {
+      context,
+      index
+    };
     if (isExternalSetState) {
-      this._startChangeCycle.next();
+      this._startChangeCycle.next(changeCycleIndex);
+      this.emitStartChangeCycleEvents(changeCycleIndex);
     }
     try {
       this.internalSetState(context, index, value, {
@@ -2902,7 +3030,8 @@ var StateManager = class {
       }, ownerId);
     } finally {
       if (isExternalSetState) {
-        this._endChangeCycle.next();
+        this._endChangeCycle.next(changeCycleIndex);
+        this.emitEndChangeCycleEvents(changeCycleIndex);
       }
     }
   }
@@ -2927,18 +3056,23 @@ var StateManager = class {
     }
     observer.dispose();
   }
+  hasChanged(newValue, oldValue) {
+    if (Object.is(newValue, oldValue)) {
+      return false;
+    }
+    const isObjectLike = /* @__PURE__ */ __name((v) => v !== null && (typeof v === "object" || typeof v === "function"), "isObjectLike");
+    if ((isObjectLike(newValue) || isObjectLike(oldValue)) && this._equalityService.isEqual(newValue, oldValue)) {
+      return false;
+    }
+    return true;
+  }
   internalUnregister(context, index, indexWatchRule) {
     if (this.canReleaseState(context, index)) {
       this.unnsubscribeToObserverEvents(context, index, indexWatchRule);
     }
   }
   emitChange(context, index, newValue, oldValue, oldContext) {
-    if (newValue === oldValue || newValue !== newValue && oldValue !== oldValue) {
-      return;
-    }
-    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)) {
+    if (!this.hasChanged(newValue, oldValue)) {
       return;
     }
     const stateChange = {
@@ -2961,7 +3095,8 @@ var StateManager = class {
   }
   increaseStateReferenceCount(context, index, watched, ownerId) {
     const state = this.getState(context, index);
-    this._objectStateManager.create(context).instance.create({
+    const stateForContext = this._objectStateManager.createAndGetInstance(context);
+    stateForContext.create({
       value: state,
       key: index,
       watched,
@@ -2969,14 +3104,14 @@ var StateManager = class {
     });
     return state;
   }
-  tryToSubscribeToChange(context, index, ownerId, indexWatchRule, transferedValue) {
-    this._stateChangeSubscriptionManager.create(context).instance.create({
+  tryToSubscribeToChange(context, index, ownerId, indexWatchRule, transferedValue, suppressInitialChangeEmit = false) {
+    this._stateChangeSubscriptionManager.createAndGetInstance(context).createAndGetInstance({
       index,
       indexWatchRule,
       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, ownerId);
+          this.setInitialValue(context, index, observer.value, transferedValue, true, ownerId, suppressInitialChangeEmit);
         }
         observer.init();
       }, "init")
@@ -2984,7 +3119,8 @@ var StateManager = class {
   }
   getValue(context, key) {
     try {
-      return this._indexValueAccessor.getResolvedValue(context, key);
+      const value = this._indexValueAccessor.getResolvedValue(context, key);
+      return this._proxyRegistry.getProxyTarget(value) ?? value;
     } catch {
       return this.getState(context, key);
     }
@@ -3134,6 +3270,24 @@ var StateManager = class {
       this.releaseStateEventSubscription(subscription);
     }
   }
+  emitStartChangeCycleEvents(changeCycleIndex) {
+    const subscriptions = this._stateEventSubscriptionsByContext.get(changeCycleIndex.context)?.get(changeCycleIndex.index);
+    if (!subscriptions || subscriptions.size === 0) {
+      return;
+    }
+    for (const subscription of subscriptions) {
+      subscription.listener.onStartChangeCycle?.(changeCycleIndex);
+    }
+  }
+  emitEndChangeCycleEvents(changeCycleIndex) {
+    const subscriptions = this._stateEventSubscriptionsByContext.get(changeCycleIndex.context)?.get(changeCycleIndex.index);
+    if (!subscriptions || subscriptions.size === 0) {
+      return;
+    }
+    for (const subscription of subscriptions) {
+      subscription.listener.onEndChangeCycle?.(changeCycleIndex);
+    }
+  }
   emitStateChangeEvents(change) {
     const subscriptions = this._stateEventSubscriptionsByContext.get(change.context)?.get(change.index);
     if (!subscriptions || subscriptions.size === 0) {
@@ -3183,10 +3337,14 @@ var StateManager = class {
     subscription.active = false;
     this._stateEventSubscriptionPool.push(subscription);
   }
-  setInitialValue(context, index, initialValue, transferedValue, watched, ownerId) {
+  setInitialValue(context, index, initialValue, transferedValue, watched, ownerId, suppressInitialChangeEmit = false) {
+    const existingStateForContext = this._objectStateManager.getFromId(context);
+    const existingStateForIndex = existingStateForContext?.getFromId(index);
+    const isFirstWatchedInitialization = watched && transferedValue === void 0 && existingStateForIndex === void 0;
+    const previousValue = transferedValue?.value ?? existingStateForIndex?.value ?? void 0;
     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);
+    if (!(suppressInitialChangeEmit && isFirstWatchedInitialization) && (!transferedValue?.shouldEmitChange || transferedValue.shouldEmitChange(context, index))) {
+      this.emitChange(context, index, initialValue, previousValue, transferedValue?.context);
     }
   }
   getChainChanges(chain) {
@@ -3230,14 +3388,20 @@ var StateManager = class {
       }
       const value = this.getValue(context, index);
       const oldValue = this.getOldValue(context, index);
-      this._startChangeCycle.next();
+      const changeCycleIndex2 = {
+        context,
+        index
+      };
+      this._startChangeCycle.next(changeCycleIndex2);
+      this.emitStartChangeCycleEvents(changeCycleIndex2);
       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();
+        this._endChangeCycle.next(changeCycleIndex2);
+        this.emitEndChangeCycleEvents(changeCycleIndex2);
       }
       return;
     }
@@ -3245,9 +3409,14 @@ var StateManager = class {
     if (chainChanges.length === 0) {
       return;
     }
-    this._startChangeCycle.next();
+    const chainLeaf = chainChanges[chainChanges.length - 1];
+    const changeCycleIndex = {
+      context: chainLeaf.context,
+      index: chainLeaf.index
+    };
+    this._startChangeCycle.next(changeCycleIndex);
+    this.emitStartChangeCycleEvents(changeCycleIndex);
     try {
-      const chainLeaf = chainChanges[chainChanges.length - 1];
       const currentValue = this.getCurrentValue(chainLeaf.context, chainLeaf.index);
       this.tryRebindingNestedState(change.newValue, currentValue, ownerId);
       for (let i = 0; i < chainChanges.length; i++) {
@@ -3259,29 +3428,229 @@ var StateManager = class {
         this.emitChange(chainChange.context, chainChange.index, chainChange.value, chainChange.oldValue);
       }
     } finally {
-      this._endChangeCycle.next();
+      this._endChangeCycle.next(changeCycleIndex);
+      this.emitEndChangeCycleEvents(changeCycleIndex);
     }
   }
 };
-StateManager = _ts_decorate24([
-  Injectable24(),
-  _ts_param24(0, Inject23(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
-  _ts_param24(1, Inject23(RsXStateManagerInjectionTokens.IObjectStateManager)),
-  _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", [
+StateManager = _ts_decorate25([
+  Injectable25(),
+  _ts_param24(0, Inject22(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
+  _ts_param24(1, Inject22(RsXStateManagerInjectionTokens.IObjectStateManager)),
+  _ts_param24(2, Inject22(RsXCoreInjectionTokens19.IErrorLog)),
+  _ts_param24(3, Inject22(RsXCoreInjectionTokens19.IIndexValueAccessor)),
+  _ts_param24(4, Inject22(RsXCoreInjectionTokens19.IEqualityService)),
+  _ts_param24(5, Inject22(RsXCoreInjectionTokens19.IProxyRegistry)),
+  _ts_metadata25("design:type", Function),
+  _ts_metadata25("design:paramtypes", [
     typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager,
     typeof IObjectStateManager === "undefined" ? Object : IObjectStateManager,
     typeof IErrorLog === "undefined" ? Object : IErrorLog,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
     typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
-    typeof IEqualityService === "undefined" ? Object : IEqualityService
+    typeof IEqualityService === "undefined" ? Object : IEqualityService,
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
   ])
 ], StateManager);
 
+// lib/state-manager/watch-factory/watch-factory.ts
+import { Dispatcher, GroupedKeyedInstanceFactory as GroupedKeyedInstanceFactory5, Inject as Inject23, Injectable as Injectable26, Type as Type13 } from "@rs-x/core";
+function _ts_decorate26(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_metadata26(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata26, "_ts_metadata");
+function _ts_param25(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param25, "_ts_param");
+var Watch = class Watch2 {
+  static {
+    __name(this, "Watch");
+  }
+  _owner;
+  _context;
+  index;
+  _options;
+  _stateManager;
+  _watchReferenceCount = 0;
+  _changeDispatcher = new Dispatcher();
+  _contextChangedDispatcher = new Dispatcher();
+  _startChangeCycleDispatcher = new Dispatcher();
+  _endChangeCycleDispatcher = new Dispatcher();
+  _isWatched = false;
+  _isDisposed = false;
+  _stateEventUnsubscribe;
+  _value;
+  constructor(_owner, _context, index, _options, _stateManager) {
+    this._owner = _owner;
+    this._context = _context;
+    this.index = index;
+    this._options = _options;
+    this._stateManager = _stateManager;
+  }
+  get context() {
+    return this._context;
+  }
+  get value() {
+    return this._value;
+  }
+  get changed() {
+    return this._changeDispatcher.observable;
+  }
+  get contextChange() {
+    return this._contextChangedDispatcher.observable;
+  }
+  get startChangeCycle() {
+    return this._startChangeCycleDispatcher.observable;
+  }
+  get endChangeCycle() {
+    return this._endChangeCycleDispatcher.observable;
+  }
+  watch() {
+    this._watchReferenceCount++;
+    if (this._isWatched) {
+      return;
+    }
+    if (Type13.isReadonlyProperty(this.context, this.index)) {
+      this._value = this._stateManager.getState(this.context, this.index);
+    } else {
+      this._value = this._stateManager.watchState(this.context, this.index, {
+        ...this._options,
+        suppressInitialChangeEmit: true
+      });
+      if (this._value === void 0) {
+        this._value = this._stateManager.getState(this.context, this.index);
+      }
+    }
+    this._stateEventUnsubscribe = this._stateManager.subscribeStateEvents(this.context, this.index, {
+      onStateChange: this.onChanged,
+      onContextChanged: this.onContextChanged,
+      onStartChangeCycle: this.onStartChangeCycle,
+      onEndChangeCycle: this.onEndChangeCycle
+    });
+    this._isWatched = true;
+  }
+  onChanged = /* @__PURE__ */ __name((change) => {
+    if (change.context == this._context && change.index === this.index) {
+      this._value = change.newValue;
+      this._changeDispatcher.dispatch(change);
+    }
+  }, "onChanged");
+  onContextChanged = /* @__PURE__ */ __name((change) => {
+    if (this._options.ownerId === void 0 && this._context === change.oldContext && this.index === change.index) {
+      this._context = change.context;
+      this._contextChangedDispatcher.dispatch(change);
+    }
+  }, "onContextChanged");
+  onStartChangeCycle = /* @__PURE__ */ __name((cycle) => {
+    this._startChangeCycleDispatcher.dispatch(cycle);
+  }, "onStartChangeCycle");
+  onEndChangeCycle = /* @__PURE__ */ __name((cycle) => {
+    this._endChangeCycleDispatcher.dispatch(cycle);
+  }, "onEndChangeCycle");
+  unwatch() {
+    if (!this._isWatched) {
+      return;
+    }
+    this._watchReferenceCount--;
+    if (this._watchReferenceCount == 0) {
+      this._stateManager.releaseState(this._context, this.index, this._options.indexWatchRule);
+      this._stateEventUnsubscribe?.();
+      this._stateEventUnsubscribe = void 0;
+      this._isWatched = false;
+    }
+  }
+  addListeners(key, callbacks) {
+    this._changeDispatcher.addListener(key, callbacks.onChanged);
+    this._contextChangedDispatcher.addListener(key, callbacks.onContextChanged);
+    this._startChangeCycleDispatcher.addListener(key, callbacks.onStartChangeCycle);
+    this._endChangeCycleDispatcher.addListener(key, callbacks.onEndChangeCycle);
+  }
+  removeListeners(key) {
+    this._changeDispatcher.removeListener(key);
+    this._contextChangedDispatcher.removeListener(key);
+    this._startChangeCycleDispatcher.removeListener(key);
+    this._endChangeCycleDispatcher.removeListener(key);
+  }
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    const canDispose = this._owner.canDispose;
+    if (canDispose()) {
+      this._watchReferenceCount = 1;
+      this.unwatch();
+      this._isDisposed = true;
+    }
+    this._owner.release();
+  }
+};
+var WatchFactory = class extends GroupedKeyedInstanceFactory5 {
+  static {
+    __name(this, "WatchFactory");
+  }
+  _stateManager;
+  _identityMap = /* @__PURE__ */ new WeakMap();
+  _identityIndex = 0;
+  _nextId = 0;
+  constructor(_stateManager) {
+    super(), this._stateManager = _stateManager;
+  }
+  getGroupId(data) {
+    return data.context;
+  }
+  getGroupMemberId(data) {
+    const watchData = data;
+    const watchRule = watchData.options?.indexWatchRule;
+    if (watchRule === void 0) {
+      return watchData.index;
+    }
+    return `${this.toIdentityKey(watchData.index)}|${this.toIdentityKey(watchRule)}`;
+  }
+  createInstance(data, id) {
+    return new Watch({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    }, data.context, data.index, data.options, this._stateManager);
+  }
+  createUniqueId(_data) {
+    return this._nextId++;
+  }
+  toIdentityKey(value) {
+    if (value === null) {
+      return "null";
+    }
+    const valueType = typeof value;
+    if (valueType === "object" || valueType === "function") {
+      const target = value;
+      const existing = this._identityMap.get(target);
+      if (existing) {
+        return existing;
+      }
+      const key = `obj:${++this._identityIndex}`;
+      this._identityMap.set(target, key);
+      return key;
+    }
+    return `${valueType}:${String(value)}`;
+  }
+};
+WatchFactory = _ts_decorate26([
+  Injectable26(),
+  _ts_param25(0, Inject23(RsXStateManagerInjectionTokens.IStateManager)),
+  _ts_metadata26("design:type", Function),
+  _ts_metadata26("design:paramtypes", [
+    typeof IStateManager === "undefined" ? Object : IStateManager
+  ])
+], WatchFactory);
+
 // lib/rs-x-state-manager.module.ts
 var defaultObjectObserverProxyPairFactoryList = [
   {
@@ -3336,6 +3705,7 @@ var RsXStateManagerModule = new ContainerModule((options) => {
   options.bind(RsXStateManagerInjectionTokens.IPromiseProxyFactory).to(PromiseProxyFactory).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IObservableProxyFactory).to(ObservableProxyFactory).inSingletonScope();
   options.bind(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager).to(ObjectPropertyObserverProxyPairManager).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IIndexWatchRuleFactory).to(IndexWatchRuleFactory).inSingletonScope();
   registerMultiInjectServices(options, RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryList, defaultObjectObserverProxyPairFactoryList);
   registerMultiInjectServices(options, RsXStateManagerInjectionTokens.IPropertyObserverProxyPairFactoryList, defaultPropertyObserverProxyPairFactoryList);
   options.bind(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProvider).to(ObjectObserverProxyPairFactoryProvider).inSingletonScope();
@@ -3348,6 +3718,7 @@ var RsXStateManagerModule = new ContainerModule((options) => {
     return () => context.get(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProvider);
   });
   options.bind(RsXStateManagerInjectionTokens.IStateManager).to(StateManager).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IWatchFactory).to(WatchFactory).inSingletonScope();
 });
 async function unloadRsXStateManagerModule() {
   await InjectionContainer.unload(RsXStateManagerModule);
@@ -3369,6 +3740,7 @@ export {
   IndexChangeSubscriptionManager,
   IndexObserverProxyPairFactory,
   IndexWatchRule,
+  IndexWatchRuleFactory,
   MapObserverProxyPairFactory,
   MapProxy,
   MapProxyFactory,
@@ -3392,6 +3764,7 @@ export {
   StateChangeSubscriptionManager,
   StateForObjectManager,
   StateManager,
+  WatchFactory,
   defaultObjectObserverProxyPairFactoryList,
   defaultPropertyObserverProxyPairFactoryList,
   unloadRsXStateManagerModule,