@blac/core 2.0.0-rc-10 → 2.0.0-rc-11

package/dist/index.es.js

@@ -1,15 +1,15 @@
-var M = Object.defineProperty;
-var P = (u, e, t) => e in u ? M(u, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : u[e] = t;
-var n = (u, e, t) => P(u, typeof e != "symbol" ? e + "" : e, t);
-class E {
+var E = Object.defineProperty;
+var O = (c, e, t) => e in c ? E(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var i = (c, e, t) => O(c, typeof e != "symbol" ? e + "" : e, t);
+class V {
   /**
    * Creates a new BlacObservable instance
    * @param bloc - The Bloc instance to observe
    */
   constructor(e) {
     /** The Bloc instance this observable is associated with */
-    n(this, "bloc");
-    n(this, "_observers", /* @__PURE__ */ new Set());
+    i(this, "bloc");
+    i(this, "_observers", /* @__PURE__ */ new Set());
     this.bloc = e;
   }
   /**
@@ -33,23 +33,23 @@ class E {
    */
   subscribe(e) {
     const t = this.bloc._disposalState;
-    return t === _.DISPOSED || t === _.DISPOSING ? (f.log(
+    return t === _.DISPOSED || t === _.DISPOSING ? (d.log(
       "BlacObservable.subscribe: Cannot subscribe to disposed/disposing bloc.",
       this.bloc,
       e
     ), () => {
-    }) : (f.log(
+    }) : (d.log(
       "BlacObservable.subscribe: Subscribing observer.",
       this.bloc,
       e
-    ), this._observers.add(e), t === _.DISPOSAL_REQUESTED && (f.log(
+    ), this._observers.add(e), t === _.DISPOSAL_REQUESTED && (d.log(
       "BlacObservable.subscribe: Cancelling disposal due to new subscription.",
       this.bloc
     ), this.bloc._atomicStateTransition(
       _.DISPOSAL_REQUESTED,
       _.ACTIVE
     )), () => {
-      f.log(
+      d.log(
         "BlacObservable.subscribe: Unsubscribing observer.",
         this.bloc,
         e
@@ -61,7 +61,7 @@ class E {
    * @param observer - The observer to unsubscribe
    */
   unsubscribe(e) {
-    this._observers.delete(e), this.size === 0 && (f.log("BlacObservable.unsubscribe: No observers left.", this.bloc), this.bloc._consumers.size === 0 && !this.bloc._keepAlive && this.bloc._disposalState === _.ACTIVE && (f.log(
+    this._observers.delete(e), this.size === 0 && (d.log("BlacObservable.unsubscribe: No observers left.", this.bloc), this.bloc._consumers.size === 0 && !this.bloc._keepAlive && this.bloc._disposalState === _.ACTIVE && (d.log(
       `[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`
     ), this.bloc._scheduleDisposal()));
   }
@@ -72,28 +72,28 @@ class E {
    * @param action - Optional action that triggered the state change
    */
   notify(e, t, s) {
-    this._observers.forEach((i) => {
+    this._observers.forEach((n) => {
       let r = !1;
-      if (i.dependencyArray) {
-        const a = i.lastState, o = i.dependencyArray(
+      if (n.dependencyArray) {
+        const o = n.lastState, a = n.dependencyArray(
           e,
           t,
           this.bloc
         );
-        if (!a)
+        if (!o)
           r = !0;
-        else if (a.length !== o.length)
+        else if (o.length !== a.length)
           r = !0;
         else
-          for (let l = 0; l < o.length; l++)
-            if (!Object.is(a[l], o[l])) {
+          for (let u = 0; u < a.length; u++)
+            if (!Object.is(o[u], a[u])) {
               r = !0;
               break;
             }
-        i.lastState = o;
+        n.lastState = a;
       } else
         r = !0;
-      r && i.fn(e, t, s);
+      r && n.fn(e, t, s);
     });
   }
   /**
@@ -103,14 +103,14 @@ class E {
     this._observers.clear();
   }
 }
-function R() {
-  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(u) {
+function $() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
     const e = Math.random() * 16 | 0;
-    return (u === "x" ? e : e & 3 | 8).toString(16);
+    return (c === "x" ? e : e & 3 | 8).toString(16);
   });
 }
-var _ = /* @__PURE__ */ ((u) => (u.ACTIVE = "active", u.DISPOSAL_REQUESTED = "disposal_requested", u.DISPOSING = "disposing", u.DISPOSED = "disposed", u))(_ || {});
-class k {
+var _ = /* @__PURE__ */ ((c) => (c.ACTIVE = "active", c.DISPOSAL_REQUESTED = "disposal_requested", c.DISPOSING = "disposing", c.DISPOSED = "disposed", c))(_ || {});
+class x {
   /**
    * Creates a new BlocBase instance with the given initial state.
    * Sets up the observer, registers with the Blac manager, and initializes addons.
@@ -118,88 +118,88 @@ class k {
    * @param initialState The initial state value for this Bloc
    */
   constructor(e) {
-    n(this, "uid", R());
+    i(this, "uid", $());
     /**
      * Defines how dependencies are selected from the state for efficient updates.
      * When provided, observers will only be notified when selected dependencies change.
      */
-    n(this, "defaultDependencySelector");
+    i(this, "defaultDependencySelector");
     /**
      * @internal
      * Indicates if this specific Bloc instance is isolated from others of the same type.
      */
-    n(this, "_isolated", !1);
+    i(this, "_isolated", !1);
     /**
      * @internal
      * Observable responsible for managing state listeners and notifying consumers.
      */
-    n(this, "_observer");
+    i(this, "_observer");
     /**
      * The unique identifier for this Bloc instance.
      * Defaults to the class name, but can be customized.
      */
-    n(this, "_id");
+    i(this, "_id");
     /**
      * @internal
      * Reference string used internally for tracking and debugging.
      */
-    n(this, "_instanceRef");
+    i(this, "_instanceRef");
     /**
      * @internal
      * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
      */
-    n(this, "_keepAlive", !1);
+    i(this, "_keepAlive", !1);
     /**
      * @readonly
      * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
      */
-    n(this, "_createdAt", Date.now());
+    i(this, "_createdAt", Date.now());
     /**
      * @internal
      * Atomic disposal state to prevent race conditions
      */
-    n(this, "_disposalState", "active");
+    i(this, "_disposalState", "active");
     /**
      * @internal
      * Timestamp when disposal was requested (for React Strict Mode grace period)
      */
-    n(this, "_disposalRequestTime", 0);
+    i(this, "_disposalRequestTime", 0);
     /**
      * @internal
      * The current state of the Bloc.
      */
-    n(this, "_state");
+    i(this, "_state");
     /**
      * @internal
      * The previous state of the Bloc, maintained for comparison and history.
      */
-    n(this, "_oldState");
+    i(this, "_oldState");
     /**
      * Props passed during Bloc instance creation.
      * Can be used to configure or parameterize the Bloc's behavior.
      */
-    n(this, "props", null);
+    i(this, "props", null);
     /**
      * @internal
      * Flag to prevent batching race conditions
      */
-    n(this, "_batchingLock", !1);
+    i(this, "_batchingLock", !1);
     /**
      * @internal
      * Pending batched updates
      */
-    n(this, "_pendingUpdates", []);
+    i(this, "_pendingUpdates", []);
     /**
      * @internal
      * Map of consumer IDs to their WeakRef objects for proper cleanup
      */
-    n(this, "_consumerRefs", /* @__PURE__ */ new Map());
+    i(this, "_consumerRefs", /* @__PURE__ */ new Map());
     /**
      * @internal
      * Validates that all consumer references are still alive
      * Removes dead consumers automatically
      */
-    n(this, "_validateConsumers", () => {
+    i(this, "_validateConsumers", () => {
       const e = [];
       for (const [t, s] of this._consumerRefs)
         s.deref() === void 0 && e.push(t);
@@ -214,7 +214,7 @@ class k {
      *
      * @param id The new ID to assign to this Bloc instance
      */
-    n(this, "_updateId", (e) => {
+    i(this, "_updateId", (e) => {
       const t = this._id;
       !e || e === t || (this._id = e);
     });
@@ -222,12 +222,12 @@ class k {
      * @internal
      * Optional function to be called when the Bloc is disposed.
      */
-    n(this, "onDispose");
+    i(this, "onDispose");
     /**
      * @internal
      * Set of consumer IDs currently listening to this Bloc's state changes.
      */
-    n(this, "_consumers", /* @__PURE__ */ new Set());
+    i(this, "_consumers", /* @__PURE__ */ new Set());
     /**
      * @internal
      * Registers a new consumer to this Bloc instance.
@@ -236,7 +236,7 @@ class k {
      * @param consumerId The unique ID of the consumer being added
      * @param consumerRef Optional reference to the consumer object for cleanup validation
      */
-    n(this, "_addConsumer", (e, t) => {
+    i(this, "_addConsumer", (e, t) => {
       var s;
       return this._disposalState !== "active" ? !1 : (this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.set(e, new WeakRef(t)), (s = globalThis.Blac) == null || s.log(
         `[${this._name}:${this._id}] Consumer added. Total consumers: ${this._consumers.size}`
@@ -249,7 +249,7 @@ class k {
      *
      * @param consumerId The unique ID of the consumer being removed
      */
-    n(this, "_removeConsumer", (e) => {
+    i(this, "_removeConsumer", (e) => {
       var t, s;
       this._consumers.has(e) && (this._consumers.delete(e), this._consumerRefs.delete(e), (t = globalThis.Blac) == null || t.log(
         `[${this._name}:${this._id}] Consumer removed. Remaining consumers: ${this._consumers.size}, keepAlive: ${this._keepAlive}`
@@ -261,13 +261,13 @@ class k {
      * @internal
      * Handler function for disposal (can be set by Blac manager)
      */
-    n(this, "_disposalHandler");
-    n(this, "lastUpdate", Date.now());
+    i(this, "_disposalHandler");
+    i(this, "lastUpdate", Date.now());
     /**
      * @internal
      * Flag to indicate if batching is enabled for this bloc
      */
-    n(this, "_batchingEnabled", !1);
+    i(this, "_batchingEnabled", !1);
     /**
      * @internal
      * Updates the state and notifies all observers of the change.
@@ -276,7 +276,7 @@ class k {
      * @param oldState The previous state for comparison
      * @param action Optional metadata about what caused the state change
      */
-    n(this, "_pushState", (e, t, s) => {
+    i(this, "_pushState", (e, t, s) => {
       if (e !== void 0 && !(s !== void 0 && typeof s != "object" && typeof s != "function")) {
         if (this._batchingEnabled) {
           this._pendingUpdates.push({ newState: e, oldState: t, action: s }), this._oldState = t, this._state = e;
@@ -289,7 +289,7 @@ class k {
      * Enables batching for multiple state updates
      * @param batchFn Function to execute with batching enabled
      */
-    n(this, "batch", (e) => {
+    i(this, "batch", (e) => {
       if (this._batchingLock)
         return e();
       this._batchingLock = !0, this._batchingEnabled = !0, this._pendingUpdates = [];
@@ -308,7 +308,7 @@ class k {
         this._batchingEnabled = !1, this._batchingLock = !1, this._pendingUpdates = [];
       }
     });
-    this._state = e, this._observer = new E(this), this._id = this.constructor.name;
+    this._state = e, this._observer = new V(this), this._id = this.constructor.name;
     const t = this.constructor;
     this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1;
   }
@@ -348,18 +348,18 @@ class k {
    * @returns Result indicating success/failure and state information
    */
   _atomicStateTransition(e, t) {
-    var s, i, r, a;
+    var s, n, r, o;
     if (this._disposalState === e) {
-      const o = this._disposalState;
-      return this._disposalState = t, (s = globalThis.Blac) != null && s.enableLog && ((i = globalThis.Blac) == null || i.log(
-        `[${this._name}:${this._id}] State transition: ${o} -> ${t} (SUCCESS)`
+      const a = this._disposalState;
+      return this._disposalState = t, (s = globalThis.Blac) != null && s.enableLog && ((n = globalThis.Blac) == null || n.log(
+        `[${this._name}:${this._id}] State transition: ${a} -> ${t} (SUCCESS)`
       )), {
         success: !0,
         currentState: t,
-        previousState: o
+        previousState: a
       };
     }
-    return (r = globalThis.Blac) != null && r.enableLog && ((a = globalThis.Blac) == null || a.log(
+    return (r = globalThis.Blac) != null && r.enableLog && ((o = globalThis.Blac) == null || o.log(
       `[${this._name}:${this._id}] State transition failed: expected ${e}, current ${this._disposalState}`
     )), {
       success: !1,
@@ -436,101 +436,101 @@ class k {
  * Use this when state should not be shared between components.
  * @default false
  */
-n(k, "isolated", !1), /**
+i(x, "isolated", !1), /**
  * When true, the Bloc instance persists even when there are no active consumers.
  * Useful for maintaining state between component unmount/remount cycles.
  * @default false
  */
-n(k, "keepAlive", !1);
-const I = class I {
+i(x, "keepAlive", !1);
+const y = class y {
   getInstance() {
-    return I._instance || (I._instance = new f({
+    return y._instance || (y._instance = new d({
       __unsafe_ignore_singleton: !0
-    })), I._instance;
+    })), y._instance;
   }
   setInstance(e) {
-    I._instance = e;
+    y._instance = e;
   }
   resetInstance() {
-    const e = I._instance;
-    if (I._instance = new f({
+    const e = y._instance;
+    if (y._instance = new d({
       __unsafe_ignore_singleton: !0
     }), e)
       for (const t of e.keepAliveBlocs)
-        I._instance.keepAliveBlocs.add(t), I._instance.uidRegistry.set(t.uid, t);
+        y._instance.keepAliveBlocs.add(t), y._instance.uidRegistry.set(t.uid, t);
   }
 };
-n(I, "_instance");
-let T = I, b = new T();
-function L(u) {
-  b = u;
+i(y, "_instance");
+let C = y, S = new C();
+function q(c) {
+  S = c;
 }
-const c = class c {
+const l = class l {
   /**
    * Creates a new Blac instance.
    * @param options - Configuration options including singleton control
    */
   constructor(e = {}) {
     /** Timestamp when the instance was created */
-    n(this, "createdAt", Date.now());
+    i(this, "createdAt", Date.now());
     /** Map storing all registered bloc instances by their class name and ID */
-    n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
+    i(this, "blocInstanceMap", /* @__PURE__ */ new Map());
     /** Map storing isolated bloc instances grouped by their constructor */
     // Using BlocConstructor<BlocBase<unknown>> would break type inference when storing
     // different bloc types in the same map. The 'any' allows proper polymorphic storage
     // while maintaining type safety at usage sites through the BlocConstructor constraint.
-    n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
+    i(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
     /** Map for O(1) lookup of isolated blocs by UID */
-    n(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
+    i(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
     /** Map tracking UIDs to prevent memory leaks */
-    n(this, "uidRegistry", /* @__PURE__ */ new Map());
+    i(this, "uidRegistry", /* @__PURE__ */ new Map());
     /** Set of keep-alive blocs for controlled cleanup */
-    n(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
+    i(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
     /** Flag to control whether changes should be posted to document */
-    n(this, "postChangesToDocument", !1);
+    i(this, "postChangesToDocument", !1);
     /**
      * Logs messages to console when logging is enabled
      * @param args - Arguments to log
      */
-    n(this, "log", (...e) => {
-      c.logSpy && c.logSpy(e), c.enableLog && c.logLevel, c.enableLog && c.logLevel;
+    i(this, "log", (...e) => {
+      l.logSpy && l.logSpy(e), l.enableLog && l.logLevel, l.enableLog && l.logLevel;
     });
     /**
      * Logs a warning message
      * @param message - Warning message
      * @param args - Additional arguments
      */
-    n(this, "warn", (e, ...t) => {
-      c.enableLog;
+    i(this, "warn", (e, ...t) => {
+      l.enableLog;
     });
     /**
      * Logs an error message
      * @param message - Error message
      * @param args - Additional arguments
      */
-    n(this, "error", (e, ...t) => {
-      c.enableLog;
+    i(this, "error", (e, ...t) => {
+      l.enableLog;
     });
     /**
      * Resets the Blac instance to a new one, disposing non-keepAlive blocs
      * from the old instance.
      */
-    n(this, "resetInstance", () => {
+    i(this, "resetInstance", () => {
       this.log("Reset Blac instance");
       const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
       e.forEach((s) => {
         !s._keepAlive && s._disposalState === _.ACTIVE && this.disposeBloc(s);
       }), t.forEach((s) => {
-        s.forEach((i) => {
-          !i._keepAlive && i._disposalState === _.ACTIVE && this.disposeBloc(i);
+        s.forEach((n) => {
+          !n._keepAlive && n._disposalState === _.ACTIVE && this.disposeBloc(n);
         });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), b.resetInstance();
+      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), S.resetInstance();
     });
     /**
      * Disposes of a bloc instance by removing it from the appropriate registry
      * @param bloc - The bloc instance to dispose
      */
-    n(this, "disposeBloc", (e) => {
+    i(this, "disposeBloc", (e) => {
       const t = e._disposalState;
       if (![
         _.ACTIVE,
@@ -541,12 +541,12 @@ const c = class c {
         );
         return;
       }
-      const i = e.constructor, r = this.createBlocInstanceMapKey(e._name, e._id);
+      const n = e.constructor, r = this.createBlocInstanceMapKey(e._name, e._id);
       this.log(
-        `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(i.isolated)}`
-      ), e._dispose(), i.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(r)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
+        `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(n.isolated)}`
+      ), e._dispose(), n.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(r)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
     });
-    n(this, "activateBloc", (e) => {
+    i(this, "activateBloc", (e) => {
       if (e._disposalState !== _.ACTIVE) {
         this.log(
           `[${e._name}:${String(e._id)}] activateBloc called on disposed bloc. Ignoring.`
@@ -569,41 +569,41 @@ const c = class c {
      *   - instanceRef: Optional reference string for the instance
      * @returns The bloc instance
      */
-    n(this, "getBloc", (e, t = {}) => {
-      const { id: s, forceNewInstance: i } = t, r = e, a = s ?? e.name;
-      if (this.log(`[${e.name}:${String(a)}] (getBloc) Called:`, {
+    i(this, "getBloc", (e, t = {}) => {
+      const { id: s, forceNewInstance: n } = t, r = e, o = s ?? e.name;
+      if (this.log(`[${e.name}:${String(o)}] (getBloc) Called:`, {
         options: t,
         base: r
-      }), !i)
+      }), !n)
         if (r.isolated) {
-          const l = this.findIsolatedBlocInstance(
+          const u = this.findIsolatedBlocInstance(
             e,
-            t.instanceRef ?? a
+            t.instanceRef ?? o
           );
-          if (l)
-            return l;
+          if (u)
+            return u;
           if (t.throwIfNotFound)
             throw new Error(`Isolated bloc ${e.name} not found`);
         } else {
-          const l = this.findRegisteredBlocInstance(
+          const u = this.findRegisteredBlocInstance(
             e,
-            a
+            o
           );
-          if (l)
-            return l;
+          if (u)
+            return u;
           if (t.throwIfNotFound)
             throw new Error(`Registered bloc ${e.name} not found`);
         }
-      const o = this.createNewBlocInstance(e, a, t);
+      const a = this.createNewBlocInstance(e, o, t);
       if (this.log(
-        `[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`,
+        `[${e.name}:${String(o)}] (getBloc) No existing instance found. Creating new one.`,
         t,
-        o
-      ), !o)
+        a
+      ), !a)
         throw new Error(
           `[getBloc] Failed to create bloc instance for ${e.name}. This should never happen.`
         );
-      return o;
+      return a;
     });
     /**
      * Gets a bloc instance or throws an error if it doesn't exist
@@ -613,8 +613,8 @@ const c = class c {
      *   - props: Properties to pass to the bloc constructor
      *   - instanceRef: Optional reference string for the instance
      */
-    n(this, "getBlocOrThrow", (e, t = {}) => {
-      const s = e.isolated, i = t.id || e.name, r = s ? this.findIsolatedBlocInstance(e, i) : this.findRegisteredBlocInstance(e, i);
+    i(this, "getBlocOrThrow", (e, t = {}) => {
+      const s = e.isolated, n = t.id || e.name, r = s ? this.findIsolatedBlocInstance(e, n) : this.findRegisteredBlocInstance(e, n);
       if (r)
         return r;
       throw new Error(`Bloc ${e.name} not found`);
@@ -626,13 +626,13 @@ const c = class c {
      *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
      * @returns Array of matching bloc instances
      */
-    n(this, "getAllBlocs", (e, t = {}) => {
+    i(this, "getAllBlocs", (e, t = {}) => {
       const s = [];
-      if (this.blocInstanceMap.forEach((i) => {
-        i.constructor === e && s.push(i);
+      if (this.blocInstanceMap.forEach((n) => {
+        n.constructor === e && s.push(n);
       }), t.searchIsolated !== !1) {
-        const i = this.isolatedBlocMap.get(e);
-        i && s.push(...i.map((r) => r));
+        const n = this.isolatedBlocMap.get(e);
+        n && s.push(...n.map((r) => r));
       }
       return s;
     });
@@ -640,7 +640,7 @@ const c = class c {
      * Disposes all keep-alive blocs of a specific type
      * @param blocClass - The bloc class to dispose
      */
-    n(this, "disposeKeepAliveBlocs", (e) => {
+    i(this, "disposeKeepAliveBlocs", (e) => {
       const t = [];
       for (const s of this.keepAliveBlocs)
         (!e || s.constructor === e) && t.push(s);
@@ -650,19 +650,19 @@ const c = class c {
      * Disposes all blocs matching a pattern
      * @param predicate - Function to test each bloc for disposal
      */
-    n(this, "disposeBlocs", (e) => {
+    i(this, "disposeBlocs", (e) => {
       const t = [];
       for (const s of this.blocInstanceMap.values())
         e(s) && t.push(s);
       for (const s of this.isolatedBlocMap.values())
-        for (const i of s)
-          e(i) && t.push(i);
+        for (const n of s)
+          e(n) && t.push(n);
       t.forEach((s) => s._dispose());
     });
     /**
      * Gets memory usage statistics for debugging
      */
-    n(this, "getMemoryStats", () => ({
+    i(this, "getMemoryStats", () => ({
       totalBlocs: this.uidRegistry.size,
       registeredBlocs: this.blocInstanceMap.size,
       isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce(
@@ -675,7 +675,7 @@ const c = class c {
     /**
      * Validates consumer references and cleans up orphaned consumers
      */
-    n(this, "validateConsumers", () => {
+    i(this, "validateConsumers", () => {
       for (const e of this.uidRegistry.values())
         e._validateConsumers(), e._consumers.size === 0 && !e._keepAlive && e._disposalState === _.ACTIVE && setTimeout(() => {
           e._consumers.size === 0 && !e._keepAlive && e._disposalState === _.ACTIVE && this.disposeBloc(e);
@@ -683,33 +683,52 @@ const c = class c {
     });
     const { __unsafe_ignore_singleton: t = !1 } = e;
     if (!t)
-      return c.instance;
-    b.setInstance(this);
+      return l.instance;
+    S.setInstance(this);
   }
   static get instance() {
-    return b.getInstance();
+    return S.getInstance();
   }
   static get getAllBlocs() {
-    return c.instance.getAllBlocs;
+    return l.instance.getAllBlocs;
+  }
+  /** Get current configuration */
+  static get config() {
+    return { ...this._config };
+  }
+  /**
+   * Set or update Blac configuration
+   * @param config - Partial configuration to merge with existing config
+   * @throws Error if configuration is invalid
+   */
+  static setConfig(e) {
+    if (e.proxyDependencyTracking !== void 0 && typeof e.proxyDependencyTracking != "boolean")
+      throw new Error("BlacConfig.proxyDependencyTracking must be a boolean");
+    if (e.exposeBlacInstance !== void 0 && typeof e.exposeBlacInstance != "boolean")
+      throw new Error("BlacConfig.exposeBlacInstance must be a boolean");
+    this._config = {
+      ...this._config,
+      ...e
+    }, this.enableLog && this.instance.log("Blac config updated:", this._config);
   }
   static get log() {
-    return c.instance.log;
+    return l.instance.log;
   }
   /**
    * Gets the current Blac instance
    * @returns The Blac instance
    */
   static getInstance() {
-    return b.getInstance();
+    return S.getInstance();
   }
   static get warn() {
-    return c.instance.warn;
+    return l.instance.warn;
   }
   static get error() {
-    return c.instance.error;
+    return l.instance.error;
   }
   static get disposeBloc() {
-    return c.instance.disposeBloc;
+    return l.instance.disposeBloc;
   }
   /**
    * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
@@ -744,8 +763,8 @@ const c = class c {
    */
   findRegisteredBlocInstance(e, t) {
     if (e.isolated) return;
-    const i = this.createBlocInstanceMapKey(e.name, t);
-    return this.blocInstanceMap.get(i);
+    const n = this.createBlocInstanceMapKey(e.name, t);
+    return this.blocInstanceMap.get(n);
   }
   /**
    * Registers an isolated bloc instance in the isolated registry
@@ -761,14 +780,14 @@ const c = class c {
    */
   unregisterIsolatedBlocInstance(e) {
     const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    let i = !1;
+    let n = !1;
     if (s) {
-      const a = s.findIndex((o) => o.uid === e.uid);
-      a !== -1 && (s.splice(a, 1), i = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
+      const o = s.findIndex((a) => a.uid === e.uid);
+      o !== -1 && (s.splice(o, 1), n = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
     }
     const r = this.isolatedBlocIndex.delete(e.uid);
-    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), i !== r && this.warn(
-      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${i}, Index removal: ${r}`
+    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), n !== r && this.warn(
+      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${n}, Index removal: ${r}`
     );
   }
   /**
@@ -776,8 +795,8 @@ const c = class c {
    */
   findIsolatedBlocInstance(e, t) {
     if (!e.isolated) return;
-    const i = this.isolatedBlocMap.get(e);
-    return i ? i.find((a) => a._id === t) : void 0;
+    const n = this.isolatedBlocMap.get(e);
+    return n ? n.find((o) => o._id === t) : void 0;
   }
   /**
    * Finds an isolated bloc instance by UID (O(1) lookup)
@@ -794,59 +813,60 @@ const c = class c {
    * @returns The newly created bloc instance
    */
   createNewBlocInstance(e, t, s = {}) {
-    const { props: i, instanceRef: r } = s, a = new e(i);
-    return a._instanceRef = r, a.props = i || null, a._updateId(t), a._setDisposalHandler((o) => this.disposeBloc(o)), a.isIsolated ? (this.registerIsolatedBlocInstance(a), a) : (this.registerBlocInstance(a), a);
+    const { props: n, instanceRef: r } = s, o = new e(n);
+    return o._instanceRef = r, o.props = n || null, o._updateId(t), o._setDisposalHandler((a) => this.disposeBloc(a)), o.isIsolated ? (this.registerIsolatedBlocInstance(o), o) : (this.registerBlocInstance(o), o);
   }
   static get activateBloc() {
-    return c.instance.activateBloc;
+    return l.instance.activateBloc;
   }
   static get getBloc() {
-    return c.instance.getBloc;
+    return l.instance.getBloc;
   }
   static get getBlocOrThrow() {
-    return c.instance.getBlocOrThrow;
+    return l.instance.getBlocOrThrow;
   }
   static get disposeKeepAliveBlocs() {
-    return c.instance.disposeKeepAliveBlocs;
+    return l.instance.disposeKeepAliveBlocs;
   }
   static get disposeBlocs() {
-    return c.instance.disposeBlocs;
+    return l.instance.disposeBlocs;
   }
   static get getMemoryStats() {
-    return c.instance.getMemoryStats;
+    return l.instance.getMemoryStats;
   }
   static get validateConsumers() {
-    return c.instance.validateConsumers;
+    return l.instance.validateConsumers;
   }
 };
-/** Flag to enable/disable logging */
-n(c, "enableLog", !1), n(c, "logLevel", "warn"), n(c, "logSpy", null), n(c, "resetInstance", () => {
-  b.resetInstance();
+/** Private static configuration */
+i(l, "_config", {
+  exposeBlacInstance: !1,
+  proxyDependencyTracking: !0
+}), /** Flag to enable/disable logging */
+i(l, "enableLog", !1), i(l, "logLevel", "warn"), i(l, "logSpy", null), i(l, "resetInstance", () => {
+  S.resetInstance();
 });
-let f = c;
-class O extends k {
+let d = l;
+class U extends x {
   constructor() {
     super(...arguments);
-    // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
-    // The handler's event parameter will be correctly typed to the specific EventConstructor
-    // by the 'on' method's signature.
-    n(this, "eventHandlers", /* @__PURE__ */ new Map());
+    i(this, "eventHandlers", /* @__PURE__ */ new Map());
     /**
      * @internal
      * Event queue to ensure sequential processing of async events
      */
-    n(this, "_eventQueue", []);
+    i(this, "_eventQueue", []);
     /**
      * @internal
      * Flag indicating if an event is currently being processed
      */
-    n(this, "_isProcessingEvent", !1);
+    i(this, "_isProcessingEvent", !1);
     /**
      * Dispatches an action/event to the Bloc.
      * Events are queued and processed sequentially to prevent race conditions.
      * @param action The action/event instance to be processed.
      */
-    n(this, "add", async (t) => {
+    i(this, "add", async (t) => {
       this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
     });
   }
@@ -858,7 +878,7 @@ class O extends k {
    *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
    */
   on(t, s) {
-    this.eventHandlers.has(t) && f.warn(
+    this.eventHandlers.has(t) && d.warn(
       `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
       t,
@@ -887,44 +907,53 @@ class O extends k {
    * Processes a single event
    */
   async _processEvent(t) {
-    const s = t.constructor, i = this.eventHandlers.get(s);
-    if (i) {
-      const r = (a) => {
-        const o = this.state;
-        this._pushState(a, o, t);
+    const s = t.constructor, n = this.eventHandlers.get(s);
+    if (n) {
+      const r = (o) => {
+        const a = this.state;
+        this._pushState(o, a, t);
       };
       try {
-        await i(t, r);
-      } catch (a) {
-        const o = t.constructor.name || "UnnamedConstructor", l = {
+        await n(t, r);
+      } catch (o) {
+        const a = t.constructor.name || "UnnamedConstructor", u = {
           blocName: this._name,
           blocId: String(this._id),
-          eventType: o,
+          eventType: a,
           currentState: this.state,
           action: t,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        if (f.error(
-          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${o}':`,
-          a,
+        if (d.error(
+          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${a}':`,
+          o,
           "Context:",
-          l
-        ), a instanceof Error && a.name === "CriticalError")
-          throw a;
+          u
+        ), o instanceof Error && o.name === "CriticalError")
+          throw o;
       }
     } else {
       const r = t.constructor.name || "UnnamedConstructor";
-      f.warn(
+      d.warn(
         `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${r}'.`,
         "Registered handlers:",
-        Array.from(this.eventHandlers.keys()).map((a) => a.name),
+        Array.from(this.eventHandlers.keys()).map((o) => o.name),
         "Action was:",
         t
       );
     }
   }
 }
-class V extends k {
+class H extends x {
+  /**
+   * @internal
+   * Protected method for useBloc to call
+   */
+  _updateProps(e) {
+    var s;
+    const t = this.props;
+    this.props = e, (s = this.onPropsChanged) == null || s.call(this, t, e);
+  }
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),
@@ -947,7 +976,7 @@ class V extends k {
    */
   patch(e, t = !1) {
     if (typeof this.state != "object" || this.state === null) {
-      f.warn(
+      d.warn(
         "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
       );
       return;
@@ -956,10 +985,10 @@ class V extends k {
     if (t)
       s = !0;
     else
-      for (const i in e)
-        if (Object.prototype.hasOwnProperty.call(e, i)) {
-          const a = this.state[i];
-          if (!Object.is(e[i], a)) {
+      for (const n in e)
+        if (Object.prototype.hasOwnProperty.call(e, n)) {
+          const o = this.state[n];
+          if (!Object.is(e[n], o)) {
             s = !0;
             break;
           }
@@ -970,69 +999,89 @@ class V extends k {
     });
   }
 }
-class U {
+class N {
+  constructor(e) {
+    this.props = e;
+  }
+}
+function j(c, e) {
+  if (Object.is(c, e))
+    return !0;
+  if (typeof c != "object" || c === null || typeof e != "object" || e === null)
+    return !1;
+  const t = Object.keys(c), s = Object.keys(e);
+  if (t.length !== s.length)
+    return !1;
+  for (let n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (!Object.prototype.hasOwnProperty.call(e, r) || !Object.is(c[r], e[r]))
+      return !1;
+  }
+  return !0;
+}
+class L {
   /**
    * Sets up a clean test environment
    */
   static setUp() {
-    this.originalInstance = f.instance, f.resetInstance(), f.enableLog = !1;
+    this.originalInstance = d.instance, d.resetInstance(), d.enableLog = !1;
   }
   /**
    * Tears down the test environment and restores original state
    */
   static tearDown() {
-    f.resetInstance();
+    d.resetInstance();
   }
   /**
    * Creates a test bloc with automatic cleanup
    */
   static createBloc(e, ...t) {
     const s = new e(...t);
-    return f.activateBloc(s), s;
+    return d.activateBloc(s), s;
   }
   /**
    * Waits for a bloc to emit a specific state
    */
   static async waitForState(e, t, s = 5e3) {
-    return new Promise((i, r) => {
-      const a = setTimeout(() => {
+    return new Promise((n, r) => {
+      const o = setTimeout(() => {
         r(
           new Error(
             `Timeout waiting for state matching predicate after ${s}ms`
           )
         );
-      }, s), o = e._observer.subscribe({
+      }, s), a = e._observer.subscribe({
         id: `test-waiter-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        fn: (l) => {
-          t(l) && (clearTimeout(a), o(), i(l));
+        fn: (u) => {
+          t(u) && (clearTimeout(o), a(), n(u));
         }
       });
-      t(e.state) && (clearTimeout(a), o(), i(e.state));
+      t(e.state) && (clearTimeout(o), a(), n(e.state));
     });
   }
   /**
    * Expects a bloc to emit specific states in order
    */
   static async expectStates(e, t, s = 5e3) {
-    const i = [];
-    return new Promise((r, a) => {
-      const o = setTimeout(() => {
-        a(
+    const n = [];
+    return new Promise((r, o) => {
+      const a = setTimeout(() => {
+        o(
           new Error(
-            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(i)}`
+            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(n)}`
           )
         );
-      }, s), l = e._observer.subscribe({
+      }, s), u = e._observer.subscribe({
         id: `test-expecter-${crypto.randomUUID()}`,
         fn: (p) => {
-          if (i.push(p), i.length === t.length) {
-            clearTimeout(o), l();
-            for (let d = 0; d < t.length; d++) {
-              const m = t[d], v = i[d];
-              if (JSON.stringify(m) !== JSON.stringify(v)) {
-                a(
+          if (n.push(p), n.length === t.length) {
+            clearTimeout(a), u();
+            for (let h = 0; h < t.length; h++) {
+              const m = t[h], I = n[h];
+              if (JSON.stringify(m) !== JSON.stringify(I)) {
+                o(
                   new Error(
-                    `State mismatch at index ${d}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(v)}`
+                    `State mismatch at index ${h}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(I)}`
                   )
                 );
                 return;
@@ -1045,11 +1094,11 @@ class U {
     });
   }
 }
-n(U, "originalInstance");
-class z extends O {
+i(L, "originalInstance");
+class Q extends U {
   constructor(t) {
     super(t);
-    n(this, "mockHandlers", /* @__PURE__ */ new Map());
+    i(this, "mockHandlers", /* @__PURE__ */ new Map());
   }
   /**
    * Mock an event handler for testing
@@ -1070,10 +1119,10 @@ class z extends O {
     return this.eventHandlers.has(t);
   }
 }
-class j extends V {
+class W extends H {
   constructor(t) {
     super(t);
-    n(this, "stateHistory", []);
+    i(this, "stateHistory", []);
     this.stateHistory.push(t);
   }
   /**
@@ -1095,16 +1144,16 @@ class j extends V {
     this.stateHistory = [this.state];
   }
 }
-class K {
+class F {
   constructor() {
-    n(this, "initialStats");
-    this.initialStats = f.getMemoryStats();
+    i(this, "initialStats");
+    this.initialStats = d.getMemoryStats();
   }
   /**
    * Check for memory leaks and return a report
    */
   checkForLeaks() {
-    const e = f.getMemoryStats(), t = e.registeredBlocs > this.initialStats.registeredBlocs || e.isolatedBlocs > this.initialStats.isolatedBlocs || e.keepAliveBlocs > this.initialStats.keepAliveBlocs, s = `
+    const e = d.getMemoryStats(), t = e.registeredBlocs > this.initialStats.registeredBlocs || e.isolatedBlocs > this.initialStats.isolatedBlocs || e.keepAliveBlocs > this.initialStats.keepAliveBlocs, s = `
 Memory Leak Detection Report:
 - Initial registered blocs: ${this.initialStats.registeredBlocs}
 - Current registered blocs: ${e.registeredBlocs}
@@ -1121,11 +1170,11 @@ Memory Leak Detection Report:
     };
   }
 }
-class H {
+class z {
   constructor() {
-    n(this, "consumers", /* @__PURE__ */ new WeakMap());
-    n(this, "registrationCount", 0);
-    n(this, "activeConsumers", 0);
+    i(this, "consumers", /* @__PURE__ */ new WeakMap());
+    i(this, "registrationCount", 0);
+    i(this, "activeConsumers", 0);
   }
   register(e, t) {
     this.registrationCount++, this.consumers.get(e) || this.activeConsumers++, this.consumers.set(e, {
@@ -1144,11 +1193,11 @@ class H {
   unregister(e) {
     e && this.consumers.get(e) && (this.consumers.delete(e), this.activeConsumers = Math.max(0, this.activeConsumers - 1));
   }
-  trackAccess(e, t, s, i) {
+  trackAccess(e, t, s, n) {
     const r = this.consumers.get(e);
     if (!r) return;
-    const a = Date.now();
-    r.firstAccessTime || (r.firstAccessTime = a), r.accessCount++, r.lastAccessTime = a, t === "state" ? (r.stateAccesses.add(s), i !== void 0 && r.stateValues.set(s, { value: i, lastAccessTime: a })) : (r.classAccesses.add(s), i !== void 0 && r.classValues.set(s, { value: i, lastAccessTime: a }));
+    const o = Date.now();
+    r.firstAccessTime || (r.firstAccessTime = o), r.accessCount++, r.lastAccessTime = o, t === "state" ? (r.stateAccesses.add(s), n !== void 0 && r.stateValues.set(s, { value: n, lastAccessTime: o })) : (r.classAccesses.add(s), n !== void 0 && r.classValues.set(s, { value: n, lastAccessTime: o }));
   }
   resetTracking(e) {
     const t = this.consumers.get(e);
@@ -1162,28 +1211,28 @@ class H {
     } : null;
   }
   hasValuesChanged(e, t, s) {
-    const i = this.consumers.get(e);
-    if (!i) return !0;
+    const n = this.consumers.get(e);
+    if (!n) return !0;
     let r = !1;
-    const a = Date.now();
-    if (i.stateValues.size === 0 && i.classValues.size === 0 && (i.stateAccesses.size > 0 || i.classAccesses.size > 0))
+    const o = Date.now();
+    if (n.stateValues.size === 0 && n.classValues.size === 0 && (n.stateAccesses.size > 0 || n.classAccesses.size > 0))
       return !0;
-    for (const [o, l] of i.stateValues)
+    for (const [a, u] of n.stateValues)
       try {
-        const p = this.getValueAtPath(t, o);
-        p !== l.value && (i.stateValues.set(o, {
+        const p = this.getValueAtPath(t, a);
+        p !== u.value && (n.stateValues.set(a, {
           value: p,
-          lastAccessTime: a
+          lastAccessTime: o
         }), r = !0);
       } catch {
         r = !0;
       }
-    for (const [o, l] of i.classValues)
+    for (const [a, u] of n.classValues)
       try {
-        const p = this.getValueAtPath(s, o);
-        p !== l.value && (i.classValues.set(o, {
+        const p = this.getValueAtPath(s, a);
+        p !== u.value && (n.classValues.set(a, {
           value: p,
-          lastAccessTime: a
+          lastAccessTime: o
         }), r = !0);
       } catch {
         r = !0;
@@ -1193,10 +1242,10 @@ class H {
   shouldNotifyConsumer(e, t) {
     const s = this.consumers.get(e);
     if (!s) return !1;
-    for (const i of t) {
-      if (s.stateAccesses.has(i) || s.classAccesses.has(i)) return !0;
+    for (const n of t) {
+      if (s.stateAccesses.has(n) || s.classAccesses.has(n)) return !0;
       for (const r of s.stateAccesses)
-        if (i.startsWith(r + ".") || r.startsWith(i + "."))
+        if (n.startsWith(r + ".") || r.startsWith(n + "."))
           return !0;
     }
     return !1;
@@ -1223,16 +1272,16 @@ class H {
   }
   getValueAtPath(e, t) {
     const s = t.split(".");
-    let i = e;
+    let n = e;
     for (const r of s) {
-      if (i == null) return;
-      i = i[r];
+      if (n == null) return;
+      n = n[r];
     }
-    return i;
+    return n;
   }
 }
-const w = /* @__PURE__ */ new WeakMap();
-let h = {
+const k = /* @__PURE__ */ new WeakMap();
+let f = {
   stateProxiesCreated: 0,
   classProxiesCreated: 0,
   cacheHits: 0,
@@ -1242,44 +1291,44 @@ let h = {
   totalProxiesCreated: 0,
   createdAt: Date.now()
 };
-class y {
+class b {
   static createStateProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: i, path: r = "" } = e;
-    if (!s || !i || typeof t != "object" || t === null)
+    const { target: t, consumerRef: s, consumerTracker: n, path: r = "" } = e;
+    if (!s || !n || typeof t != "object" || t === null)
       return t;
-    let a = w.get(t);
-    a || (a = /* @__PURE__ */ new WeakMap(), w.set(t, a));
-    const o = a.get(s);
-    if (o)
-      return h.cacheHits++, o;
-    h.cacheMisses++;
-    const l = {
-      get(d, m) {
+    let o = k.get(t);
+    o || (o = /* @__PURE__ */ new WeakMap(), k.set(t, o));
+    const a = o.get(s);
+    if (a)
+      return f.cacheHits++, a;
+    f.cacheMisses++;
+    const u = {
+      get(h, m) {
         if (typeof m == "symbol" || m === "constructor")
-          return Reflect.get(d, m);
-        const v = r ? `${r}.${m}` : m;
-        h.propertyAccesses++;
-        const g = Reflect.get(d, m), S = g && typeof g === "object" && g !== null ? void 0 : g;
-        if (i.trackAccess(s, "state", v, S), g && typeof g == "object" && g !== null) {
-          const B = Object.getPrototypeOf(g) === Object.prototype, D = Array.isArray(g);
-          if (B || D)
-            return h.nestedProxiesCreated++, y.createStateProxy({
+          return Reflect.get(h, m);
+        const I = r ? `${r}.${m}` : m;
+        f.propertyAccesses++;
+        const g = Reflect.get(h, m), w = g && typeof g === "object" && g !== null ? void 0 : g;
+        if (n.trackAccess(s, "state", I, w), g && typeof g == "object" && g !== null) {
+          const B = Object.getPrototypeOf(g) === Object.prototype, P = Array.isArray(g);
+          if (B || P)
+            return f.nestedProxiesCreated++, b.createStateProxy({
               target: g,
               consumerRef: s,
-              consumerTracker: i,
-              path: v
+              consumerTracker: n,
+              path: I
             });
         }
         return g;
       },
-      has(d, m) {
-        return m in d;
+      has(h, m) {
+        return m in h;
       },
-      ownKeys(d) {
-        return Reflect.ownKeys(d);
+      ownKeys(h) {
+        return Reflect.ownKeys(h);
       },
-      getOwnPropertyDescriptor(d, m) {
-        return Reflect.getOwnPropertyDescriptor(d, m);
+      getOwnPropertyDescriptor(h, m) {
+        return Reflect.getOwnPropertyDescriptor(h, m);
       },
       set() {
         return !1;
@@ -1287,90 +1336,90 @@ class y {
       deleteProperty() {
         return !1;
       }
-    }, p = new Proxy(t, l);
-    return a.set(s, p), h.stateProxiesCreated++, h.totalProxiesCreated++, p;
+    }, p = new Proxy(t, u);
+    return o.set(s, p), f.stateProxiesCreated++, f.totalProxiesCreated++, p;
   }
   static createClassProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: i } = e;
-    if (!s || !i)
+    const { target: t, consumerRef: s, consumerTracker: n } = e;
+    if (!s || !n)
       return t;
-    let r = w.get(t);
-    r || (r = /* @__PURE__ */ new WeakMap(), w.set(t, r));
-    const a = r.get(s);
-    if (a)
-      return h.cacheHits++, a;
-    h.cacheMisses++;
-    const o = {
-      get(p, d) {
-        const m = Reflect.get(p, d);
-        let v = !1, g = p;
-        const A = /* @__PURE__ */ new WeakSet(), C = 10;
-        let S = 0;
-        for (; g && !v && S < C && !A.has(g); ) {
+    let r = k.get(t);
+    r || (r = /* @__PURE__ */ new WeakMap(), k.set(t, r));
+    const o = r.get(s);
+    if (o)
+      return f.cacheHits++, o;
+    f.cacheMisses++;
+    const a = {
+      get(p, h) {
+        const m = Reflect.get(p, h);
+        let I = !1, g = p;
+        const A = /* @__PURE__ */ new WeakSet(), D = 10;
+        let w = 0;
+        for (; g && !I && w < D && !A.has(g); ) {
           A.add(g);
           try {
-            const x = Object.getOwnPropertyDescriptor(
+            const T = Object.getOwnPropertyDescriptor(
               g,
-              d
+              h
             );
-            if (x && x.get) {
-              v = !0;
+            if (T && T.get) {
+              I = !0;
               break;
             }
-            g = Object.getPrototypeOf(g), S++;
+            g = Object.getPrototypeOf(g), w++;
           } catch {
             break;
           }
         }
-        if (!v)
+        if (!I)
           return m;
-        h.propertyAccesses++;
-        const B = m, $ = B !== null && typeof B != "object" ? B : void 0;
-        return i.trackAccess(
+        f.propertyAccesses++;
+        const B = m, M = B !== null && typeof B != "object" ? B : void 0;
+        return n.trackAccess(
           s,
           "class",
-          String(d),
-          $
+          String(h),
+          M
         ), m;
       },
-      has(p, d) {
-        return d in p;
+      has(p, h) {
+        return h in p;
       },
       ownKeys(p) {
         return Reflect.ownKeys(p);
       },
-      getOwnPropertyDescriptor(p, d) {
-        return Reflect.getOwnPropertyDescriptor(p, d);
+      getOwnPropertyDescriptor(p, h) {
+        return Reflect.getOwnPropertyDescriptor(p, h);
       }
-    }, l = new Proxy(t, o);
-    return r.set(s, l), h.classProxiesCreated++, h.totalProxiesCreated++, l;
+    }, u = new Proxy(t, a);
+    return r.set(s, u), f.classProxiesCreated++, f.totalProxiesCreated++, u;
   }
   static getProxyState(e) {
-    return y.createStateProxy({
+    return b.createStateProxy({
       target: e.state,
       consumerRef: e.consumerRef,
       consumerTracker: e.consumerTracker
     });
   }
   static getProxyBlocInstance(e) {
-    return y.createClassProxy({
+    return b.createClassProxy({
       target: e.blocInstance,
       consumerRef: e.consumerRef,
       consumerTracker: e.consumerTracker
     });
   }
   static getStats() {
-    const e = Date.now() - h.createdAt;
+    const e = Date.now() - f.createdAt;
     return {
-      ...h,
-      totalProxies: h.stateProxiesCreated + h.classProxiesCreated,
-      cacheEfficiency: h.cacheHits + h.cacheMisses > 0 ? `${(h.cacheHits / (h.cacheHits + h.cacheMisses) * 100).toFixed(1)}%` : "N/A",
+      ...f,
+      totalProxies: f.stateProxiesCreated + f.classProxiesCreated,
+      cacheEfficiency: f.cacheHits + f.cacheMisses > 0 ? `${(f.cacheHits / (f.cacheHits + f.cacheMisses) * 100).toFixed(1)}%` : "N/A",
       lifetime: `${e}ms`,
-      proxiesPerSecond: e > 0 ? (h.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
+      proxiesPerSecond: e > 0 ? (f.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
     };
   }
   static resetStats() {
-    h = {
+    f = {
       stateProxiesCreated: 0,
       classProxiesCreated: 0,
       cacheHits: 0,
@@ -1382,60 +1431,64 @@ class y {
     };
   }
 }
-class q {
+const v = class v {
   constructor(e, t) {
-    n(this, "id", `consumer-${R()}`);
-    n(this, "blocConstructor");
-    n(this, "componentRef", { current: {} });
-    n(this, "blocInstance");
+    i(this, "id", `consumer-${$()}`);
+    i(this, "blocConstructor");
+    i(this, "componentRef", { current: {} });
+    i(this, "blocInstance");
     // Core components
-    n(this, "consumerTracker");
-    n(this, "unmountTime", 0);
-    n(this, "mountTime", 0);
+    i(this, "consumerTracker");
+    i(this, "lastProps");
+    i(this, "unmountTime", 0);
+    i(this, "mountTime", 0);
     // Dependency tracking
-    n(this, "dependencyValues");
-    n(this, "isUsingDependencies", !1);
+    i(this, "dependencyValues");
+    i(this, "isUsingDependencies", !1);
     // Lifecycle state
-    n(this, "hasMounted", !1);
-    n(this, "mountCount", 0);
-    n(this, "options");
-    n(this, "createStateProxy", (e) => y.createStateProxy({
+    i(this, "hasMounted", !1);
+    i(this, "mountCount", 0);
+    i(this, "options");
+    i(this, "createStateProxy", (e) => b.createStateProxy({
       target: e.target,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
-    n(this, "createClassProxy", (e) => y.createClassProxy({
+    i(this, "createClassProxy", (e) => b.createClassProxy({
       target: e.target,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
-    n(this, "createSubscription", (e) => this.blocInstance._observer.subscribe({
+    i(this, "createSubscription", (e) => this.blocInstance._observer.subscribe({
       id: this.id,
-      fn: (s, i) => {
+      fn: (s, n) => {
         var r;
         if (this.isUsingDependencies && ((r = this.options) != null && r.dependencies)) {
-          const a = this.options.dependencies(this.blocInstance);
+          const o = this.options.dependencies(this.blocInstance);
           if (!this.hasDependencyValuesChanged(
             this.dependencyValues,
-            a
+            o
           ))
             return;
-          this.dependencyValues = a;
-        } else {
-          const a = this.consumerTracker.getConsumerInfo(
+          this.dependencyValues = o;
+        } else if (d.config.proxyDependencyTracking) {
+          const o = this.consumerTracker.getConsumerInfo(
             this.componentRef.current
           );
-          if (a && a.hasRendered && !this.consumerTracker.hasValuesChanged(
+          if (o && o.hasRendered && !this.consumerTracker.hasValuesChanged(
             this.componentRef.current,
             s,
             this.blocInstance
           ))
             return;
+        } else {
+          e.onChange();
+          return;
         }
         e.onChange();
       }
     }));
-    n(this, "mount", () => {
+    i(this, "mount", () => {
       var e, t;
       if (this.isUsingDependencies && ((e = this.options) != null && e.dependencies) && (this.dependencyValues = this.options.dependencies(this.blocInstance)), this.mountCount++, this.blocInstance._addConsumer(this.id, this.componentRef.current), !this.hasMounted && (this.hasMounted = !0, this.mountTime = Date.now(), (t = this.options) != null && t.onMount))
         try {
@@ -1444,28 +1497,28 @@ class q {
           throw s;
         }
     });
-    n(this, "unmount", () => {
+    i(this, "unmount", () => {
       var e;
-      if (this.unmountTime = Date.now(), this.consumerTracker.unregister(this.componentRef.current), this.blocInstance._removeConsumer(this.id), (e = this.options) != null && e.onUnmount)
+      if (this.unmountTime = Date.now(), this.consumerTracker.unregister(this.componentRef.current), this.blocInstance._removeConsumer(this.id), v.propsOwners.get(this.blocInstance) === this.id && v.propsOwners.delete(this.blocInstance), (e = this.options) != null && e.onUnmount)
         try {
           this.options.onUnmount(this.blocInstance);
         } catch {
         }
     });
-    n(this, "getProxyState", (e) => this.isUsingDependencies ? e : y.getProxyState({
+    i(this, "getProxyState", (e) => this.isUsingDependencies || !d.config.proxyDependencyTracking ? e : b.getProxyState({
       state: e,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
-    n(this, "getProxyBlocInstance", () => this.isUsingDependencies ? this.blocInstance : y.getProxyBlocInstance({
+    i(this, "getProxyBlocInstance", () => this.isUsingDependencies || !d.config.proxyDependencyTracking ? this.blocInstance : b.getProxyBlocInstance({
       blocInstance: this.blocInstance,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
-    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!(t != null && t.dependencies), this.consumerTracker = new H(), this.blocInstance = this.updateBlocInstance(), this.consumerTracker.register(e.componentRef.current, this.id), this.isUsingDependencies && (t != null && t.dependencies) && (this.dependencyValues = t.dependencies(this.blocInstance));
+    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!(t != null && t.dependencies), this.consumerTracker = new z(), this.blocInstance = this.updateBlocInstance(), this.consumerTracker.register(e.componentRef.current, this.id), this.isUsingDependencies && (t != null && t.dependencies) && (this.dependencyValues = t.dependencies(this.blocInstance)), (t == null ? void 0 : t.props) !== void 0 && this.updateProps(t.props);
   }
-  trackAccess(e, t, s, i) {
-    this.consumerTracker.trackAccess(e, t, s, i);
+  trackAccess(e, t, s, n) {
+    this.consumerTracker.trackAccess(e, t, s, n);
   }
   getConsumerDependencies(e) {
     return this.consumerTracker.getDependencies(e);
@@ -1482,7 +1535,7 @@ class q {
   }
   updateBlocInstance() {
     var e, t;
-    return this.blocInstance = f.instance.getBloc(this.blocConstructor, {
+    return this.blocInstance = d.instance.getBloc(this.blocConstructor, {
       props: (e = this.options) == null ? void 0 : e.props,
       id: (t = this.options) == null ? void 0 : t.id,
       instanceRef: this.id
@@ -1492,6 +1545,16 @@ class q {
   get calledOnMount() {
     return this.hasMounted;
   }
+  updateProps(e) {
+    const t = this.blocInstance;
+    if (v.propsOwners.has(t) || v.propsOwners.set(t, this.id), v.propsOwners.get(t) !== this.id) {
+      d.warn(
+        `[BlacAdapter] Attempted to set props on ${t.constructor.name} from non-owner adapter`
+      );
+      return;
+    }
+    t._disposalState === _.DISPOSED || t._disposalState === _.DISPOSING || j(this.lastProps, e) || ("add" in t && typeof t.add == "function" ? t.add(new N(e)) : "_updateProps" in t && typeof t._updateProps == "function" && t._updateProps(e), this.lastProps = e);
+  }
   hasDependencyValuesChanged(e, t) {
     if (!e || e.length !== t.length) return !0;
     for (let s = 0; s < e.length; s++)
@@ -1499,22 +1562,27 @@ class q {
         return !0;
     return !1;
   }
-}
+};
+// Props ownership tracking
+i(v, "propsOwners", /* @__PURE__ */ new WeakMap());
+let R = v;
 export {
-  f as Blac,
-  q as BlacAdapter,
-  E as BlacObservable,
-  O as Bloc,
-  k as BlocBase,
+  d as Blac,
+  R as BlacAdapter,
+  V as BlacObservable,
+  U as Bloc,
+  x as BlocBase,
   _ as BlocLifecycleState,
-  U as BlocTest,
-  H as ConsumerTracker,
-  V as Cubit,
-  K as MemoryLeakDetector,
-  z as MockBloc,
-  j as MockCubit,
-  y as ProxyFactory,
-  R as generateUUID,
-  L as setBlacInstanceManager
+  L as BlocTest,
+  z as ConsumerTracker,
+  H as Cubit,
+  F as MemoryLeakDetector,
+  Q as MockBloc,
+  W as MockCubit,
+  N as PropsUpdated,
+  b as ProxyFactory,
+  $ as generateUUID,
+  q as setBlacInstanceManager,
+  j as shallowEqual
 };
 //# sourceMappingURL=index.es.js.map