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

package/dist/index.es.js

@@ -1,7 +1,7 @@
-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 R = Object.defineProperty;
+var O = (c, e, t) => e in c ? R(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 {
+class H {
   /**
    * Creates a new BlacObservable instance
    * @param bloc - The Bloc instance to observe
@@ -33,23 +33,23 @@ class V {
    */
   subscribe(e) {
     const t = this.bloc._disposalState;
-    return t === _.DISPOSED || t === _.DISPOSING ? (d.log(
+    return t === y.DISPOSED || t === y.DISPOSING ? (u.log(
       "BlacObservable.subscribe: Cannot subscribe to disposed/disposing bloc.",
       this.bloc,
       e
     ), () => {
-    }) : (d.log(
+    }) : (u.log(
       "BlacObservable.subscribe: Subscribing observer.",
       this.bloc,
       e
-    ), this._observers.add(e), t === _.DISPOSAL_REQUESTED && (d.log(
+    ), this._observers.add(e), t === y.DISPOSAL_REQUESTED && (u.log(
       "BlacObservable.subscribe: Cancelling disposal due to new subscription.",
       this.bloc
     ), this.bloc._atomicStateTransition(
-      _.DISPOSAL_REQUESTED,
-      _.ACTIVE
+      y.DISPOSAL_REQUESTED,
+      y.ACTIVE
     )), () => {
-      d.log(
+      u.log(
         "BlacObservable.subscribe: Unsubscribing observer.",
         this.bloc,
         e
@@ -61,7 +61,7 @@ class V {
    * @param observer - The observer to unsubscribe
    */
   unsubscribe(e) {
-    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._observers.delete(e), this.size === 0 && (u.log("BlacObservable.unsubscribe: No observers left.", this.bloc), this.bloc._consumers.size === 0 && !this.bloc._keepAlive && this.bloc._disposalState === y.ACTIVE && (u.log(
       `[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`
     ), this.bloc._scheduleDisposal()));
   }
@@ -72,29 +72,29 @@ class V {
    * @param action - Optional action that triggered the state change
    */
   notify(e, t, s) {
-    this._observers.forEach((n) => {
-      let r = !1;
-      if (n.dependencyArray) {
-        const o = n.lastState, a = n.dependencyArray(
+    this._observers.forEach((r) => {
+      let n = !1;
+      if (r.dependencyArray) {
+        const o = r.lastState, a = r.dependencyArray(
           e,
           t,
           this.bloc
         );
         if (!o)
-          r = !0;
+          n = !0;
         else if (o.length !== a.length)
-          r = !0;
+          n = !0;
         else
-          for (let u = 0; u < a.length; u++)
-            if (!Object.is(o[u], a[u])) {
-              r = !0;
+          for (let l = 0; l < a.length; l++)
+            if (!Object.is(o[l], a[l])) {
+              n = !0;
               break;
             }
-        n.lastState = a;
+        r.lastState = a;
       } else
-        r = !0;
-      r && n.fn(e, t, s);
-    });
+        n = !0;
+      n && r.fn(e, t, s);
+    }), u.instance.plugins.notifyStateChanged(this.bloc, t, e);
   }
   /**
    * Clears the observer set
@@ -109,8 +109,161 @@ function $() {
     return (c === "x" ? e : e & 3 | 8).toString(16);
   });
 }
-var _ = /* @__PURE__ */ ((c) => (c.ACTIVE = "active", c.DISPOSAL_REQUESTED = "disposal_requested", c.DISPOSING = "disposing", c.DISPOSED = "disposed", c))(_ || {});
-class x {
+class V {
+  constructor() {
+    i(this, "plugins", /* @__PURE__ */ new Map());
+    i(this, "executionOrder", []);
+    i(this, "attached", !1);
+  }
+  /**
+   * Add a bloc plugin
+   */
+  add(e) {
+    if (this.plugins.has(e.name))
+      throw new Error(`Plugin '${e.name}' is already registered`);
+    e.capabilities && this.validateCapabilities(e), this.plugins.set(e.name, e), this.executionOrder.push(e.name);
+  }
+  /**
+   * Remove a bloc plugin
+   */
+  remove(e) {
+    const t = this.plugins.get(e);
+    if (!t) return !1;
+    if (this.attached && t.onDetach)
+      try {
+        t.onDetach();
+      } catch (s) {
+        console.error(`Plugin '${e}' error in onDetach:`, s);
+      }
+    return this.plugins.delete(e), this.executionOrder = this.executionOrder.filter((s) => s !== e), !0;
+  }
+  /**
+   * Get a plugin by name
+   */
+  get(e) {
+    return this.plugins.get(e);
+  }
+  /**
+   * Get all plugins in execution order
+   */
+  getAll() {
+    return this.executionOrder.map((e) => this.plugins.get(e));
+  }
+  /**
+   * Clear all plugins
+   */
+  clear() {
+    if (this.attached) {
+      for (const e of this.getAll())
+        if (e.onDetach)
+          try {
+            e.onDetach();
+          } catch (t) {
+            console.error(`Plugin '${e.name}' error in onDetach:`, t);
+          }
+    }
+    this.plugins.clear(), this.executionOrder = [], this.attached = !1;
+  }
+  /**
+   * Attach all plugins to a bloc
+   */
+  attach(e) {
+    if (this.attached)
+      throw new Error("Plugins are already attached");
+    for (const t of this.getAll())
+      if (t.onAttach)
+        try {
+          t.onAttach(e);
+        } catch (s) {
+          console.error(`Plugin '${t.name}' error in onAttach:`, s), this.remove(t.name);
+        }
+    this.attached = !0;
+  }
+  /**
+   * Transform state through all plugins
+   */
+  transformState(e, t) {
+    let s = t;
+    for (const r of this.getAll())
+      if (r.transformState && this.canTransformState(r))
+        try {
+          s = r.transformState(e, s);
+        } catch (n) {
+          console.error(`Plugin '${r.name}' error in transformState:`, n);
+        }
+    return s;
+  }
+  /**
+   * Transform event through all plugins
+   */
+  transformEvent(e) {
+    let t = e;
+    for (const s of this.getAll()) {
+      if (t === null) break;
+      if (s.transformEvent && this.canInterceptEvents(s))
+        try {
+          t = s.transformEvent(t);
+        } catch (r) {
+          console.error(`Plugin '${s.name}' error in transformEvent:`, r);
+        }
+    }
+    return t;
+  }
+  /**
+   * Notify plugins of state change
+   */
+  notifyStateChange(e, t) {
+    for (const s of this.getAll())
+      if (s.onStateChange && this.canReadState(s))
+        try {
+          s.onStateChange(e, t);
+        } catch (r) {
+          console.error(`Plugin '${s.name}' error in onStateChange:`, r);
+        }
+  }
+  /**
+   * Notify plugins of event
+   */
+  notifyEvent(e) {
+    for (const t of this.getAll())
+      if (t.onEvent && this.canReadState(t))
+        try {
+          t.onEvent(e);
+        } catch (s) {
+          console.error(`Plugin '${t.name}' error in onEvent:`, s);
+        }
+  }
+  /**
+   * Notify plugins of error
+   */
+  notifyError(e, t) {
+    for (const s of this.getAll())
+      if (s.onError)
+        try {
+          s.onError(e, t);
+        } catch (r) {
+          console.error(`Plugin '${s.name}' error in onError:`, r);
+        }
+  }
+  validateCapabilities(e) {
+    const t = e.capabilities;
+    if (t.transformState && !t.readState)
+      throw new Error(`Plugin '${e.name}': transformState requires readState capability`);
+    if (t.interceptEvents && !t.readState)
+      throw new Error(`Plugin '${e.name}': interceptEvents requires readState capability`);
+  }
+  canReadState(e) {
+    return !e.capabilities || e.capabilities.readState !== !1;
+  }
+  canTransformState(e) {
+    return !e.capabilities || e.capabilities.transformState === !0;
+  }
+  canInterceptEvents(e) {
+    return !e.capabilities || e.capabilities.interceptEvents === !0;
+  }
+}
+var y = /* @__PURE__ */ ((c) => (c.ACTIVE = "active", c.DISPOSAL_REQUESTED = "disposal_requested", c.DISPOSING = "disposing", c.DISPOSED = "disposed", c))(y || {});
+class k {
   /**
    * Creates a new BlocBase instance with the given initial state.
    * Sets up the observer, registers with the Blac manager, and initializes addons.
@@ -194,6 +347,10 @@ class x {
      * Map of consumer IDs to their WeakRef objects for proper cleanup
      */
     i(this, "_consumerRefs", /* @__PURE__ */ new Map());
+    /**
+     * Plugin registry for this bloc instance
+     */
+    i(this, "_plugins");
     /**
      * @internal
      * Validates that all consumer references are still alive
@@ -277,13 +434,28 @@ class x {
      * @param action Optional metadata about what caused the state change
      */
     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;
-          return;
-        }
-        this._oldState = t, this._state = e, this._observer.notify(e, t, s), this.lastUpdate = Date.now();
+      if (e === void 0 || s !== void 0 && typeof s != "object" && typeof s != "function")
+        return;
+      let r = e;
+      try {
+        r = this._plugins.transformState(t, e);
+      } catch (n) {
+        this._plugins.notifyError(n, {
+          phase: "state-change",
+          operation: "transformState"
+        });
+      }
+      if (this._batchingEnabled) {
+        this._pendingUpdates.push({ newState: r, oldState: t, action: s }), this._oldState = t, this._state = r;
+        return;
+      }
+      this._oldState = t, this._state = r;
+      try {
+        this._plugins.notifyStateChange(t, r);
+      } catch (n) {
+        console.error("Error notifying bloc plugins of state change:", n);
       }
+      this._observer.notify(r, t, s), this.lastUpdate = Date.now();
     });
     /**
      * Enables batching for multiple state updates
@@ -308,9 +480,11 @@ class x {
         this._batchingEnabled = !1, this._batchingLock = !1, this._pendingUpdates = [];
       }
     });
-    this._state = e, this._observer = new V(this), this._id = this.constructor.name;
+    this._state = e, this._observer = new H(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;
+    if (this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1, this._plugins = new V(), t.plugins && Array.isArray(t.plugins))
+      for (const s of t.plugins)
+        this.addPlugin(s);
   }
   get isIsolated() {
     return this._isolated;
@@ -348,10 +522,10 @@ class x {
    * @returns Result indicating success/failure and state information
    */
   _atomicStateTransition(e, t) {
-    var s, n, r, o;
+    var s, r, n, o;
     if (this._disposalState === e) {
       const a = this._disposalState;
-      return this._disposalState = t, (s = globalThis.Blac) != null && s.enableLog && ((n = globalThis.Blac) == null || n.log(
+      return this._disposalState = t, (s = globalThis.Blac) != null && s.enableLog && ((r = globalThis.Blac) == null || r.log(
         `[${this._name}:${this._id}] State transition: ${a} -> ${t} (SUCCESS)`
       )), {
         success: !0,
@@ -359,7 +533,7 @@ class x {
         previousState: a
       };
     }
-    return (r = globalThis.Blac) != null && r.enableLog && ((o = globalThis.Blac) == null || o.log(
+    return (n = globalThis.Blac) != null && n.enableLog && ((o = globalThis.Blac) == null || o.log(
       `[${this._name}:${this._id}] State transition failed: expected ${e}, current ${this._disposalState}`
     )), {
       success: !1,
@@ -430,42 +604,224 @@ class x {
       );
     });
   }
+  /**
+   * Notify observers of a state change
+   * @internal Used by plugins for state hydration
+   * @param newState The new state
+   * @param oldState The old state
+   */
+  _notifyObservers(e, t) {
+    this._observer.notify(e, t);
+  }
+  /**
+   * Add a plugin to this bloc instance
+   */
+  addPlugin(e) {
+    if (this._plugins.add(e), this._disposalState === "active")
+      try {
+        e.onAttach && e.onAttach(this);
+      } catch (t) {
+        throw console.error(`Failed to attach plugin '${e.name}':`, t), this._plugins.remove(e.name), t;
+      }
+  }
+  /**
+   * Remove a plugin from this bloc instance
+   */
+  removePlugin(e) {
+    return this._plugins.remove(e);
+  }
+  /**
+   * Get a plugin by name
+   */
+  getPlugin(e) {
+    return this._plugins.get(e);
+  }
+  /**
+   * Get all plugins
+   */
+  getPlugins() {
+    return this._plugins.getAll();
+  }
+  /**
+   * @internal
+   * Activate plugins when bloc becomes active
+   */
+  _activatePlugins() {
+    if (this._disposalState === "active")
+      try {
+        this._plugins.attach(this);
+      } catch (e) {
+        console.error(`Failed to activate plugins for ${this._name}:`, e);
+      }
+  }
 }
 /**
  * When true, every consumer will receive its own unique instance of this Bloc.
  * Use this when state should not be shared between components.
  * @default false
  */
-i(x, "isolated", !1), /**
+i(k, "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
  */
-i(x, "keepAlive", !1);
-const y = class y {
+i(k, "keepAlive", !1);
+class U {
+  constructor() {
+    i(this, "plugins", /* @__PURE__ */ new Map());
+    i(this, "metrics", /* @__PURE__ */ new Map());
+    i(this, "executionOrder", []);
+  }
+  /**
+   * Add a system plugin
+   */
+  add(e) {
+    if (this.plugins.has(e.name))
+      throw new Error(`Plugin '${e.name}' is already registered`);
+    this.plugins.set(e.name, e), this.executionOrder.push(e.name), this.initializeMetrics(e.name);
+  }
+  /**
+   * Remove a system plugin
+   */
+  remove(e) {
+    return this.plugins.get(e) ? (this.plugins.delete(e), this.metrics.delete(e), this.executionOrder = this.executionOrder.filter((s) => s !== e), !0) : !1;
+  }
+  /**
+   * Get a plugin by name
+   */
+  get(e) {
+    return this.plugins.get(e);
+  }
+  /**
+   * Get all plugins in execution order
+   */
+  getAll() {
+    return this.executionOrder.map((e) => this.plugins.get(e));
+  }
+  /**
+   * Clear all plugins
+   */
+  clear() {
+    this.plugins.clear(), this.metrics.clear(), this.executionOrder = [];
+  }
+  /**
+   * Execute a hook on all plugins
+   */
+  executeHook(e, t, s) {
+    for (const r of this.executionOrder) {
+      const n = this.plugins.get(r), o = n[e];
+      if (typeof o != "function") continue;
+      const a = performance.now();
+      try {
+        o.apply(n, t), this.recordSuccess(r, e, a);
+      } catch (l) {
+        this.recordError(r, e, l), s ? s(l, n) : console.error(`Plugin '${r}' error in hook '${e}':`, l);
+      }
+    }
+  }
+  /**
+   * Bootstrap all plugins
+   */
+  bootstrap() {
+    this.executeHook("beforeBootstrap", []), this.executeHook("afterBootstrap", []);
+  }
+  /**
+   * Shutdown all plugins
+   */
+  shutdown() {
+    this.executeHook("beforeShutdown", []), this.executeHook("afterShutdown", []);
+  }
+  /**
+   * Notify plugins of bloc creation
+   */
+  notifyBlocCreated(e) {
+    this.executeHook("onBlocCreated", [e]);
+  }
+  /**
+   * Notify plugins of bloc disposal
+   */
+  notifyBlocDisposed(e) {
+    this.executeHook("onBlocDisposed", [e]);
+  }
+  /**
+   * Notify plugins of state change
+   */
+  notifyStateChanged(e, t, s) {
+    this.executeHook("onStateChanged", [e, t, s]);
+  }
+  /**
+   * Notify plugins of event addition
+   */
+  notifyEventAdded(e, t) {
+    this.executeHook("onEventAdded", [e, t]);
+  }
+  /**
+   * Notify plugins of errors
+   */
+  notifyError(e, t, s) {
+    this.executeHook("onError", [e, t, s], (r, n) => {
+      console.error(`Plugin '${n.name}' error handler failed:`, r);
+    });
+  }
+  /**
+   * Get metrics for a plugin
+   */
+  getMetrics(e) {
+    return this.metrics.get(e);
+  }
+  initializeMetrics(e) {
+    this.metrics.set(e, /* @__PURE__ */ new Map());
+  }
+  recordSuccess(e, t, s) {
+    const r = this.metrics.get(e), n = r.get(t) || {
+      executionTime: 0,
+      executionCount: 0,
+      errorCount: 0
+    }, o = performance.now() - s;
+    r.set(t, {
+      ...n,
+      executionTime: n.executionTime + o,
+      executionCount: n.executionCount + 1,
+      lastExecutionTime: o
+    });
+  }
+  recordError(e, t, s) {
+    const r = this.metrics.get(e), n = r.get(t) || {
+      executionTime: 0,
+      executionCount: 0,
+      errorCount: 0
+    };
+    r.set(t, {
+      ...n,
+      errorCount: n.errorCount + 1,
+      lastError: s
+    });
+  }
+}
+const _ = class _ {
   getInstance() {
-    return y._instance || (y._instance = new d({
+    return _._instance || (_._instance = new u({
       __unsafe_ignore_singleton: !0
-    })), y._instance;
+    })), _._instance;
   }
   setInstance(e) {
-    y._instance = e;
+    _._instance = e;
   }
   resetInstance() {
-    const e = y._instance;
-    if (y._instance = new d({
+    const e = _._instance;
+    if (_._instance = new u({
       __unsafe_ignore_singleton: !0
     }), e)
       for (const t of e.keepAliveBlocs)
-        y._instance.keepAliveBlocs.add(t), y._instance.uidRegistry.set(t.uid, t);
+        _._instance.keepAliveBlocs.add(t), _._instance.uidRegistry.set(t.uid, t);
   }
 };
-i(y, "_instance");
-let C = y, S = new C();
-function q(c) {
+i(_, "_instance");
+let E = _, S = new E();
+function W(c) {
   S = c;
 }
-const l = class l {
+const h = class h {
   /**
    * Creates a new Blac instance.
    * @param options - Configuration options including singleton control
@@ -488,12 +844,14 @@ const l = class l {
     i(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
     /** Flag to control whether changes should be posted to document */
     i(this, "postChangesToDocument", !1);
+    /** System plugin registry */
+    i(this, "plugins", new U());
     /**
      * Logs messages to console when logging is enabled
      * @param args - Arguments to log
      */
     i(this, "log", (...e) => {
-      l.logSpy && l.logSpy(e), l.enableLog && l.logLevel, l.enableLog && l.logLevel;
+      h.logSpy && h.logSpy(e), h.enableLog && h.logLevel, h.enableLog && h.logLevel;
     });
     /**
      * Logs a warning message
@@ -501,7 +859,7 @@ const l = class l {
      * @param args - Additional arguments
      */
     i(this, "warn", (e, ...t) => {
-      l.enableLog;
+      h.enableLog;
     });
     /**
      * Logs an error message
@@ -509,7 +867,7 @@ const l = class l {
      * @param args - Additional arguments
      */
     i(this, "error", (e, ...t) => {
-      l.enableLog;
+      h.enableLog;
     });
     /**
      * Resets the Blac instance to a new one, disposing non-keepAlive blocs
@@ -519,10 +877,10 @@ const l = class l {
       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);
+        !s._keepAlive && s._disposalState === y.ACTIVE && this.disposeBloc(s);
       }), t.forEach((s) => {
-        s.forEach((n) => {
-          !n._keepAlive && n._disposalState === _.ACTIVE && this.disposeBloc(n);
+        s.forEach((r) => {
+          !r._keepAlive && r._disposalState === y.ACTIVE && this.disposeBloc(r);
         });
       }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), S.resetInstance();
     });
@@ -533,21 +891,21 @@ const l = class l {
     i(this, "disposeBloc", (e) => {
       const t = e._disposalState;
       if (![
-        _.ACTIVE,
-        _.DISPOSAL_REQUESTED
+        y.ACTIVE,
+        y.DISPOSAL_REQUESTED
       ].includes(t)) {
         this.log(
           `[${e._name}:${String(e._id)}] disposeBloc called on bloc in invalid state: ${t}`
         );
         return;
       }
-      const n = e.constructor, r = this.createBlocInstanceMapKey(e._name, e._id);
+      const r = e.constructor, n = this.createBlocInstanceMapKey(e._name, e._id);
       this.log(
-        `[${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);
+        `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(r.isolated)}`
+      ), e._dispose(), this.plugins.notifyBlocDisposed(e), r.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(n)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
     });
     i(this, "activateBloc", (e) => {
-      if (e._disposalState !== _.ACTIVE) {
+      if (e._disposalState !== y.ACTIVE) {
         this.log(
           `[${e._name}:${String(e._id)}] activateBloc called on disposed bloc. Ignoring.`
         );
@@ -570,27 +928,27 @@ const l = class l {
      * @returns The bloc instance
      */
     i(this, "getBloc", (e, t = {}) => {
-      const { id: s, forceNewInstance: n } = t, r = e, o = s ?? e.name;
+      const { id: s, forceNewInstance: r } = t, n = e, o = s ?? e.name;
       if (this.log(`[${e.name}:${String(o)}] (getBloc) Called:`, {
         options: t,
-        base: r
-      }), !n)
-        if (r.isolated) {
-          const u = this.findIsolatedBlocInstance(
+        base: n
+      }), !r)
+        if (n.isolated) {
+          const l = this.findIsolatedBlocInstance(
             e,
             t.instanceRef ?? o
           );
-          if (u)
-            return u;
+          if (l)
+            return l;
           if (t.throwIfNotFound)
             throw new Error(`Isolated bloc ${e.name} not found`);
         } else {
-          const u = this.findRegisteredBlocInstance(
+          const l = this.findRegisteredBlocInstance(
             e,
             o
           );
-          if (u)
-            return u;
+          if (l)
+            return l;
           if (t.throwIfNotFound)
             throw new Error(`Registered bloc ${e.name} not found`);
         }
@@ -614,9 +972,9 @@ const l = class l {
      *   - instanceRef: Optional reference string for the instance
      */
     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;
+      const s = e.isolated, r = t.id || e.name, n = s ? this.findIsolatedBlocInstance(e, r) : this.findRegisteredBlocInstance(e, r);
+      if (n)
+        return n;
       throw new Error(`Bloc ${e.name} not found`);
     });
     /**
@@ -628,11 +986,11 @@ const l = class l {
      */
     i(this, "getAllBlocs", (e, t = {}) => {
       const s = [];
-      if (this.blocInstanceMap.forEach((n) => {
-        n.constructor === e && s.push(n);
+      if (this.blocInstanceMap.forEach((r) => {
+        r.constructor === e && s.push(r);
       }), t.searchIsolated !== !1) {
-        const n = this.isolatedBlocMap.get(e);
-        n && s.push(...n.map((r) => r));
+        const r = this.isolatedBlocMap.get(e);
+        r && s.push(...r.map((n) => n));
       }
       return s;
     });
@@ -655,8 +1013,8 @@ const l = class l {
       for (const s of this.blocInstanceMap.values())
         e(s) && t.push(s);
       for (const s of this.isolatedBlocMap.values())
-        for (const n of s)
-          e(n) && t.push(n);
+        for (const r of s)
+          e(r) && t.push(r);
       t.forEach((s) => s._dispose());
     });
     /**
@@ -677,20 +1035,20 @@ const l = class l {
      */
     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);
+        e._validateConsumers(), e._consumers.size === 0 && !e._keepAlive && e._disposalState === y.ACTIVE && setTimeout(() => {
+          e._consumers.size === 0 && !e._keepAlive && e._disposalState === y.ACTIVE && this.disposeBloc(e);
         }, 1e3);
     });
     const { __unsafe_ignore_singleton: t = !1 } = e;
     if (!t)
-      return l.instance;
-    S.setInstance(this);
+      return h.instance;
+    S.setInstance(this), this.plugins.bootstrap();
   }
   static get instance() {
     return S.getInstance();
   }
   static get getAllBlocs() {
-    return l.instance.getAllBlocs;
+    return h.instance.getAllBlocs;
   }
   /** Get current configuration */
   static get config() {
@@ -712,7 +1070,7 @@ const l = class l {
     }, this.enableLog && this.instance.log("Blac config updated:", this._config);
   }
   static get log() {
-    return l.instance.log;
+    return h.instance.log;
   }
   /**
    * Gets the current Blac instance
@@ -722,13 +1080,13 @@ const l = class l {
     return S.getInstance();
   }
   static get warn() {
-    return l.instance.warn;
+    return h.instance.warn;
   }
   static get error() {
-    return l.instance.error;
+    return h.instance.error;
   }
   static get disposeBloc() {
-    return l.instance.disposeBloc;
+    return h.instance.disposeBloc;
   }
   /**
    * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
@@ -763,8 +1121,8 @@ const l = class l {
    */
   findRegisteredBlocInstance(e, t) {
     if (e.isolated) return;
-    const n = this.createBlocInstanceMapKey(e.name, t);
-    return this.blocInstanceMap.get(n);
+    const r = this.createBlocInstanceMapKey(e.name, t);
+    return this.blocInstanceMap.get(r);
   }
   /**
    * Registers an isolated bloc instance in the isolated registry
@@ -780,14 +1138,14 @@ const l = class l {
    */
   unregisterIsolatedBlocInstance(e) {
     const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    let n = !1;
+    let r = !1;
     if (s) {
       const o = s.findIndex((a) => a.uid === e.uid);
-      o !== -1 && (s.splice(o, 1), n = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
+      o !== -1 && (s.splice(o, 1), r = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
     }
-    const r = this.isolatedBlocIndex.delete(e.uid);
-    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}`
+    const n = this.isolatedBlocIndex.delete(e.uid);
+    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), r !== n && this.warn(
+      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${r}, Index removal: ${n}`
     );
   }
   /**
@@ -795,8 +1153,8 @@ const l = class l {
    */
   findIsolatedBlocInstance(e, t) {
     if (!e.isolated) return;
-    const n = this.isolatedBlocMap.get(e);
-    return n ? n.find((o) => o._id === t) : void 0;
+    const r = this.isolatedBlocMap.get(e);
+    return r ? r.find((o) => o._id === t) : void 0;
   }
   /**
    * Finds an isolated bloc instance by UID (O(1) lookup)
@@ -813,41 +1171,58 @@ const l = class l {
    * @returns The newly created bloc instance
    */
   createNewBlocInstance(e, t, s = {}) {
-    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);
+    const { props: r, instanceRef: n } = s, o = new e(r);
+    return o._instanceRef = n, o.props = r || null, o._updateId(t), o._setDisposalHandler((a) => this.disposeBloc(a)), o.isIsolated ? this.registerIsolatedBlocInstance(o) : this.registerBlocInstance(o), o._activatePlugins(), this.plugins.notifyBlocCreated(o), o;
   }
   static get activateBloc() {
-    return l.instance.activateBloc;
+    return h.instance.activateBloc;
   }
   static get getBloc() {
-    return l.instance.getBloc;
+    return h.instance.getBloc;
   }
   static get getBlocOrThrow() {
-    return l.instance.getBlocOrThrow;
+    return h.instance.getBlocOrThrow;
   }
   static get disposeKeepAliveBlocs() {
-    return l.instance.disposeKeepAliveBlocs;
+    return h.instance.disposeKeepAliveBlocs;
   }
   static get disposeBlocs() {
-    return l.instance.disposeBlocs;
+    return h.instance.disposeBlocs;
   }
   static get getMemoryStats() {
-    return l.instance.getMemoryStats;
+    return h.instance.getMemoryStats;
   }
   static get validateConsumers() {
-    return l.instance.validateConsumers;
+    return h.instance.validateConsumers;
+  }
+  /**
+   * Bootstrap the Blac instance and all plugins
+   */
+  bootstrap() {
+    this.plugins.bootstrap();
+  }
+  /**
+   * Shutdown the Blac instance and all plugins
+   */
+  shutdown() {
+    this.plugins.shutdown();
+    for (const e of this.blocInstanceMap.values())
+      e._keepAlive || this.disposeBloc(e);
+    for (const e of this.isolatedBlocMap.values())
+      for (const t of e)
+        t._keepAlive || this.disposeBloc(t);
   }
 };
 /** Private static configuration */
-i(l, "_config", {
+i(h, "_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", () => {
+i(h, "enableLog", !1), i(h, "logLevel", "warn"), i(h, "logSpy", null), i(h, "resetInstance", () => {
   S.resetInstance();
 });
-let d = l;
-class U extends x {
+let u = h;
+class j extends k {
   constructor() {
     super(...arguments);
     i(this, "eventHandlers", /* @__PURE__ */ new Map());
@@ -867,7 +1242,20 @@ class U extends x {
      * @param action The action/event instance to be processed.
      */
     i(this, "add", async (t) => {
-      this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
+      let s = t;
+      try {
+        s = this._plugins.transformEvent(t);
+      } catch (r) {
+        console.error("Error transforming event:", r);
+      }
+      if (s !== null) {
+        try {
+          this._plugins.notifyEvent(s);
+        } catch (r) {
+          console.error("Error notifying plugins of event:", r);
+        }
+        u.instance.plugins.notifyEventAdded(this, s), this._eventQueue.push(s), this._isProcessingEvent || await this._processEventQueue();
+      }
     });
   }
   /**
@@ -878,7 +1266,7 @@ class U extends x {
    *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
    */
   on(t, s) {
-    this.eventHandlers.has(t) && d.warn(
+    this.eventHandlers.has(t) && u.warn(
       `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
       t,
@@ -907,16 +1295,16 @@ class U extends x {
    * Processes a single event
    */
   async _processEvent(t) {
-    const s = t.constructor, n = this.eventHandlers.get(s);
-    if (n) {
-      const r = (o) => {
+    const s = t.constructor, r = this.eventHandlers.get(s);
+    if (r) {
+      const n = (o) => {
         const a = this.state;
         this._pushState(o, a, t);
       };
       try {
-        await n(t, r);
+        await r(t, n);
       } catch (o) {
-        const a = t.constructor.name || "UnnamedConstructor", u = {
+        const a = t.constructor.name || "UnnamedConstructor", l = {
           blocName: this._name,
           blocId: String(this._id),
           eventType: a,
@@ -924,18 +1312,32 @@ class U extends x {
           action: t,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        if (d.error(
+        if (u.error(
           `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${a}':`,
           o,
           "Context:",
-          u
-        ), o instanceof Error && o.name === "CriticalError")
+          l
+        ), o instanceof Error)
+          try {
+            this._plugins.notifyError(o, {
+              phase: "event-processing",
+              operation: "handler",
+              metadata: { event: t }
+            }), u.instance.plugins.notifyError(o, this, {
+              phase: "event-processing",
+              operation: "handler",
+              metadata: { event: t }
+            });
+          } catch (d) {
+            console.error("Error notifying plugins:", d);
+          }
+        if (o instanceof Error && o.name === "CriticalError")
           throw o;
       }
     } else {
-      const r = t.constructor.name || "UnnamedConstructor";
-      d.warn(
-        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${r}'.`,
+      const n = t.constructor.name || "UnnamedConstructor";
+      u.warn(
+        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${n}'.`,
         "Registered handlers:",
         Array.from(this.eventHandlers.keys()).map((o) => o.name),
         "Action was:",
@@ -944,7 +1346,7 @@ class U extends x {
     }
   }
 }
-class H extends x {
+class z extends k {
   /**
    * @internal
    * Protected method for useBloc to call
@@ -976,7 +1378,7 @@ class H extends x {
    */
   patch(e, t = !1) {
     if (typeof this.state != "object" || this.state === null) {
-      d.warn(
+      u.warn(
         "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
       );
       return;
@@ -985,10 +1387,10 @@ class H extends x {
     if (t)
       s = !0;
     else
-      for (const n in e)
-        if (Object.prototype.hasOwnProperty.call(e, n)) {
-          const o = this.state[n];
-          if (!Object.is(e[n], o)) {
+      for (const r in e)
+        if (Object.prototype.hasOwnProperty.call(e, r)) {
+          const o = this.state[r];
+          if (!Object.is(e[r], o)) {
             s = !0;
             break;
           }
@@ -999,12 +1401,12 @@ class H extends x {
     });
   }
 }
-class N {
+class L {
   constructor(e) {
     this.props = e;
   }
 }
-function j(c, e) {
+function N(c, e) {
   if (Object.is(c, e))
     return !0;
   if (typeof c != "object" || c === null || typeof e != "object" || e === null)
@@ -1012,90 +1414,90 @@ function j(c, e) {
   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]))
+  for (let r = 0; r < t.length; r++) {
+    const n = t[r];
+    if (!Object.prototype.hasOwnProperty.call(e, n) || !Object.is(c[n], e[n]))
       return !1;
   }
   return !0;
 }
-class L {
+class q {
   /**
    * Sets up a clean test environment
    */
   static setUp() {
-    this.originalInstance = d.instance, d.resetInstance(), d.enableLog = !1;
+    this.originalInstance = u.instance, u.resetInstance(), u.enableLog = !1;
   }
   /**
    * Tears down the test environment and restores original state
    */
   static tearDown() {
-    d.resetInstance();
+    u.resetInstance();
   }
   /**
    * Creates a test bloc with automatic cleanup
    */
   static createBloc(e, ...t) {
     const s = new e(...t);
-    return d.activateBloc(s), s;
+    return u.activateBloc(s), s;
   }
   /**
    * Waits for a bloc to emit a specific state
    */
   static async waitForState(e, t, s = 5e3) {
-    return new Promise((n, r) => {
+    return new Promise((r, n) => {
       const o = setTimeout(() => {
-        r(
+        n(
           new Error(
             `Timeout waiting for state matching predicate after ${s}ms`
           )
         );
       }, s), a = e._observer.subscribe({
         id: `test-waiter-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        fn: (u) => {
-          t(u) && (clearTimeout(o), a(), n(u));
+        fn: (l) => {
+          t(l) && (clearTimeout(o), a(), r(l));
         }
       });
-      t(e.state) && (clearTimeout(o), a(), n(e.state));
+      t(e.state) && (clearTimeout(o), a(), r(e.state));
     });
   }
   /**
    * Expects a bloc to emit specific states in order
    */
   static async expectStates(e, t, s = 5e3) {
-    const n = [];
-    return new Promise((r, o) => {
+    const r = [];
+    return new Promise((n, o) => {
       const a = setTimeout(() => {
         o(
           new Error(
-            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(n)}`
+            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(r)}`
           )
         );
-      }, s), u = e._observer.subscribe({
+      }, s), l = e._observer.subscribe({
         id: `test-expecter-${crypto.randomUUID()}`,
-        fn: (p) => {
-          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)) {
+        fn: (d) => {
+          if (r.push(d), r.length === t.length) {
+            clearTimeout(a), l();
+            for (let f = 0; f < t.length; f++) {
+              const m = t[f], v = r[f];
+              if (JSON.stringify(m) !== JSON.stringify(v)) {
                 o(
                   new Error(
-                    `State mismatch at index ${h}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(I)}`
+                    `State mismatch at index ${f}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(v)}`
                   )
                 );
                 return;
               }
             }
-            r();
+            n();
           }
         }
       });
     });
   }
 }
-i(L, "originalInstance");
-class Q extends U {
+i(q, "originalInstance");
+class F extends j {
   constructor(t) {
     super(t);
     i(this, "mockHandlers", /* @__PURE__ */ new Map());
@@ -1119,7 +1521,7 @@ class Q extends U {
     return this.eventHandlers.has(t);
   }
 }
-class W extends H {
+class G extends z {
   constructor(t) {
     super(t);
     i(this, "stateHistory", []);
@@ -1144,16 +1546,16 @@ class W extends H {
     this.stateHistory = [this.state];
   }
 }
-class F {
+class J {
   constructor() {
     i(this, "initialStats");
-    this.initialStats = d.getMemoryStats();
+    this.initialStats = u.getMemoryStats();
   }
   /**
    * Check for memory leaks and return a report
    */
   checkForLeaks() {
-    const e = d.getMemoryStats(), t = e.registeredBlocs > this.initialStats.registeredBlocs || e.isolatedBlocs > this.initialStats.isolatedBlocs || e.keepAliveBlocs > this.initialStats.keepAliveBlocs, s = `
+    const e = u.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}
@@ -1170,7 +1572,7 @@ Memory Leak Detection Report:
     };
   }
 }
-class z {
+class K {
   constructor() {
     i(this, "consumers", /* @__PURE__ */ new WeakMap());
     i(this, "registrationCount", 0);
@@ -1193,11 +1595,11 @@ class z {
   unregister(e) {
     e && this.consumers.get(e) && (this.consumers.delete(e), this.activeConsumers = Math.max(0, this.activeConsumers - 1));
   }
-  trackAccess(e, t, s, n) {
-    const r = this.consumers.get(e);
-    if (!r) return;
+  trackAccess(e, t, s, r) {
+    const n = this.consumers.get(e);
+    if (!n) return;
     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 }));
+    n.firstAccessTime || (n.firstAccessTime = o), n.accessCount++, n.lastAccessTime = o, t === "state" ? (n.stateAccesses.add(s), r !== void 0 && n.stateValues.set(s, { value: r, lastAccessTime: o })) : (n.classAccesses.add(s), r !== void 0 && n.classValues.set(s, { value: r, lastAccessTime: o }));
   }
   resetTracking(e) {
     const t = this.consumers.get(e);
@@ -1211,41 +1613,41 @@ class z {
     } : null;
   }
   hasValuesChanged(e, t, s) {
-    const n = this.consumers.get(e);
-    if (!n) return !0;
-    let r = !1;
+    const r = this.consumers.get(e);
+    if (!r) return !0;
+    let n = !1;
     const o = Date.now();
-    if (n.stateValues.size === 0 && n.classValues.size === 0 && (n.stateAccesses.size > 0 || n.classAccesses.size > 0))
+    if (r.stateValues.size === 0 && r.classValues.size === 0 && (r.stateAccesses.size > 0 || r.classAccesses.size > 0))
       return !0;
-    for (const [a, u] of n.stateValues)
+    for (const [a, l] of r.stateValues)
       try {
-        const p = this.getValueAtPath(t, a);
-        p !== u.value && (n.stateValues.set(a, {
-          value: p,
+        const d = this.getValueAtPath(t, a);
+        d !== l.value && (r.stateValues.set(a, {
+          value: d,
           lastAccessTime: o
-        }), r = !0);
+        }), n = !0);
       } catch {
-        r = !0;
+        n = !0;
       }
-    for (const [a, u] of n.classValues)
+    for (const [a, l] of r.classValues)
       try {
-        const p = this.getValueAtPath(s, a);
-        p !== u.value && (n.classValues.set(a, {
-          value: p,
+        const d = this.getValueAtPath(s, a);
+        d !== l.value && (r.classValues.set(a, {
+          value: d,
           lastAccessTime: o
-        }), r = !0);
+        }), n = !0);
       } catch {
-        r = !0;
+        n = !0;
       }
-    return r;
+    return n;
   }
   shouldNotifyConsumer(e, t) {
     const s = this.consumers.get(e);
     if (!s) return !1;
-    for (const n of t) {
-      if (s.stateAccesses.has(n) || s.classAccesses.has(n)) return !0;
-      for (const r of s.stateAccesses)
-        if (n.startsWith(r + ".") || r.startsWith(n + "."))
+    for (const r of t) {
+      if (s.stateAccesses.has(r) || s.classAccesses.has(r)) return !0;
+      for (const n of s.stateAccesses)
+        if (r.startsWith(n + ".") || n.startsWith(r + "."))
           return !0;
     }
     return !1;
@@ -1272,16 +1674,16 @@ class z {
   }
   getValueAtPath(e, t) {
     const s = t.split(".");
-    let n = e;
-    for (const r of s) {
-      if (n == null) return;
-      n = n[r];
+    let r = e;
+    for (const n of s) {
+      if (r == null) return;
+      r = r[n];
     }
-    return n;
+    return r;
   }
 }
-const k = /* @__PURE__ */ new WeakMap();
-let f = {
+const x = /* @__PURE__ */ new WeakMap();
+let p = {
   stateProxiesCreated: 0,
   classProxiesCreated: 0,
   cacheHits: 0,
@@ -1291,44 +1693,44 @@ let f = {
   totalProxiesCreated: 0,
   createdAt: Date.now()
 };
-class b {
+class I {
   static createStateProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: n, path: r = "" } = e;
-    if (!s || !n || typeof t != "object" || t === null)
+    const { target: t, consumerRef: s, consumerTracker: r, path: n = "" } = e;
+    if (!s || !r || typeof t != "object" || t === null)
       return t;
-    let o = k.get(t);
-    o || (o = /* @__PURE__ */ new WeakMap(), k.set(t, o));
+    let o = x.get(t);
+    o || (o = /* @__PURE__ */ new WeakMap(), x.set(t, o));
     const a = o.get(s);
     if (a)
-      return f.cacheHits++, a;
-    f.cacheMisses++;
-    const u = {
-      get(h, m) {
+      return p.cacheHits++, a;
+    p.cacheMisses++;
+    const l = {
+      get(f, m) {
         if (typeof m == "symbol" || m === "constructor")
-          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({
+          return Reflect.get(f, m);
+        const v = n ? `${n}.${m}` : m;
+        p.propertyAccesses++;
+        const g = Reflect.get(f, m), B = g && typeof g === "object" && g !== null ? void 0 : g;
+        if (r.trackAccess(s, "state", v, B), g && typeof g == "object" && g !== null) {
+          const w = Object.getPrototypeOf(g) === Object.prototype, T = Array.isArray(g);
+          if (w || T)
+            return p.nestedProxiesCreated++, I.createStateProxy({
               target: g,
               consumerRef: s,
-              consumerTracker: n,
-              path: I
+              consumerTracker: r,
+              path: v
             });
         }
         return g;
       },
-      has(h, m) {
-        return m in h;
+      has(f, m) {
+        return m in f;
       },
-      ownKeys(h) {
-        return Reflect.ownKeys(h);
+      ownKeys(f) {
+        return Reflect.ownKeys(f);
       },
-      getOwnPropertyDescriptor(h, m) {
-        return Reflect.getOwnPropertyDescriptor(h, m);
+      getOwnPropertyDescriptor(f, m) {
+        return Reflect.getOwnPropertyDescriptor(f, m);
       },
       set() {
         return !1;
@@ -1336,90 +1738,90 @@ class b {
       deleteProperty() {
         return !1;
       }
-    }, p = new Proxy(t, u);
-    return o.set(s, p), f.stateProxiesCreated++, f.totalProxiesCreated++, p;
+    }, d = new Proxy(t, l);
+    return o.set(s, d), p.stateProxiesCreated++, p.totalProxiesCreated++, d;
   }
   static createClassProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: n } = e;
-    if (!s || !n)
+    const { target: t, consumerRef: s, consumerTracker: r } = e;
+    if (!s || !r)
       return t;
-    let r = k.get(t);
-    r || (r = /* @__PURE__ */ new WeakMap(), k.set(t, r));
-    const o = r.get(s);
+    let n = x.get(t);
+    n || (n = /* @__PURE__ */ new WeakMap(), x.set(t, n));
+    const o = n.get(s);
     if (o)
-      return f.cacheHits++, o;
-    f.cacheMisses++;
+      return p.cacheHits++, o;
+    p.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); ) {
+      get(d, f) {
+        const m = Reflect.get(d, f);
+        let v = !1, g = d;
+        const A = /* @__PURE__ */ new WeakSet(), P = 10;
+        let B = 0;
+        for (; g && !v && B < P && !A.has(g); ) {
           A.add(g);
           try {
-            const T = Object.getOwnPropertyDescriptor(
+            const C = Object.getOwnPropertyDescriptor(
               g,
-              h
+              f
             );
-            if (T && T.get) {
-              I = !0;
+            if (C && C.get) {
+              v = !0;
               break;
             }
-            g = Object.getPrototypeOf(g), w++;
+            g = Object.getPrototypeOf(g), B++;
           } catch {
             break;
           }
         }
-        if (!I)
+        if (!v)
           return m;
-        f.propertyAccesses++;
-        const B = m, M = B !== null && typeof B != "object" ? B : void 0;
-        return n.trackAccess(
+        p.propertyAccesses++;
+        const w = m, M = w !== null && typeof w != "object" ? w : void 0;
+        return r.trackAccess(
           s,
           "class",
-          String(h),
+          String(f),
           M
         ), m;
       },
-      has(p, h) {
-        return h in p;
+      has(d, f) {
+        return f in d;
       },
-      ownKeys(p) {
-        return Reflect.ownKeys(p);
+      ownKeys(d) {
+        return Reflect.ownKeys(d);
       },
-      getOwnPropertyDescriptor(p, h) {
-        return Reflect.getOwnPropertyDescriptor(p, h);
+      getOwnPropertyDescriptor(d, f) {
+        return Reflect.getOwnPropertyDescriptor(d, f);
       }
-    }, u = new Proxy(t, a);
-    return r.set(s, u), f.classProxiesCreated++, f.totalProxiesCreated++, u;
+    }, l = new Proxy(t, a);
+    return n.set(s, l), p.classProxiesCreated++, p.totalProxiesCreated++, l;
   }
   static getProxyState(e) {
-    return b.createStateProxy({
+    return I.createStateProxy({
       target: e.state,
       consumerRef: e.consumerRef,
       consumerTracker: e.consumerTracker
     });
   }
   static getProxyBlocInstance(e) {
-    return b.createClassProxy({
+    return I.createClassProxy({
       target: e.blocInstance,
       consumerRef: e.consumerRef,
       consumerTracker: e.consumerTracker
     });
   }
   static getStats() {
-    const e = Date.now() - f.createdAt;
+    const e = Date.now() - p.createdAt;
     return {
-      ...f,
-      totalProxies: f.stateProxiesCreated + f.classProxiesCreated,
-      cacheEfficiency: f.cacheHits + f.cacheMisses > 0 ? `${(f.cacheHits / (f.cacheHits + f.cacheMisses) * 100).toFixed(1)}%` : "N/A",
+      ...p,
+      totalProxies: p.stateProxiesCreated + p.classProxiesCreated,
+      cacheEfficiency: p.cacheHits + p.cacheMisses > 0 ? `${(p.cacheHits / (p.cacheHits + p.cacheMisses) * 100).toFixed(1)}%` : "N/A",
       lifetime: `${e}ms`,
-      proxiesPerSecond: e > 0 ? (f.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
+      proxiesPerSecond: e > 0 ? (p.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
     };
   }
   static resetStats() {
-    f = {
+    p = {
       stateProxiesCreated: 0,
       classProxiesCreated: 0,
       cacheHits: 0,
@@ -1431,7 +1833,7 @@ class b {
     };
   }
 }
-const v = class v {
+const b = class b {
   constructor(e, t) {
     i(this, "id", `consumer-${$()}`);
     i(this, "blocConstructor");
@@ -1449,21 +1851,21 @@ const v = class v {
     i(this, "hasMounted", !1);
     i(this, "mountCount", 0);
     i(this, "options");
-    i(this, "createStateProxy", (e) => b.createStateProxy({
+    i(this, "createStateProxy", (e) => I.createStateProxy({
       target: e.target,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
-    i(this, "createClassProxy", (e) => b.createClassProxy({
+    i(this, "createClassProxy", (e) => I.createClassProxy({
       target: e.target,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
     i(this, "createSubscription", (e) => this.blocInstance._observer.subscribe({
       id: this.id,
-      fn: (s, n) => {
-        var r;
-        if (this.isUsingDependencies && ((r = this.options) != null && r.dependencies)) {
+      fn: (s, r) => {
+        var n;
+        if (this.isUsingDependencies && ((n = this.options) != null && n.dependencies)) {
           const o = this.options.dependencies(this.blocInstance);
           if (!this.hasDependencyValuesChanged(
             this.dependencyValues,
@@ -1471,7 +1873,7 @@ const v = class v {
           ))
             return;
           this.dependencyValues = o;
-        } else if (d.config.proxyDependencyTracking) {
+        } else if (u.config.proxyDependencyTracking) {
           const o = this.consumerTracker.getConsumerInfo(
             this.componentRef.current
           );
@@ -1499,26 +1901,26 @@ const v = class v {
     });
     i(this, "unmount", () => {
       var e;
-      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)
+      if (this.unmountTime = Date.now(), this.consumerTracker.unregister(this.componentRef.current), this.blocInstance._removeConsumer(this.id), b.propsOwners.get(this.blocInstance) === this.id && b.propsOwners.delete(this.blocInstance), (e = this.options) != null && e.onUnmount)
         try {
           this.options.onUnmount(this.blocInstance);
         } catch {
         }
     });
-    i(this, "getProxyState", (e) => this.isUsingDependencies || !d.config.proxyDependencyTracking ? e : b.getProxyState({
+    i(this, "getProxyState", (e) => this.isUsingDependencies || !u.config.proxyDependencyTracking ? e : I.getProxyState({
       state: e,
       consumerRef: this.componentRef.current,
       consumerTracker: this
     }));
-    i(this, "getProxyBlocInstance", () => this.isUsingDependencies || !d.config.proxyDependencyTracking ? this.blocInstance : b.getProxyBlocInstance({
+    i(this, "getProxyBlocInstance", () => this.isUsingDependencies || !u.config.proxyDependencyTracking ? this.blocInstance : I.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 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);
+    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!(t != null && t.dependencies), this.consumerTracker = new K(), 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, n) {
-    this.consumerTracker.trackAccess(e, t, s, n);
+  trackAccess(e, t, s, r) {
+    this.consumerTracker.trackAccess(e, t, s, r);
   }
   getConsumerDependencies(e) {
     return this.consumerTracker.getDependencies(e);
@@ -1535,7 +1937,7 @@ const v = class v {
   }
   updateBlocInstance() {
     var e, t;
-    return this.blocInstance = d.instance.getBloc(this.blocConstructor, {
+    return this.blocInstance = u.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
@@ -1547,13 +1949,13 @@ const v = class v {
   }
   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(
+    if (b.propsOwners.has(t) || b.propsOwners.set(t, this.id), b.propsOwners.get(t) !== this.id) {
+      u.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);
+    t._disposalState === y.DISPOSED || t._disposalState === y.DISPOSING || N(this.lastProps, e) || ("add" in t && typeof t.add == "function" ? t.add(new L(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;
@@ -1564,25 +1966,27 @@ const v = class v {
   }
 };
 // Props ownership tracking
-i(v, "propsOwners", /* @__PURE__ */ new WeakMap());
-let R = v;
+i(b, "propsOwners", /* @__PURE__ */ new WeakMap());
+let D = b;
 export {
-  d as Blac,
-  R as BlacAdapter,
-  V as BlacObservable,
-  U as Bloc,
-  x as BlocBase,
-  _ as BlocLifecycleState,
-  L as BlocTest,
-  z as ConsumerTracker,
-  H as Cubit,
-  F as MemoryLeakDetector,
-  Q as MockBloc,
-  W as MockCubit,
-  N as PropsUpdated,
-  b as ProxyFactory,
+  u as Blac,
+  D as BlacAdapter,
+  H as BlacObservable,
+  j as Bloc,
+  k as BlocBase,
+  y as BlocLifecycleState,
+  V as BlocPluginRegistry,
+  q as BlocTest,
+  K as ConsumerTracker,
+  z as Cubit,
+  J as MemoryLeakDetector,
+  F as MockBloc,
+  G as MockCubit,
+  L as PropsUpdated,
+  I as ProxyFactory,
+  U as SystemPluginRegistry,
   $ as generateUUID,
-  q as setBlacInstanceManager,
-  j as shallowEqual
+  W as setBlacInstanceManager,
+  N as shallowEqual
 };
 //# sourceMappingURL=index.es.js.map