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

package/dist/index.es.js

@@ -1,697 +1,361 @@
-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 {
+var u = /* @__PURE__ */ ((r) => (r.ACTIVE = "active", r.DISPOSAL_REQUESTED = "disposal_requested", r.DISPOSING = "disposing", r.DISPOSED = "disposed", r))(u || {});
+class B {
+  disposalState = "active";
+  disposalLock = !1;
+  disposalTimer;
+  disposalHandler;
+  get currentState() {
+    return this.disposalState;
+  }
+  get isDisposed() {
+    return this.disposalState === "disposed";
+  }
   /**
-   * Creates a new BlacObservable instance
-   * @param bloc - The Bloc instance to observe
+   * Atomic state transition for disposal
    */
-  constructor(e) {
-    /** The Bloc instance this observable is associated with */
-    i(this, "bloc");
-    i(this, "_observers", /* @__PURE__ */ new Set());
-    this.bloc = e;
+  atomicStateTransition(e, t) {
+    if (this.disposalLock)
+      return {
+        success: !1,
+        currentState: this.disposalState,
+        previousState: this.disposalState
+      };
+    this.disposalLock = !0;
+    try {
+      if (this.disposalState !== e)
+        return {
+          success: !1,
+          currentState: this.disposalState,
+          previousState: this.disposalState
+        };
+      const s = this.disposalState;
+      return this.disposalState = t, {
+        success: !0,
+        currentState: t,
+        previousState: s
+      };
+    } finally {
+      this.disposalLock = !1;
+    }
   }
   /**
-   * Gets the number of active observers
-   * @returns The number of observers currently subscribed
+   * Schedule disposal after a delay
    */
-  get size() {
-    return this._observers.size;
+  scheduleDisposal(e, t, s) {
+    this.disposalTimer && (clearTimeout(this.disposalTimer), this.disposalTimer = void 0), this.atomicStateTransition(
+      "active",
+      "disposal_requested"
+      /* DISPOSAL_REQUESTED */
+    ).success && (this.disposalTimer = setTimeout(() => {
+      t() && this.disposalState === "disposal_requested" ? s() : this.atomicStateTransition(
+        "disposal_requested",
+        "active"
+        /* ACTIVE */
+      );
+    }, e));
   }
   /**
-   * Gets the set of all observers
-   * @returns The Set of all BlacObserver instances
+   * Cancel disposal if in disposal requested state
    */
-  get observers() {
-    return this._observers;
+  cancelDisposal() {
+    return this.disposalState === "disposal_requested" ? (this.disposalTimer && (clearTimeout(this.disposalTimer), this.disposalTimer = void 0), this.atomicStateTransition(
+      "disposal_requested",
+      "active"
+      /* ACTIVE */
+    ).success) : !1;
   }
   /**
-   * Subscribes an observer to state changes
-   * @param observer - The observer to subscribe
-   * @returns A function that can be called to unsubscribe the observer
+   * Set disposal handler
    */
-  subscribe(e) {
-    const t = this.bloc._disposalState;
-    return t === _.DISPOSED || t === _.DISPOSING ? (d.log(
-      "BlacObservable.subscribe: Cannot subscribe to disposed/disposing bloc.",
-      this.bloc,
-      e
-    ), () => {
-    }) : (d.log(
-      "BlacObservable.subscribe: Subscribing observer.",
-      this.bloc,
-      e
-    ), 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
-    )), () => {
-      d.log(
-        "BlacObservable.subscribe: Unsubscribing observer.",
-        this.bloc,
-        e
-      ), this.unsubscribe(e);
-    });
+  setDisposalHandler(e) {
+    this.disposalHandler = e;
   }
   /**
-   * Unsubscribes an observer from state changes
-   * @param observer - The observer to unsubscribe
+   * Get disposal handler
    */
-  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.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`
-    ), this.bloc._scheduleDisposal()));
+  getDisposalHandler() {
+    return this.disposalHandler;
   }
   /**
-   * Notifies all observers of a state change
-   * @param newState - The new state value
-   * @param oldState - The previous state value
-   * @param action - Optional action that triggered the state change
+   * Clear disposal timer
    */
-  notify(e, t, s) {
-    this._observers.forEach((n) => {
-      let r = !1;
-      if (n.dependencyArray) {
-        const o = n.lastState, a = n.dependencyArray(
-          e,
-          t,
-          this.bloc
-        );
-        if (!o)
-          r = !0;
-        else if (o.length !== a.length)
-          r = !0;
-        else
-          for (let u = 0; u < a.length; u++)
-            if (!Object.is(o[u], a[u])) {
-              r = !0;
-              break;
-            }
-        n.lastState = a;
-      } else
-        r = !0;
-      r && n.fn(e, t, s);
-    });
+  clearDisposalTimer() {
+    this.disposalTimer && (clearTimeout(this.disposalTimer), this.disposalTimer = void 0);
+  }
+}
+class T {
+  plugins = /* @__PURE__ */ new Map();
+  metrics = /* @__PURE__ */ new Map();
+  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;
   }
   /**
-   * Clears the observer set
+   * 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._observers.clear();
+    this.plugins.clear(), this.metrics.clear(), this.executionOrder = [];
   }
-}
-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 (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 {
   /**
-   * Creates a new BlocBase instance with the given initial state.
-   * Sets up the observer, registers with the Blac manager, and initializes addons.
-   *
-   * @param initialState The initial state value for this Bloc
+   * Execute a hook on all plugins
    */
-  constructor(e) {
-    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.
-     */
-    i(this, "defaultDependencySelector");
-    /**
-     * @internal
-     * Indicates if this specific Bloc instance is isolated from others of the same type.
-     */
-    i(this, "_isolated", !1);
-    /**
-     * @internal
-     * Observable responsible for managing state listeners and notifying consumers.
-     */
-    i(this, "_observer");
-    /**
-     * The unique identifier for this Bloc instance.
-     * Defaults to the class name, but can be customized.
-     */
-    i(this, "_id");
-    /**
-     * @internal
-     * Reference string used internally for tracking and debugging.
-     */
-    i(this, "_instanceRef");
-    /**
-     * @internal
-     * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
-     */
-    i(this, "_keepAlive", !1);
-    /**
-     * @readonly
-     * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
-     */
-    i(this, "_createdAt", Date.now());
-    /**
-     * @internal
-     * Atomic disposal state to prevent race conditions
-     */
-    i(this, "_disposalState", "active");
-    /**
-     * @internal
-     * Timestamp when disposal was requested (for React Strict Mode grace period)
-     */
-    i(this, "_disposalRequestTime", 0);
-    /**
-     * @internal
-     * The current state of the Bloc.
-     */
-    i(this, "_state");
-    /**
-     * @internal
-     * The previous state of the Bloc, maintained for comparison and history.
-     */
-    i(this, "_oldState");
-    /**
-     * Props passed during Bloc instance creation.
-     * Can be used to configure or parameterize the Bloc's behavior.
-     */
-    i(this, "props", null);
-    /**
-     * @internal
-     * Flag to prevent batching race conditions
-     */
-    i(this, "_batchingLock", !1);
-    /**
-     * @internal
-     * Pending batched updates
-     */
-    i(this, "_pendingUpdates", []);
-    /**
-     * @internal
-     * Map of consumer IDs to their WeakRef objects for proper cleanup
-     */
-    i(this, "_consumerRefs", /* @__PURE__ */ new Map());
-    /**
-     * @internal
-     * Validates that all consumer references are still alive
-     * Removes dead consumers automatically
-     */
-    i(this, "_validateConsumers", () => {
-      const e = [];
-      for (const [t, s] of this._consumerRefs)
-        s.deref() === void 0 && e.push(t);
-      for (const t of e)
-        this._consumers.delete(t), this._consumerRefs.delete(t);
-      this._consumers.size === 0 && !this._keepAlive && this._disposalState === "active" && this._scheduleDisposal();
-    });
-    /**
-     * @internal
-     * Updates the Bloc instance's ID to a new value.
-     * Only updates if the new ID is defined and different from the current one.
-     *
-     * @param id The new ID to assign to this Bloc instance
-     */
-    i(this, "_updateId", (e) => {
-      const t = this._id;
-      !e || e === t || (this._id = e);
-    });
-    /**
-     * @internal
-     * Optional function to be called when the Bloc is disposed.
-     */
-    i(this, "onDispose");
-    /**
-     * @internal
-     * Set of consumer IDs currently listening to this Bloc's state changes.
-     */
-    i(this, "_consumers", /* @__PURE__ */ new Set());
-    /**
-     * @internal
-     * Registers a new consumer to this Bloc instance.
-     * Notifies the Blac manager that a consumer has been added.
-     *
-     * @param consumerId The unique ID of the consumer being added
-     * @param consumerRef Optional reference to the consumer object for cleanup validation
-     */
-    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}`
-      )), !0);
-    });
-    /**
-     * @internal
-     * Unregisters a consumer from this Bloc instance.
-     * Notifies the Blac manager that a consumer has been removed.
-     *
-     * @param consumerId The unique ID of the consumer being removed
-     */
-    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}`
-      ), this._consumers.size === 0 && !this._keepAlive && this._disposalState === "active" && ((s = globalThis.Blac) == null || s.log(
-        `[${this._name}:${this._id}] No consumers left and not keep-alive. Scheduling disposal.`
-      ), this._scheduleDisposal()));
-    });
-    /**
-     * @internal
-     * Handler function for disposal (can be set by Blac manager)
-     */
-    i(this, "_disposalHandler");
-    i(this, "lastUpdate", Date.now());
-    /**
-     * @internal
-     * Flag to indicate if batching is enabled for this bloc
-     */
-    i(this, "_batchingEnabled", !1);
-    /**
-     * @internal
-     * Updates the state and notifies all observers of the change.
-     *
-     * @param newState The new state to be set
-     * @param oldState The previous state for comparison
-     * @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();
-      }
-    });
-    /**
-     * Enables batching for multiple state updates
-     * @param batchFn Function to execute with batching enabled
-     */
-    i(this, "batch", (e) => {
-      if (this._batchingLock)
-        return e();
-      this._batchingLock = !0, this._batchingEnabled = !0, this._pendingUpdates = [];
+  executeHook(e, t, s) {
+    for (const i of this.executionOrder) {
+      const n = this.plugins.get(i), a = n[e];
+      if (typeof a != "function") continue;
+      const c = performance.now();
       try {
-        const t = e();
-        if (this._pendingUpdates.length > 0) {
-          const s = this._pendingUpdates[this._pendingUpdates.length - 1];
-          this._observer.notify(
-            s.newState,
-            s.oldState,
-            s.action
-          ), this.lastUpdate = Date.now();
-        }
-        return t;
-      } finally {
-        this._batchingEnabled = !1, this._batchingLock = !1, this._pendingUpdates = [];
+        a.apply(n, t), this.recordSuccess(i, e, c);
+      } catch (l) {
+        this.recordError(i, e, l), s ? s(l, n) : console.error(
+          `Plugin '${i}' error in hook '${e}':`,
+          l
+        );
       }
-    });
-    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;
+    }
   }
-  get isIsolated() {
-    return this._isolated;
+  /**
+   * Bootstrap all plugins
+   */
+  bootstrap() {
+    this.executeHook("beforeBootstrap", []), this.executeHook("afterBootstrap", []);
   }
-  get isKeepAlive() {
-    return this._keepAlive;
+  /**
+   * Shutdown all plugins
+   */
+  shutdown() {
+    this.executeHook("beforeShutdown", []), this.executeHook("afterShutdown", []);
   }
   /**
-   * Returns the current state of the Bloc.
-   * Use this getter to access the state in a read-only manner.
-   * Returns the state even during transitional lifecycle states for React compatibility.
+   * Notify plugins of bloc creation
    */
-  get state() {
-    return this._disposalState === "disposed" ? this._state : this._state;
+  notifyBlocCreated(e) {
+    this.executeHook("onBlocCreated", [e]);
   }
   /**
-   * Returns whether this Bloc instance has been disposed.
-   * @returns true if the bloc is in DISPOSED state
+   * Notify plugins of bloc disposal
    */
-  get isDisposed() {
-    return this._disposalState === "disposed";
+  notifyBlocDisposed(e) {
+    this.executeHook("onBlocDisposed", [e]);
   }
   /**
-   * @internal
-   * Returns the name of the Bloc class for identification and debugging.
+   * Notify plugins of state change
    */
-  get _name() {
-    return this.constructor.name;
+  notifyStateChanged(e, t, s) {
+    this.executeHook("onStateChanged", [e, t, s]);
   }
   /**
-   * @internal
-   * Performs atomic state transition using compare-and-swap semantics
-   * @param expectedState The expected current state
-   * @param newState The desired new state
-   * @returns Result indicating success/failure and state information
+   * Notify plugins of event addition
    */
-  _atomicStateTransition(e, t) {
-    var s, n, r, 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(
-        `[${this._name}:${this._id}] State transition: ${a} -> ${t} (SUCCESS)`
-      )), {
-        success: !0,
-        currentState: t,
-        previousState: a
-      };
-    }
-    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,
-      currentState: this._disposalState,
-      previousState: e
+  notifyEventAdded(e, t) {
+    this.executeHook("onEventAdded", [e, t]);
+  }
+  /**
+   * Notify plugins of errors
+   */
+  notifyError(e, t, s) {
+    this.executeHook("onError", [e, t, s], (i, n) => {
+      console.error(`Plugin '${n.name}' error handler failed:`, i);
+    });
+  }
+  /**
+   * Notify plugins of adapter lifecycle events
+   */
+  notifyAdapterCreated(e, t) {
+    this.executeHook("onAdapterCreated", [e, t]);
+  }
+  notifyAdapterMount(e, t) {
+    this.executeHook("onAdapterMount", [e, t]);
+  }
+  notifyAdapterUnmount(e, t) {
+    this.executeHook("onAdapterUnmount", [e, t]);
+  }
+  notifyAdapterRender(e, t) {
+    this.executeHook("onAdapterRender", [e, t]);
+  }
+  notifyAdapterDisposed(e, t) {
+    this.executeHook("onAdapterDisposed", [e, t]);
+  }
+  /**
+   * 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 i = this.metrics.get(e), n = i.get(t) || {
+      executionTime: 0,
+      executionCount: 0,
+      errorCount: 0
+    }, a = performance.now() - s;
+    i.set(t, {
+      ...n,
+      executionTime: n.executionTime + a,
+      executionCount: n.executionCount + 1,
+      lastExecutionTime: a
+    });
+  }
+  recordError(e, t, s) {
+    const i = this.metrics.get(e), n = i.get(t) || {
+      executionTime: 0,
+      executionCount: 0,
+      errorCount: 0
     };
+    i.set(t, {
+      ...n,
+      errorCount: n.errorCount + 1,
+      lastError: s
+    });
+  }
+}
+var v = /* @__PURE__ */ ((r) => (r.LIFECYCLE = "LIFECYCLE", r.STATE = "STATE", r.PLUGIN = "PLUGIN", r.VALIDATION = "VALIDATION", r.DISPOSAL = "DISPOSAL", r.CONSUMER = "CONSUMER", r))(v || {}), y = /* @__PURE__ */ ((r) => (r.FATAL = "FATAL", r.ERROR = "ERROR", r.WARNING = "WARNING", r.INFO = "INFO", r))(y || {});
+class m extends Error {
+  constructor(e, t, s, i, n) {
+    super(e), this.category = t, this.severity = s, this.context = i, this.cause = n, this.name = "BlacError", Object.setPrototypeOf(this, m.prototype);
+  }
+  toString() {
+    const e = this.context ? ` [${Object.entries(this.context).filter(([t, s]) => s !== void 0).map(([t, s]) => `${t}: ${s}`).join(", ")}]` : "";
+    return `${this.name} [${this.severity}/${this.category}]: ${this.message}${e}`;
+  }
+}
+const P = {
+  shouldPropagate: (r) => r.severity === "FATAL",
+  shouldLog: (r) => r.severity !== "INFO",
+  handle: (r) => {
+    P.shouldLog(r) && console.error(r.toString(), r.cause);
   }
+};
+class f {
+  static instance;
+  handlers = /* @__PURE__ */ new Set();
+  strategy = P;
   /**
-   * @internal
-   * Cleans up resources and removes this Bloc from the system.
-   * Notifies the Blac manager and clears all observers.
+   * Get the singleton instance of ErrorManager
    */
-  _dispose() {
-    var t;
-    let e = this._atomicStateTransition(
-      "active",
-      "disposing"
-      /* DISPOSING */
-    );
-    if (e.success || (e = this._atomicStateTransition(
-      "disposal_requested",
-      "disposing"
-      /* DISPOSING */
-    )), !e.success)
-      return !1;
-    try {
-      return this._consumers.clear(), this._consumerRefs.clear(), this._observer.clear(), (t = this.onDispose) == null || t.call(this), this._atomicStateTransition(
-        "disposing",
-        "disposed"
-        /* DISPOSED */
-      ).success;
-    } catch (s) {
-      throw this._disposalState = "active", s;
-    }
+  static getInstance() {
+    return f.instance || (f.instance = new f()), f.instance;
   }
   /**
-   * @internal
-   * Sets the disposal handler for this bloc
+   * Set a custom error handling strategy
    */
-  _setDisposalHandler(e) {
-    this._disposalHandler = e;
+  setStrategy(e) {
+    this.strategy = e;
   }
   /**
-   * @internal
-   * Schedules disposal of this bloc instance if it has no consumers
-   * Uses atomic state transitions to prevent race conditions
+   * Add a custom error handler that will be called for all errors
    */
-  _scheduleDisposal() {
-    if (!this._atomicStateTransition(
-      "active",
-      "disposal_requested"
-      /* DISPOSAL_REQUESTED */
-    ).success)
+  addHandler(e) {
+    this.handlers.add(e);
+  }
+  /**
+   * Remove a previously added error handler
+   */
+  removeHandler(e) {
+    this.handlers.delete(e);
+  }
+  /**
+   * Process an error through all handlers and apply the configured strategy
+   */
+  handle(e) {
+    if (this.handlers.forEach((t) => {
+      try {
+        t(e);
+      } catch (s) {
+        console.error("Error in error handler:", s);
+      }
+    }), this.strategy.handle(e), this.strategy.shouldPropagate(e))
+      throw e;
+  }
+  /**
+   * Convenience method for wrapping operations with error handling
+   */
+  wrap(e, t) {
+    try {
+      return e();
+    } catch (s) {
+      const i = t(s);
+      this.handle(i);
       return;
-    if (!(this._consumers.size === 0 && !this._keepAlive)) {
-      this._atomicStateTransition(
-        "disposal_requested",
-        "active"
-        /* ACTIVE */
-      );
+    }
+  }
+  /**
+   * Async version of wrap
+   */
+  async wrapAsync(e, t) {
+    try {
+      return await e();
+    } catch (s) {
+      const i = t(s);
+      this.handle(i);
       return;
     }
-    this._disposalRequestTime = Date.now(), queueMicrotask(() => {
-      this._consumers.size === 0 && !this._keepAlive && this._observer.size === 0 && this._disposalState === "disposal_requested" ? this._disposalHandler ? this._disposalHandler(this) : this._dispose() : this._atomicStateTransition(
-        "disposal_requested",
-        "active"
-        /* ACTIVE */
-      );
-    });
   }
 }
-/**
- * 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), /**
- * 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 {
+class g {
+  static _instance;
   getInstance() {
-    return y._instance || (y._instance = new d({
+    return g._instance || (g._instance = new o({
       __unsafe_ignore_singleton: !0
-    })), y._instance;
+    })), g._instance;
   }
   setInstance(e) {
-    y._instance = e;
+    g._instance = e;
   }
   resetInstance() {
-    const e = y._instance;
-    if (y._instance = new d({
+    const e = g._instance;
+    if (g._instance = new o({
       __unsafe_ignore_singleton: !0
     }), e)
       for (const t of e.keepAliveBlocs)
-        y._instance.keepAliveBlocs.add(t), y._instance.uidRegistry.set(t.uid, t);
+        g._instance.keepAliveBlocs.add(t), g._instance.uidRegistry.set(t.uid, t);
   }
-};
-i(y, "_instance");
-let C = y, S = new C();
-function q(c) {
-  S = 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 */
-    i(this, "createdAt", Date.now());
-    /** Map storing all registered bloc instances by their class name and ID */
-    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.
-    i(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
-    /** Map for O(1) lookup of isolated blocs by UID */
-    i(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
-    /** Map tracking UIDs to prevent memory leaks */
-    i(this, "uidRegistry", /* @__PURE__ */ new Map());
-    /** Set of keep-alive blocs for controlled cleanup */
-    i(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
-    /** Flag to control whether changes should be posted to document */
-    i(this, "postChangesToDocument", !1);
-    /**
-     * 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;
-    });
-    /**
-     * Logs a warning message
-     * @param message - Warning message
-     * @param args - Additional arguments
-     */
-    i(this, "warn", (e, ...t) => {
-      l.enableLog;
-    });
-    /**
-     * Logs an error message
-     * @param message - Error message
-     * @param args - Additional arguments
-     */
-    i(this, "error", (e, ...t) => {
-      l.enableLog;
-    });
-    /**
-     * Resets the Blac instance to a new one, disposing non-keepAlive blocs
-     * from the old instance.
-     */
-    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((n) => {
-          !n._keepAlive && n._disposalState === _.ACTIVE && this.disposeBloc(n);
-        });
-      }), 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
-     */
-    i(this, "disposeBloc", (e) => {
-      const t = e._disposalState;
-      if (![
-        _.ACTIVE,
-        _.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);
-      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);
-    });
-    i(this, "activateBloc", (e) => {
-      if (e._disposalState !== _.ACTIVE) {
-        this.log(
-          `[${e._name}:${String(e._id)}] activateBloc called on disposed bloc. Ignoring.`
-        );
-        return;
-      }
-      const t = e.constructor;
-      (e.isIsolated ? this.findIsolatedBlocInstance(t, e._id) : this.findRegisteredBlocInstance(t, e._id)) || (this.log(
-        `[${e._name}:${String(e._id)}] activateBloc called. Isolated: ${String(e.isIsolated)}`
-      ), e.isIsolated ? this.registerIsolatedBlocInstance(e) : this.registerBlocInstance(e));
-    });
-    /**
-     * Gets or creates a bloc instance based on the provided class and options.
-     * If a bloc with the given ID exists, it will be returned. Otherwise, a new instance will be created.
-     *
-     * @param blocClass - The bloc class to get or create
-     * @param options - Options including:
-     *   - id: The instance ID (defaults to class name if not provided)
-     *   - props: Properties to pass to the bloc constructor
-     *   - instanceRef: Optional reference string for the instance
-     * @returns The bloc instance
-     */
-    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
-      }), !n)
-        if (r.isolated) {
-          const u = this.findIsolatedBlocInstance(
-            e,
-            t.instanceRef ?? o
-          );
-          if (u)
-            return u;
-          if (t.throwIfNotFound)
-            throw new Error(`Isolated bloc ${e.name} not found`);
-        } else {
-          const u = this.findRegisteredBlocInstance(
-            e,
-            o
-          );
-          if (u)
-            return u;
-          if (t.throwIfNotFound)
-            throw new Error(`Registered bloc ${e.name} not found`);
-        }
-      const a = this.createNewBlocInstance(e, o, t);
-      if (this.log(
-        `[${e.name}:${String(o)}] (getBloc) No existing instance found. Creating new one.`,
-        t,
-        a
-      ), !a)
-        throw new Error(
-          `[getBloc] Failed to create bloc instance for ${e.name}. This should never happen.`
-        );
-      return a;
-    });
-    /**
-     * Gets a bloc instance or throws an error if it doesn't exist
-     * @param blocClass - The bloc class to get
-     * @param options - Options including:
-     *   - id: The instance ID (defaults to class name if not provided)
-     *   - props: Properties to pass to the bloc constructor
-     *   - 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;
-      throw new Error(`Bloc ${e.name} not found`);
-    });
-    /**
-     * Gets all instances of a specific bloc class
-     * @param blocClass - The bloc class to search for
-     * @param options - Options including:
-     *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
-     * @returns Array of matching bloc instances
-     */
-    i(this, "getAllBlocs", (e, t = {}) => {
-      const s = [];
-      if (this.blocInstanceMap.forEach((n) => {
-        n.constructor === e && s.push(n);
-      }), t.searchIsolated !== !1) {
-        const n = this.isolatedBlocMap.get(e);
-        n && s.push(...n.map((r) => r));
-      }
-      return s;
-    });
-    /**
-     * Disposes all keep-alive blocs of a specific type
-     * @param blocClass - The bloc class to dispose
-     */
-    i(this, "disposeKeepAliveBlocs", (e) => {
-      const t = [];
-      for (const s of this.keepAliveBlocs)
-        (!e || s.constructor === e) && t.push(s);
-      t.forEach((s) => s._dispose());
-    });
-    /**
-     * Disposes all blocs matching a pattern
-     * @param predicate - Function to test each bloc for disposal
-     */
-    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 n of s)
-          e(n) && t.push(n);
-      t.forEach((s) => s._dispose());
-    });
-    /**
-     * Gets memory usage statistics for debugging
-     */
-    i(this, "getMemoryStats", () => ({
-      totalBlocs: this.uidRegistry.size,
-      registeredBlocs: this.blocInstanceMap.size,
-      isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce(
-        (e, t) => e + t.length,
-        0
-      ),
-      keepAliveBlocs: this.keepAliveBlocs.size,
-      isolatedBlocTypes: this.isolatedBlocMap.size
-    }));
-    /**
-     * Validates consumer references and cleans up orphaned consumers
-     */
-    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);
-        }, 1e3);
-    });
-    const { __unsafe_ignore_singleton: t = !1 } = e;
-    if (!t)
-      return l.instance;
-    S.setInstance(this);
-  }
+let b = new g();
+function H(r) {
+  b = r;
+}
+class o {
   static get instance() {
-    return S.getInstance();
+    return b.getInstance();
   }
+  /** Timestamp when the instance was created */
+  createdAt = Date.now();
+  errorManager = f.getInstance();
   static get getAllBlocs() {
-    return l.instance.getAllBlocs;
+    return o.instance.getAllBlocs;
   }
+  /** Private static configuration */
+  static _config = {
+    proxyDependencyTracking: !0
+  };
   /** Get current configuration */
   static get config() {
     return { ...this._config };
@@ -702,174 +366,1106 @@ const l = class l {
    * @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");
+    if (e.proxyDependencyTracking !== void 0 && typeof e.proxyDependencyTracking != "boolean") {
+      const t = new m(
+        "BlacConfig.proxyDependencyTracking must be a boolean",
+        v.VALIDATION,
+        y.FATAL
+      );
+      this.instance.errorManager.handle(t);
+    }
     this._config = {
       ...this._config,
       ...e
     }, this.enableLog && this.instance.log("Blac config updated:", this._config);
   }
+  /** Map storing all registered bloc instances by their class name and ID */
+  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.
+  isolatedBlocMap = /* @__PURE__ */ new Map();
+  /** Map for O(1) lookup of isolated blocs by UID */
+  isolatedBlocIndex = /* @__PURE__ */ new Map();
+  /** Map tracking UIDs to prevent memory leaks */
+  uidRegistry = /* @__PURE__ */ new Map();
+  /** Set of keep-alive blocs for controlled cleanup */
+  keepAliveBlocs = /* @__PURE__ */ new Set();
+  /** Flag to control whether changes should be posted to document */
+  postChangesToDocument = !1;
+  /** System plugin registry */
+  plugins = new T();
+  /**
+   * Creates a new Blac instance.
+   * @param options - Configuration options including singleton control
+   */
+  constructor(e = {}) {
+    const { __unsafe_ignore_singleton: t = !1 } = e;
+    if (!t)
+      return o.instance;
+    b.setInstance(this), this.plugins.bootstrap();
+  }
+  /** Flag to enable/disable logging */
+  static enableLog = !1;
+  static logLevel = "warn";
+  static logSpy = null;
+  /**
+   * Logs messages to console when logging is enabled
+   * @param args - Arguments to log
+   */
+  log = (...e) => {
+    o.logSpy && o.logSpy(e), o.enableLog && o.logLevel, o.enableLog && o.logLevel;
+  };
   static get log() {
-    return l.instance.log;
+    return o.instance.log;
   }
   /**
    * Gets the current Blac instance
    * @returns The Blac instance
    */
   static getInstance() {
-    return S.getInstance();
+    return b.getInstance();
   }
+  /**
+   * Logs a warning message
+   * @param message - Warning message
+   * @param args - Additional arguments
+   */
+  warn = (e, ...t) => {
+    console.warn(e, ...t);
+  };
   static get warn() {
-    return l.instance.warn;
+    return o.instance.warn;
   }
+  /**
+   * Logs an error message
+   * @param message - Error message
+   * @param args - Additional arguments
+   */
+  error = (e, ...t) => {
+    o.enableLog && console.error(e, ...t);
+  };
   static get error() {
-    return l.instance.error;
+    return o.instance.error;
   }
+  /**
+   * Resets the Blac instance to a new one, disposing non-keepAlive blocs
+   * from the old instance.
+   */
+  resetInstance = () => {
+    this.log("Reset Blac instance");
+    const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
+    e.forEach((s) => {
+      !s._keepAlive && s._disposalState === u.ACTIVE && this.disposeBloc(s);
+    }), t.forEach((s) => {
+      s.forEach((i) => {
+        !i._keepAlive && i._disposalState === u.ACTIVE && this.disposeBloc(i);
+      });
+    }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), b.resetInstance();
+  };
+  static resetInstance = () => {
+    b.resetInstance();
+  };
+  /**
+   * Disposes of a bloc instance by removing it from the appropriate registry
+   * @param bloc - The bloc instance to dispose
+   */
+  disposeBloc = (e) => {
+    const t = e._disposalState;
+    if (![
+      u.ACTIVE,
+      u.DISPOSAL_REQUESTED
+    ].includes(t)) {
+      this.log(
+        `[${e._name}:${String(e._id)}] disposeBloc called on bloc in invalid state: ${t}`
+      );
+      return;
+    }
+    const i = e.constructor, n = this.createBlocInstanceMapKey(e._name, e._id);
+    this.log(
+      `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(i.isolated)}`
+    ), e.dispose(), this.plugins.notifyBlocDisposed(e), i.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(n)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
+  };
   static get disposeBloc() {
-    return l.instance.disposeBloc;
+    return o.instance.disposeBloc;
+  }
+  /**
+   * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
+   * @param blocClassName - The name of the bloc class
+   * @param id - The instance ID
+   * @returns A unique key string in the format "className:id"
+   */
+  createBlocInstanceMapKey(e, t) {
+    return `${e}:${String(t)}`;
+  }
+  /**
+   * Unregister a bloc instance from the main registry
+   * @param bloc - The bloc instance to unregister
+   */
+  unregisterBlocInstance(e) {
+    const t = this.createBlocInstanceMapKey(e._name, e._id);
+    this.blocInstanceMap.delete(t), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
+  }
+  /**
+   * Registers a bloc instance in the main registry
+   * @param bloc - The bloc instance to register
+   */
+  registerBlocInstance(e) {
+    const t = this.createBlocInstanceMapKey(e._name, e._id);
+    this.blocInstanceMap.set(t, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
+  }
+  /**
+   * Finds a registered bloc instance by its class and ID
+   * @param blocClass - The bloc class to search for
+   * @param id - The instance ID
+   * @returns The found bloc instance or undefined if not found
+   */
+  findRegisteredBlocInstance(e, t) {
+    if (e.isolated) return;
+    const i = this.createBlocInstanceMapKey(e.name, t), n = this.blocInstanceMap.get(i);
+    if (!(n && n.isDisposed))
+      return n;
+  }
+  /**
+   * Registers an isolated bloc instance in the isolated registry
+   * @param bloc - The isolated bloc instance to register
+   */
+  registerIsolatedBlocInstance(e) {
+    const t = e.constructor, s = this.isolatedBlocMap.get(t);
+    s ? s.push(e) : this.isolatedBlocMap.set(t, [e]), this.isolatedBlocIndex.set(e.uid, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
+  }
+  /**
+   * Unregister an isolated bloc instance from the isolated registry
+   * @param bloc - The isolated bloc instance to unregister
+   */
+  unregisterIsolatedBlocInstance(e) {
+    const t = e.constructor, s = this.isolatedBlocMap.get(t);
+    let i = !1;
+    if (s) {
+      const a = s.findIndex((c) => c.uid === e.uid);
+      a !== -1 && (s.splice(a, 1), i = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
+    }
+    const n = this.isolatedBlocIndex.delete(e.uid);
+    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), i !== n && this.warn(
+      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${i}, Index removal: ${n}`
+    );
+  }
+  /**
+   * Finds an isolated bloc instance by its class and ID (O(n) lookup)
+   */
+  findIsolatedBlocInstance(e, t) {
+    if (!e.isolated) return;
+    const i = this.isolatedBlocMap.get(e);
+    return i ? i.find((a) => a._id === t && !a.isDisposed) : void 0;
+  }
+  /**
+   * Finds an isolated bloc instance by UID (O(1) lookup)
+   */
+  findIsolatedBlocInstanceByUid(e) {
+    return this.isolatedBlocIndex.get(e);
+  }
+  /**
+   * Creates a new bloc instance and registers it in the appropriate registry
+   * @param blocClass - The bloc class to instantiate
+   * @param id - The instance ID
+   * @param props - Properties to pass to the bloc constructor
+   * @param instanceRef - Optional reference string for the instance
+   * @returns The newly created bloc instance
+   */
+  createNewBlocInstance(e, t, s = {}) {
+    const { constructorParams: i, instanceRef: n } = s, a = new e(i);
+    return a.blacInstance = this, a._instanceRef = n, a._id = t, a.setDisposalHandler((c) => this.disposeBloc(c)), a.isIsolated ? this.registerIsolatedBlocInstance(a) : this.registerBlocInstance(a), this.plugins.notifyBlocCreated(a), a;
+  }
+  activateBloc = (e) => {
+    if (e._disposalState !== u.ACTIVE) {
+      this.log(
+        `[${e._name}:${String(e._id)}] activateBloc called on disposed bloc. Ignoring.`
+      );
+      return;
+    }
+    const t = e.constructor;
+    (e.isIsolated ? this.findIsolatedBlocInstance(t, e._id) : this.findRegisteredBlocInstance(t, e._id)) || (this.log(
+      `[${e._name}:${String(e._id)}] activateBloc called. Isolated: ${String(e.isIsolated)}`
+    ), e.isIsolated ? this.registerIsolatedBlocInstance(e) : this.registerBlocInstance(e));
+  };
+  static get activateBloc() {
+    return o.instance.activateBloc;
+  }
+  /**
+   * Gets or creates a bloc instance based on the provided class and options.
+   * If a bloc with the given ID exists, it will be returned. Otherwise, a new instance will be created.
+   *
+   * @param blocClass - The bloc class to get or create
+   * @param options - Options including:
+   *   - id: The instance ID (defaults to class name if not provided)
+   *   - props: Properties to pass to the bloc constructor
+   *   - instanceRef: Optional reference string for the instance
+   * @returns The bloc instance
+   */
+  getBloc = (e, t = {}) => {
+    const { id: s, forceNewInstance: i } = t, n = e, a = s ?? e.name;
+    if (this.log(`[${e.name}:${String(a)}] (getBloc) Called:`, {
+      options: t,
+      base: n
+    }), !i)
+      if (n.isolated) {
+        const l = this.findIsolatedBlocInstance(
+          e,
+          t.instanceRef ?? a
+        );
+        if (l)
+          return l;
+        if (t.throwIfNotFound)
+          throw new Error(`Isolated bloc ${e.name} not found`);
+      } else {
+        const l = this.findRegisteredBlocInstance(
+          e,
+          a
+        );
+        if (l)
+          return l;
+        if (t.throwIfNotFound)
+          throw new Error(`Registered bloc ${e.name} not found`);
+      }
+    const c = this.createNewBlocInstance(e, a, t);
+    if (this.log(
+      `[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`,
+      t,
+      c
+    ), !c)
+      throw new Error(
+        `[getBloc] Failed to create bloc instance for ${e.name}. This should never happen.`
+      );
+    return c;
+  };
+  static get getBloc() {
+    return o.instance.getBloc;
+  }
+  /**
+   * Gets all instances of a specific bloc class
+   * @param blocClass - The bloc class to search for
+   * @param options - Options including:
+   *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
+   * @returns Array of matching bloc instances
+   */
+  getAllBlocs = (e, t = {}) => {
+    const s = [];
+    if (this.blocInstanceMap.forEach((i) => {
+      i.constructor === e && s.push(i);
+    }), t.searchIsolated !== !1) {
+      const i = this.isolatedBlocMap.get(e);
+      i && s.push(...i.map((n) => n));
+    }
+    return s;
+  };
+  /**
+   * Disposes all keep-alive blocs of a specific type
+   * @param blocClass - The bloc class to dispose
+   */
+  disposeKeepAliveBlocs = (e) => {
+    const t = [];
+    for (const s of this.keepAliveBlocs)
+      (!e || s.constructor === e) && t.push(s);
+    t.forEach((s) => s.dispose());
+  };
+  static get disposeKeepAliveBlocs() {
+    return o.instance.disposeKeepAliveBlocs;
+  }
+  /**
+   * Disposes all blocs matching a pattern
+   * @param predicate - Function to test each bloc for disposal
+   */
+  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);
+    t.forEach((s) => s.dispose());
+  };
+  static get disposeBlocs() {
+    return o.instance.disposeBlocs;
+  }
+  /**
+   * Gets memory usage statistics for debugging
+   */
+  getMemoryStats = () => ({
+    totalBlocs: this.uidRegistry.size,
+    registeredBlocs: this.blocInstanceMap.size,
+    isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce(
+      (e, t) => e + t.length,
+      0
+    ),
+    keepAliveBlocs: this.keepAliveBlocs.size,
+    isolatedBlocTypes: this.isolatedBlocMap.size
+  });
+  static get getMemoryStats() {
+    return o.instance.getMemoryStats;
+  }
+  /**
+   * Validates subscription references and cleans up orphaned blocs
+   */
+  validateConsumers = () => {
+    for (const e of this.uidRegistry.values())
+      e.subscriptionCount === 0 && !e._keepAlive && e._disposalState === u.ACTIVE && setTimeout(() => {
+        e.subscriptionCount === 0 && !e._keepAlive && e._disposalState === u.ACTIVE && this.disposeBloc(e);
+      }, 1e3);
+  };
+  static get validateConsumers() {
+    return o.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);
+  }
+}
+function A() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(r) {
+    const e = Math.random() * 16 | 0;
+    return (r === "x" ? e : e & 3 | 8).toString(16);
+  });
+}
+const x = {
+  fatal: (r, e, t, s) => {
+    const i = new m(
+      r,
+      e,
+      y.FATAL,
+      t,
+      s
+    );
+    throw f.getInstance().handle(i), i;
+  },
+  error: (r, e, t, s) => {
+    const i = new m(
+      r,
+      e,
+      y.ERROR,
+      t,
+      s
+    );
+    f.getInstance().handle(i);
+  },
+  warn: (r, e, t, s) => {
+    const i = new m(
+      r,
+      e,
+      y.WARNING,
+      t,
+      s
+    );
+    f.getInstance().handle(i);
+  },
+  info: (r, e, t) => {
+    const s = new m(r, e, y.INFO, t);
+    f.getInstance().handle(s);
+  },
+  /**
+   * Wraps a function to catch and handle errors
+   */
+  wrap: (r, e, t, s = y.ERROR) => {
+    try {
+      return r();
+    } catch (i) {
+      const n = i instanceof Error ? i.message : String(i), a = new m(n, e, s, t, i);
+      f.getInstance().handle(a);
+      return;
+    }
+  },
+  /**
+   * Wraps an async function to catch and handle errors
+   */
+  wrapAsync: async (r, e, t, s = y.ERROR) => {
+    try {
+      return await r();
+    } catch (i) {
+      const n = i instanceof Error ? i.message : String(i), a = new m(n, e, s, t, i);
+      f.getInstance().handle(a);
+      return;
+    }
+  }
+};
+class w {
+  plugins = /* @__PURE__ */ new Map();
+  executionOrder = [];
+  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);
+    return t ? (this.attached && t.onDetach && x.wrap(() => t.onDetach(), v.PLUGIN, {
+      pluginName: e,
+      operation: "onDetach"
+    }), this.plugins.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() {
+    if (this.attached)
+      for (const e of this.getAll())
+        e.onDetach && x.wrap(() => e.onDetach(), v.PLUGIN, {
+          pluginName: e.name,
+          operation: "onDetach"
+        });
+    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 i of this.getAll())
+      if (i.transformState && this.canTransformState(i))
+        try {
+          s = i.transformState(
+            e,
+            s
+          );
+        } catch (n) {
+          console.error(
+            `Plugin '${i.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 (i) {
+          console.error(
+            `Plugin '${s.name}' error in transformEvent:`,
+            i
+          );
+        }
+    }
+    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 (i) {
+          console.error(
+            `Plugin '${s.name}' error in onStateChange:`,
+            i
+          );
+        }
+  }
+  /**
+   * 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 (i) {
+          console.error(`Plugin '${s.name}' error in onError:`, i);
+        }
+  }
+  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;
+  }
+}
+class E {
+  constructor(e) {
+    this.bloc = e;
+  }
+  subscriptions = /* @__PURE__ */ new Map();
+  pathToSubscriptions = /* @__PURE__ */ new Map();
+  weakRefCleanupScheduled = !1;
+  totalNotifications = 0;
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(e) {
+    const t = `${e.type}-${A()}`, s = {
+      id: t,
+      type: e.type,
+      selector: e.selector,
+      equalityFn: e.equalityFn || Object.is,
+      notify: e.notify,
+      priority: e.priority ?? 0,
+      weakRef: e.weakRef,
+      dependencies: /* @__PURE__ */ new Set(),
+      metadata: {
+        lastNotified: Date.now(),
+        hasRendered: !1,
+        accessCount: 0,
+        firstAccessTime: Date.now()
+      }
+    };
+    if (s.selector)
+      try {
+        s.lastValue = s.selector(
+          this.bloc.state,
+          this.bloc
+        );
+      } catch (i) {
+        o.error(`SubscriptionManager: Error in selector for ${t}:`, i);
+      }
+    return this.subscriptions.set(t, s), o.log(
+      `[${this.bloc._name}:${this.bloc._id}] Subscription added: ${t}. Total: ${this.subscriptions.size}`
+    ), this.bloc._cancelDisposalIfRequested(), () => this.unsubscribe(t);
+  }
+  /**
+   * Unsubscribe by ID
+   */
+  unsubscribe(e) {
+    const t = this.subscriptions.get(e);
+    if (t) {
+      if (t.dependencies)
+        for (const s of t.dependencies) {
+          const i = this.pathToSubscriptions.get(s);
+          i && (i.delete(e), i.size === 0 && this.pathToSubscriptions.delete(s));
+        }
+      this.subscriptions.delete(e), o.log(
+        `[${this.bloc._name}:${this.bloc._id}] Subscription removed: ${e}. Remaining: ${this.subscriptions.size}`
+      ), this.bloc.checkDisposal();
+    }
+  }
+  /**
+   * Notify all subscriptions of state change
+   */
+  notify(e, t, s) {
+    this.cleanupDeadReferences();
+    const i = Array.from(this.subscriptions.values()).sort(
+      (n, a) => (a.priority ?? 0) - (n.priority ?? 0)
+    );
+    for (const n of i) {
+      if (n.weakRef && !n.weakRef.deref()) {
+        this.scheduleWeakRefCleanup();
+        continue;
+      }
+      let a = !1, c, l;
+      if (n.selector)
+        try {
+          c = n.selector(e, this.bloc), l = n.lastValue, a = !(n.equalityFn || Object.is)(l, c), a && (n.lastValue = c);
+        } catch (h) {
+          o.error(
+            `SubscriptionManager: Error in selector for ${n.id}:`,
+            h
+          );
+          continue;
+        }
+      else {
+        if (n.dependencies && n.dependencies.size > 0) {
+          const h = this.getChangedPaths(t, e);
+          a = this.shouldNotifyForPaths(
+            n.id,
+            h
+          ), o.config.logLevel === "debug" && (o.log(
+            `[SubscriptionManager] Subscription ${n.id} dependencies:`,
+            Array.from(n.dependencies)
+          ), o.log(
+            "[SubscriptionManager] Changed paths:",
+            Array.from(h)
+          ), o.log("[SubscriptionManager] Should notify:", a));
+        } else
+          a = !0;
+        c = e, l = t;
+      }
+      if (a)
+        try {
+          n.notify(c, l, s), this.totalNotifications++, n.metadata && (n.metadata.lastNotified = Date.now(), n.metadata.hasRendered = !0);
+        } catch (h) {
+          o.error(
+            `SubscriptionManager: Error in notify for ${n.id}:`,
+            h
+          );
+        }
+    }
+  }
+  /**
+   * Track a path access for a subscription
+   */
+  trackAccess(e, t, s) {
+    const i = this.subscriptions.get(e);
+    if (!i) return;
+    i.dependencies || (i.dependencies = /* @__PURE__ */ new Set()), i.dependencies.add(t);
+    let n = this.pathToSubscriptions.get(t);
+    n || (n = /* @__PURE__ */ new Set(), this.pathToSubscriptions.set(t, n)), n.add(e), i.metadata && (i.metadata.accessCount = (i.metadata.accessCount || 0) + 1, i.metadata.lastAccessTime = Date.now());
+  }
+  /**
+   * Get the paths that changed between two states
+   */
+  getChangedPaths(e, t, s = "") {
+    const i = /* @__PURE__ */ new Set();
+    if (e === t) return i;
+    if (typeof e != "object" || typeof t != "object" || e === null || t === null)
+      return s && i.add(s), i;
+    const n = /* @__PURE__ */ new Set([
+      ...Object.keys(e),
+      ...Object.keys(t)
+    ]);
+    for (const a of n) {
+      const c = s ? `${s}.${a}` : a, l = e[a], h = t[a];
+      l !== h && (i.add(c), typeof l == "object" && typeof h == "object" && l !== null && h !== null && this.getChangedPaths(
+        l,
+        h,
+        c
+      ).forEach((S) => i.add(S)));
+    }
+    return i;
+  }
+  /**
+   * Check if a subscription should be notified based on changed paths
+   */
+  shouldNotifyForPaths(e, t) {
+    const s = this.subscriptions.get(e);
+    if (!s || !s.dependencies) return !0;
+    for (const i of s.dependencies) {
+      if (i.startsWith("_class.")) {
+        if (t.size > 0)
+          return !0;
+        continue;
+      }
+      if (t.has(i)) return !0;
+      for (const n of t)
+        if (n.startsWith(i + ".") || i.startsWith(n + "."))
+          return !0;
+    }
+    return !1;
+  }
+  /**
+   * Get statistics about subscriptions
+   */
+  getStats() {
+    let e = 0, t = 0;
+    for (const s of this.subscriptions.values())
+      s.type === "consumer" ? e++ : t++;
+    return {
+      activeSubscriptions: this.subscriptions.size,
+      consumerCount: e,
+      observerCount: t,
+      totalNotifications: this.totalNotifications,
+      trackedDependencies: this.pathToSubscriptions.size
+    };
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clear() {
+    this.subscriptions.clear(), this.pathToSubscriptions.clear();
+  }
+  /**
+   * Get subscription by ID
+   */
+  getSubscription(e) {
+    return this.subscriptions.get(e);
+  }
+  /**
+   * Check if there are any active subscriptions
+   */
+  get hasSubscriptions() {
+    return this.subscriptions.size > 0;
+  }
+  /**
+   * Get count of active subscriptions
+   */
+  get size() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Clean up subscriptions with dead weak references
+   */
+  cleanupDeadReferences() {
+    if (!this.weakRefCleanupScheduled) return;
+    const e = [];
+    for (const [t, s] of this.subscriptions)
+      s.weakRef && !s.weakRef.deref() && e.push(t);
+    for (const t of e)
+      this.unsubscribe(t);
+    this.weakRefCleanupScheduled = !1;
+  }
+  /**
+   * Schedule weak reference cleanup for next tick
+   */
+  scheduleWeakRefCleanup() {
+    this.weakRefCleanupScheduled || (this.weakRefCleanupScheduled = !0, queueMicrotask(() => this.cleanupDeadReferences()));
+  }
+}
+class D {
+  pendingUpdates = [];
+  isBatching = !1;
+  /**
+   * Execute a callback with batched updates
+   */
+  batchUpdates(e, t) {
+    if (this.isBatching) {
+      e();
+      return;
+    }
+    this.isBatching = !0, this.pendingUpdates = [];
+    try {
+      if (e(), this.pendingUpdates.length > 0) {
+        const s = this.pendingUpdates[this.pendingUpdates.length - 1];
+        t(s);
+      }
+    } finally {
+      this.isBatching = !1, this.pendingUpdates = [];
+    }
+  }
+  /**
+   * Add an update to the batch
+   */
+  addUpdate(e) {
+    this.isBatching && this.pendingUpdates.push(e);
+  }
+  /**
+   * Check if currently batching
+   */
+  get isCurrentlyBatching() {
+    return this.isBatching;
+  }
+}
+class C {
+  uid = A();
+  blacInstance;
+  static isolated = !1;
+  get isIsolated() {
+    return this._isolated;
+  }
+  static keepAlive = !1;
+  get isKeepAlive() {
+    return this._keepAlive;
+  }
+  _isolated = !1;
+  _id;
+  _instanceRef;
+  _name;
+  /**
+   * Unified subscription manager for all state notifications
+   */
+  _subscriptionManager;
+  _state;
+  _lifecycleManager = new B();
+  _batchingManager = new D();
+  _keepAlive = !1;
+  lastUpdate;
+  _plugins = new w();
+  onDispose;
+  /**
+   * Creates a new BlocBase instance with unified subscription management
+   */
+  constructor(e) {
+    this._state = e, this._id = this.constructor.name, this._name = this.constructor.name, this._subscriptionManager = new E(this);
+    const t = this.constructor;
+    if (this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1, this._plugins = new w(), t.plugins && Array.isArray(t.plugins))
+      for (const s of t.plugins)
+        this._plugins.add(s);
+    this._plugins.attach(this);
+  }
+  /**
+   * Returns the current state
+   */
+  get state() {
+    return this._lifecycleManager.isDisposed ? this._state : this._state;
+  }
+  /**
+   * Subscribe to all state changes
+   */
+  subscribe(e) {
+    return this._subscriptionManager.subscribe({
+      type: "observer",
+      notify: (t) => e(t)
+    });
+  }
+  /**
+   * Subscribe with a selector for optimized updates
+   */
+  subscribeWithSelector(e, t, s) {
+    return this._subscriptionManager.subscribe({
+      type: "consumer",
+      selector: e,
+      equalityFn: s,
+      notify: (i) => t(i)
+    });
+  }
+  /**
+   * Subscribe with React component reference for automatic cleanup
+   */
+  subscribeComponent(e, t) {
+    return this._subscriptionManager.subscribe({
+      type: "consumer",
+      weakRef: e,
+      notify: t
+    });
+  }
+  /**
+   * Get current subscription count
+   */
+  get subscriptionCount() {
+    return this._subscriptionManager.size;
+  }
+  /**
+   * Track property access for a subscription
+   */
+  trackAccess(e, t, s) {
+    this._subscriptionManager.trackAccess(e, t, s);
+  }
+  /**
+   * Emit a new state
+   */
+  emit(e, t) {
+    this._pushState(e, this._state, t);
+  }
+  /**
+   * Internal state push method used by Bloc
+   */
+  _pushState(e, t, s) {
+    if (this._lifecycleManager.currentState !== u.ACTIVE) {
+      this.blacInstance?.error(
+        `[${this._name}:${this._id}] Attempted state update on ${this._lifecycleManager.currentState} bloc. Update ignored.`
+      );
+      return;
+    }
+    if (e === void 0)
+      return;
+    this._state = e;
+    const i = this._plugins.transformState(
+      t,
+      e
+    );
+    if (this._state = i, this._plugins.notifyStateChange(t, i), this.blacInstance?.plugins.notifyStateChanged(
+      this,
+      t,
+      i
+    ), this._batchingManager.isCurrentlyBatching) {
+      this._batchingManager.addUpdate({
+        newState: i,
+        oldState: t,
+        action: s
+      });
+      return;
+    }
+    this._subscriptionManager.notify(i, t, s), this.lastUpdate = Date.now();
+  }
+  _batchUpdates(e) {
+    this._batchingManager.batchUpdates(e, (t) => {
+      this._subscriptionManager.notify(
+        t.newState,
+        t.oldState,
+        t.action
+      );
+    });
   }
   /**
-   * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
-   * @param blocClassName - The name of the bloc class
-   * @param id - The instance ID
-   * @returns A unique key string in the format "className:id"
+   * Add a plugin
    */
-  createBlocInstanceMapKey(e, t) {
-    return `${e}:${String(t)}`;
+  addPlugin(e) {
+    if (this._plugins.add(e), this._plugins.attached && e.onAttach)
+      try {
+        e.onAttach(this);
+      } catch (t) {
+        console.error(`Plugin '${e.name}' error in onAttach:`, t);
+      }
   }
   /**
-   * Unregister a bloc instance from the main registry
-   * @param bloc - The bloc instance to unregister
+   * Remove a plugin
    */
-  unregisterBlocInstance(e) {
-    const t = this.createBlocInstanceMapKey(e._name, e._id);
-    this.blocInstanceMap.delete(t), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
+  removePlugin(e) {
+    this._plugins.remove(e.name);
   }
   /**
-   * Registers a bloc instance in the main registry
-   * @param bloc - The bloc instance to register
+   * Get all plugins
    */
-  registerBlocInstance(e) {
-    const t = this.createBlocInstanceMapKey(e._name, e._id);
-    this.blocInstanceMap.set(t, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
+  get plugins() {
+    return this._plugins.getAll();
   }
   /**
-   * Finds a registered bloc instance by its class and ID
-   * @param blocClass - The bloc class to search for
-   * @param id - The instance ID
-   * @returns The found bloc instance or undefined if not found
+   * Disposal management
    */
-  findRegisteredBlocInstance(e, t) {
-    if (e.isolated) return;
-    const n = this.createBlocInstanceMapKey(e.name, t);
-    return this.blocInstanceMap.get(n);
+  get isDisposed() {
+    return this._lifecycleManager.isDisposed;
   }
   /**
-   * Registers an isolated bloc instance in the isolated registry
-   * @param bloc - The isolated bloc instance to register
+   * Atomic state transition for disposal
    */
-  registerIsolatedBlocInstance(e) {
-    const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    s ? s.push(e) : this.isolatedBlocMap.set(t, [e]), this.isolatedBlocIndex.set(e.uid, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
+  _atomicStateTransition(e, t) {
+    return this._lifecycleManager.atomicStateTransition(
+      e,
+      t
+    );
   }
   /**
-   * Unregister an isolated bloc instance from the isolated registry
-   * @param bloc - The isolated bloc instance to unregister
+   * Dispose the bloc and clean up resources
    */
-  unregisterIsolatedBlocInstance(e) {
-    const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    let n = !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);
+  async dispose() {
+    if (!this._lifecycleManager.atomicStateTransition(
+      u.ACTIVE,
+      u.DISPOSING
+    ).success)
+      if (this._lifecycleManager.currentState === u.DISPOSAL_REQUESTED)
+        this._lifecycleManager.atomicStateTransition(
+          u.DISPOSAL_REQUESTED,
+          u.DISPOSING
+        );
+      else
+        return;
+    try {
+      this._subscriptionManager.clear(), this.onDispose && this.onDispose();
+      for (const s of this._plugins.getAll())
+        try {
+          "onDispose" in s && typeof s.onDispose == "function" && s.onDispose(this);
+        } catch (i) {
+          console.error("Plugin disposal error:", i);
+        }
+      const t = this._lifecycleManager.getDisposalHandler();
+      t && t(this);
+    } finally {
+      this._lifecycleManager.atomicStateTransition(
+        u.DISPOSING,
+        u.DISPOSED
+      );
     }
-    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}`
-    );
   }
   /**
-   * Finds an isolated bloc instance by its class and ID (O(n) lookup)
+   * Schedule disposal when no subscriptions remain
    */
-  findIsolatedBlocInstance(e, t) {
-    if (!e.isolated) return;
-    const n = this.isolatedBlocMap.get(e);
-    return n ? n.find((o) => o._id === t) : void 0;
+  _scheduleDisposal() {
+    this._subscriptionManager.size === 0 && !this._keepAlive && this._lifecycleManager.scheduleDisposal(
+      16,
+      () => this._subscriptionManager.size === 0 && !this._keepAlive,
+      () => this.dispose()
+    );
   }
   /**
-   * Finds an isolated bloc instance by UID (O(1) lookup)
+   * Set disposal handler
    */
-  findIsolatedBlocInstanceByUid(e) {
-    return this.isolatedBlocIndex.get(e);
+  setDisposalHandler(e) {
+    this._lifecycleManager.setDisposalHandler(
+      e
+    );
   }
   /**
-   * Creates a new bloc instance and registers it in the appropriate registry
-   * @param blocClass - The bloc class to instantiate
-   * @param id - The instance ID
-   * @param props - Properties to pass to the bloc constructor
-   * @param instanceRef - Optional reference string for the instance
-   * @returns The newly created bloc instance
+   * Check if disposal should be scheduled (called by subscription manager)
    */
-  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);
-  }
-  static get activateBloc() {
-    return l.instance.activateBloc;
+  checkDisposal() {
+    this._subscriptionManager.size === 0 && !this._keepAlive && this._lifecycleManager.currentState === u.ACTIVE && this._scheduleDisposal();
   }
-  static get getBloc() {
-    return l.instance.getBloc;
-  }
-  static get getBlocOrThrow() {
-    return l.instance.getBlocOrThrow;
-  }
-  static get disposeKeepAliveBlocs() {
-    return l.instance.disposeKeepAliveBlocs;
-  }
-  static get disposeBlocs() {
-    return l.instance.disposeBlocs;
-  }
-  static get getMemoryStats() {
-    return l.instance.getMemoryStats;
-  }
-  static get validateConsumers() {
-    return l.instance.validateConsumers;
-  }
-};
-/** 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 d = l;
-class U extends x {
-  constructor() {
-    super(...arguments);
-    i(this, "eventHandlers", /* @__PURE__ */ new Map());
-    /**
-     * @internal
-     * Event queue to ensure sequential processing of async events
-     */
-    i(this, "_eventQueue", []);
-    /**
-     * @internal
-     * Flag indicating if an event is currently being processed
-     */
-    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.
-     */
-    i(this, "add", async (t) => {
-      this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
-    });
+  /**
+   * Cancel disposal if bloc is in disposal_requested state
+   */
+  _cancelDisposalIfRequested() {
+    this.blacInstance?.log(
+      `[${this._name}:${this._id}] _cancelDisposalIfRequested called. Current state: ${this._lifecycleManager.currentState}`
+    ), this._lifecycleManager.cancelDisposal() ? this.blacInstance?.log(
+      `[${this._name}:${this._id}] Disposal cancelled - new subscription added`
+    ) : this._lifecycleManager.currentState === u.DISPOSAL_REQUESTED ? this.blacInstance?.warn(
+      `[${this._name}:${this._id}] Failed to cancel disposal. Current state: ${this._lifecycleManager.currentState}`
+    ) : this._lifecycleManager.isDisposed && this.blacInstance?.error(
+      `[${this._name}:${this._id}] Cannot cancel disposal - bloc is already disposed`
+    );
   }
+}
+class R extends C {
+  eventHandlers = /* @__PURE__ */ new Map();
+  /**
+   * @internal
+   * Event queue to ensure sequential processing of async events
+   */
+  _eventQueue = [];
+  /**
+   * @internal
+   * Flag indicating if an event is currently being processed
+   */
+  _isProcessingEvent = !1;
   /**
    * Registers an event handler for a specific event type.
    * This method is typically called in the constructor of a derived Bloc class.
@@ -877,14 +1473,35 @@ class U extends x {
    * @param handler A function that processes the event and can emit new states.
    *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
    */
-  on(t, s) {
-    this.eventHandlers.has(t) && d.warn(
-      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
+  on(e, t) {
+    this.eventHandlers.has(e) && o.warn(
+      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${e.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
-      t,
-      s
+      e,
+      t
     );
   }
+  /**
+   * 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.
+   */
+  add = async (e) => {
+    let t = e;
+    try {
+      t = this._plugins.transformEvent(e);
+    } catch (s) {
+      console.error("Error transforming event:", s);
+    }
+    if (t !== null) {
+      try {
+        this._plugins.notifyEvent(t);
+      } catch (s) {
+        console.error("Error notifying plugins of event:", s);
+      }
+      o.instance.plugins.notifyEventAdded(this, t), this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
+    }
+  };
   /**
    * @internal
    * Processes events from the queue sequentially
@@ -894,8 +1511,8 @@ class U extends x {
       this._isProcessingEvent = !0;
       try {
         for (; this._eventQueue.length > 0; ) {
-          const t = this._eventQueue.shift();
-          await this._processEvent(t);
+          const e = this._eventQueue.shift();
+          await this._processEvent(e);
         }
       } finally {
         this._isProcessingEvent = !1;
@@ -906,54 +1523,59 @@ class U extends x {
    * @internal
    * Processes a single event
    */
-  async _processEvent(t) {
-    const s = t.constructor, n = this.eventHandlers.get(s);
-    if (n) {
-      const r = (o) => {
+  async _processEvent(e) {
+    const t = e.constructor, s = this.eventHandlers.get(t);
+    if (s) {
+      const i = (n) => {
         const a = this.state;
-        this._pushState(o, a, t);
+        this._pushState(n, a, e);
       };
       try {
-        await n(t, r);
-      } catch (o) {
-        const a = t.constructor.name || "UnnamedConstructor", u = {
+        await s(e, i);
+      } catch (n) {
+        const a = e.constructor.name || "UnnamedConstructor", c = {
           blocName: this._name,
           blocId: String(this._id),
           eventType: a,
           currentState: this.state,
-          action: t,
+          action: e,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        if (d.error(
+        if (o.error(
           `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${a}':`,
-          o,
+          n,
           "Context:",
-          u
-        ), o instanceof Error && o.name === "CriticalError")
-          throw o;
+          c
+        ), n instanceof Error)
+          try {
+            this._plugins.notifyError(n, {
+              phase: "event-processing",
+              operation: "handler",
+              metadata: { event: e }
+            }), o.instance.plugins.notifyError(n, this, {
+              phase: "event-processing",
+              operation: "handler",
+              metadata: { event: e }
+            });
+          } catch (l) {
+            console.error("Error notifying plugins:", l);
+          }
+        if (n instanceof Error && n.name === "CriticalError")
+          throw n;
       }
     } else {
-      const r = t.constructor.name || "UnnamedConstructor";
-      d.warn(
-        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${r}'.`,
+      const i = e.constructor.name || "UnnamedConstructor";
+      o.warn(
+        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${i}'.`,
         "Registered handlers:",
-        Array.from(this.eventHandlers.keys()).map((o) => o.name),
+        Array.from(this.eventHandlers.keys()).map((n) => n.name),
         "Action was:",
-        t
+        e
       );
     }
   }
 }
-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);
-  }
+class O extends C {
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),
@@ -976,7 +1598,7 @@ class H extends x {
    */
   patch(e, t = !1) {
     if (typeof this.state != "object" || this.state === null) {
-      d.warn(
+      o.warn(
         "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
       );
       return;
@@ -985,10 +1607,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 i in e)
+        if (Object.prototype.hasOwnProperty.call(e, i)) {
+          const a = this.state[i];
+          if (!Object.is(e[i], a)) {
             s = !0;
             break;
           }
@@ -999,112 +1621,237 @@ class H extends x {
     });
   }
 }
-class N {
+class L {
   constructor(e) {
     this.props = e;
   }
 }
-function j(c, e) {
-  if (Object.is(c, e))
+function V(r, e) {
+  if (Object.is(r, e))
     return !0;
-  if (typeof c != "object" || c === null || typeof e != "object" || e === null)
+  if (typeof r != "object" || r === null || typeof e != "object" || e === null)
     return !1;
-  const t = Object.keys(c), s = Object.keys(e);
+  const t = Object.keys(r), 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 i = 0; i < t.length; i++) {
+    const n = t[i];
+    if (!Object.prototype.hasOwnProperty.call(e, n) || !Object.is(r[n], e[n]))
       return !1;
   }
   return !0;
 }
-class L {
+function N(r) {
+  if (!r || typeof r != "object")
+    return;
+  const e = [];
+  for (const [s, i] of Object.entries(r)) {
+    const n = typeof i;
+    (n === "string" || n === "number" || n === "boolean" || i === null || i === void 0) && e.push([s, i]);
+  }
+  if (e.length === 0)
+    return;
+  e.sort(([s], [i]) => s.localeCompare(i));
+  const t = [];
+  for (const [s, i] of e)
+    i === null ? t.push(`${s}:null`) : i === void 0 ? t.push(`${s}:undefined`) : t.push(`${s}:${String(i)}`);
+  return t.join("|");
+}
+class F {
+  static componentRenderCounts = /* @__PURE__ */ new Map();
+  static lastRenderTimestamps = /* @__PURE__ */ new Map();
+  static groupedLogs = /* @__PURE__ */ new Map();
+  static groupTimeouts = /* @__PURE__ */ new Map();
+  /**
+   * Log a component rerender with detailed information
+   */
+  static logRerender(e) {
+    const t = o._config?.rerenderLogging;
+    if (!t) return;
+    const s = this.parseConfig(t);
+    if (!s.enabled || s.filter && !s.filter({
+      componentName: e.componentName,
+      blocName: e.blocName
+    }))
+      return;
+    const i = `${e.componentName}-${e.blocId}`, n = this.componentRenderCounts.get(i) || 0;
+    this.componentRenderCounts.set(i, n + 1), e.renderCount = n + 1;
+    const a = this.lastRenderTimestamps.get(i);
+    a && (e.duration = e.timestamp - a), this.lastRenderTimestamps.set(i, e.timestamp), s.includeStackTrace && s.level === "detailed" && (e.stackTrace = new Error().stack), s.groupRerenders ? this.logGrouped(e, s) : this.logImmediate(e, s);
+  }
+  /**
+   * Parse the logging configuration
+   */
+  static parseConfig(e) {
+    return e === !0 ? { enabled: !0, level: "normal" } : typeof e == "string" ? {
+      enabled: !0,
+      level: e === "minimal" ? "minimal" : "detailed"
+    } : {
+      enabled: e.enabled,
+      level: e.level || "normal",
+      filter: e.filter,
+      includeStackTrace: e.includeStackTrace,
+      groupRerenders: e.groupRerenders
+    };
+  }
+  /**
+   * Log immediately without grouping
+   */
+  static logImmediate(e, t) {
+    const s = this.formatMessage(e, t.level);
+    t.level === "detailed" ? (console.group(s.header), s.details && console.log(s.details), s.values && console.table(s.values), e.stackTrace && console.log("Stack trace:", e.stackTrace), console.groupEnd()) : console.log(s.header, s.details || "");
+  }
+  /**
+   * Log with grouping (batch multiple rerenders)
+   */
+  static logGrouped(e, t) {
+    const s = `${e.componentName}-${e.blocId}`, i = this.groupTimeouts.get(s);
+    i && clearTimeout(i);
+    const n = this.groupedLogs.get(s) || [];
+    n.push(e), this.groupedLogs.set(s, n);
+    const a = setTimeout(() => {
+      const c = this.groupedLogs.get(s) || [];
+      this.groupedLogs.delete(s), this.groupTimeouts.delete(s), c.length === 1 ? this.logImmediate(c[0], t) : (console.group(
+        `🔄 ${e.componentName} rendered ${c.length} times (${e.blocName})`
+      ), c.forEach((l, h) => {
+        const p = this.formatMessage(l, t.level);
+        console.log(`  ${h + 1}. ${p.details || p.header}`);
+      }), console.groupEnd());
+    }, 50);
+    this.groupTimeouts.set(s, a);
+  }
+  /**
+   * Format the log message based on level
+   */
+  static formatMessage(e, t) {
+    const s = this.getReasonEmoji(e.reason.type);
+    if (t === "minimal")
+      return {
+        header: `${s} ${e.componentName} #${e.renderCount}`,
+        details: null,
+        values: null
+      };
+    const i = `${s} ${e.componentName} rerender #${e.renderCount} (${e.blocName})`;
+    let n = `Reason: ${e.reason.description || e.reason.type}`;
+    e.duration !== void 0 && (n += ` | Time since last: ${e.duration}ms`), t === "normal" && e.reason.changedPaths && e.reason.changedPaths.length > 0 && (n += ` | Changed: ${e.reason.changedPaths.join(", ")}`);
+    let a = null;
+    return t === "detailed" && e.reason.changedPaths && e.reason.changedPaths.length > 0 && (a = {}, e.reason.changedPaths.forEach((c) => {
+      a[c] = {
+        old: e.reason.oldValues?.[c],
+        new: e.reason.newValues?.[c]
+      };
+    }), Object.keys(a).length === 0 && (a = null)), { header: i, details: n, values: a };
+  }
+  /**
+   * Get emoji for reason type
+   */
+  static getReasonEmoji(e) {
+    switch (e) {
+      case "state-change":
+        return "📊";
+      case "dependency-change":
+        return "🔗";
+      case "mount":
+        return "🚀";
+      case "props-change":
+        return "📦";
+      default:
+        return "🔄";
+    }
+  }
+  /**
+   * Clear all tracking data
+   */
+  static clear() {
+    this.componentRenderCounts.clear(), this.lastRenderTimestamps.clear(), this.groupedLogs.clear(), this.groupTimeouts.forEach((e) => clearTimeout(e)), this.groupTimeouts.clear();
+  }
+  /**
+   * Get render count for a component
+   */
+  static getRenderCount(e, t) {
+    return this.componentRenderCounts.get(`${e}-${t}`) || 0;
+  }
+}
+class j {
+  static originalInstance;
   /**
    * Sets up a clean test environment
    */
   static setUp() {
-    this.originalInstance = d.instance, d.resetInstance(), d.enableLog = !1;
+    this.originalInstance = o.instance, o.resetInstance(), o.enableLog = !1;
   }
   /**
    * Tears down the test environment and restores original state
    */
   static tearDown() {
-    d.resetInstance();
+    o.resetInstance();
   }
   /**
    * Creates a test bloc with automatic cleanup
    */
   static createBloc(e, ...t) {
     const s = new e(...t);
-    return d.activateBloc(s), s;
+    return o.activateBloc(s), s;
   }
   /**
    * Waits for a bloc to emit a specific state
    */
   static async waitForState(e, t, s = 5e3) {
-    return new Promise((n, r) => {
-      const o = setTimeout(() => {
-        r(
+    return new Promise((i, n) => {
+      const a = setTimeout(() => {
+        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));
-        }
+      }, s), c = e.subscribe((l) => {
+        t(l) && (clearTimeout(a), c(), i(l));
       });
-      t(e.state) && (clearTimeout(o), a(), n(e.state));
+      t(e.state) && (clearTimeout(a), c(), i(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 a = setTimeout(() => {
-        o(
+    const i = [];
+    return new Promise((n, a) => {
+      const c = setTimeout(() => {
+        a(
           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(i)}`
           )
         );
-      }, s), u = 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)) {
-                o(
-                  new Error(
-                    `State mismatch at index ${h}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(I)}`
-                  )
-                );
-                return;
-              }
+      }, s), l = e.subscribe((h) => {
+        if (i.push(h), i.length === t.length) {
+          clearTimeout(c), l();
+          for (let p = 0; p < t.length; p++) {
+            const S = t[p], k = i[p];
+            if (JSON.stringify(S) !== JSON.stringify(k)) {
+              a(
+                new Error(
+                  `State mismatch at index ${p}. Expected: ${JSON.stringify(S)}, Received: ${JSON.stringify(k)}`
+                )
+              );
+              return;
             }
-            r();
           }
+          n();
         }
       });
     });
   }
 }
-i(L, "originalInstance");
-class Q extends U {
-  constructor(t) {
-    super(t);
-    i(this, "mockHandlers", /* @__PURE__ */ new Map());
+class z extends R {
+  mockHandlers = /* @__PURE__ */ new Map();
+  constructor(e) {
+    super(e);
   }
   /**
    * Mock an event handler for testing
    */
-  mockEventHandler(t, s) {
-    this.on(t, s);
+  mockEventHandler(e, t) {
+    this.on(e, t);
   }
   /**
    * Get the number of registered handlers
@@ -1115,21 +1862,20 @@ class Q extends U {
   /**
    * Check if a handler is registered for an event type
    */
-  hasHandler(t) {
-    return this.eventHandlers.has(t);
+  hasHandler(e) {
+    return this.eventHandlers.has(e);
   }
 }
-class W extends H {
-  constructor(t) {
-    super(t);
-    i(this, "stateHistory", []);
-    this.stateHistory.push(t);
+class q extends O {
+  stateHistory = [];
+  constructor(e) {
+    super(e), this.stateHistory.push(e);
   }
   /**
    * Override emit to track state history
    */
-  emit(t) {
-    this.stateHistory.push(t), super.emit(t);
+  emit(e) {
+    this.stateHistory.push(e), super.emit(e);
   }
   /**
    * Get the history of all states
@@ -1144,16 +1890,16 @@ class W extends H {
     this.stateHistory = [this.state];
   }
 }
-class F {
+class W {
+  initialStats;
   constructor() {
-    i(this, "initialStats");
-    this.initialStats = d.getMemoryStats();
+    this.initialStats = o.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 = o.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,419 +1916,360 @@ Memory Leak Detection Report:
     };
   }
 }
-class z {
-  constructor() {
-    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, {
-      id: t,
-      lastNotified: Date.now(),
-      hasRendered: !1,
-      stateAccesses: /* @__PURE__ */ new Set(),
-      classAccesses: /* @__PURE__ */ new Set(),
-      stateValues: /* @__PURE__ */ new Map(),
-      classValues: /* @__PURE__ */ new Map(),
-      accessCount: 0,
-      lastAccessTime: 0,
-      firstAccessTime: 0
-    });
-  }
-  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;
-    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);
-    t && (t.stateAccesses.clear(), t.classAccesses.clear(), t.stateValues.clear(), t.classValues.clear(), t.accessCount = 0, t.firstAccessTime = 0);
-  }
-  getDependencies(e) {
-    const t = this.consumers.get(e);
-    return t ? {
-      statePaths: Array.from(t.stateAccesses),
-      classPaths: Array.from(t.classAccesses)
-    } : null;
-  }
-  hasValuesChanged(e, t, s) {
-    const n = this.consumers.get(e);
-    if (!n) return !0;
-    let r = !1;
-    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 [a, u] of n.stateValues)
-      try {
-        const p = this.getValueAtPath(t, a);
-        p !== u.value && (n.stateValues.set(a, {
-          value: p,
-          lastAccessTime: o
-        }), r = !0);
-      } catch {
-        r = !0;
-      }
-    for (const [a, u] of n.classValues)
-      try {
-        const p = this.getValueAtPath(s, a);
-        p !== u.value && (n.classValues.set(a, {
-          value: p,
-          lastAccessTime: o
-        }), r = !0);
-      } catch {
-        r = !0;
-      }
-    return r;
-  }
-  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 + "."))
-          return !0;
-    }
-    return !1;
-  }
-  updateLastNotified(e) {
-    const t = this.consumers.get(e);
-    t && (t.lastNotified = Date.now());
-  }
-  getConsumerInfo(e) {
-    return this.consumers.get(e);
-  }
-  setHasRendered(e, t) {
-    const s = this.consumers.get(e);
-    s && (s.hasRendered = t);
-  }
-  hasConsumer(e) {
-    return this.consumers.has(e);
-  }
-  getStats() {
-    return {
-      totalRegistrations: this.registrationCount,
-      activeConsumers: this.activeConsumers
-    };
-  }
-  getValueAtPath(e, t) {
-    const s = t.split(".");
-    let n = e;
-    for (const r of s) {
-      if (n == null) return;
-      n = n[r];
-    }
-    return n;
-  }
-}
-const k = /* @__PURE__ */ new WeakMap();
-let f = {
+const I = /* @__PURE__ */ new WeakMap(), d = {
   stateProxiesCreated: 0,
   classProxiesCreated: 0,
   cacheHits: 0,
   cacheMisses: 0,
-  propertyAccesses: 0,
-  nestedProxiesCreated: 0,
-  totalProxiesCreated: 0,
-  createdAt: Date.now()
-};
-class b {
-  static createStateProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: n, path: r = "" } = e;
-    if (!s || !n || typeof t != "object" || t === null)
-      return t;
-    let o = k.get(t);
-    o || (o = /* @__PURE__ */ new WeakMap(), k.set(t, o));
-    const a = o.get(s);
+  totalProxiesCreated: 0
+}, _ = (r, e, t, s = "") => {
+  if (!e || !t || typeof r != "object" || r === null)
+    return r;
+  if (!s) {
+    let n = I.get(r);
+    n || (n = /* @__PURE__ */ new WeakMap(), I.set(r, n));
+    const a = n.get(e);
     if (a)
-      return f.cacheHits++, a;
-    f.cacheMisses++;
-    const u = {
-      get(h, 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({
-              target: g,
-              consumerRef: s,
-              consumerTracker: n,
-              path: I
-            });
-        }
-        return g;
-      },
-      has(h, m) {
-        return m in h;
-      },
-      ownKeys(h) {
-        return Reflect.ownKeys(h);
-      },
-      getOwnPropertyDescriptor(h, m) {
-        return Reflect.getOwnPropertyDescriptor(h, m);
-      },
-      set() {
-        return !1;
-      },
-      deleteProperty() {
-        return !1;
-      }
-    }, p = new Proxy(t, u);
-    return o.set(s, p), f.stateProxiesCreated++, f.totalProxiesCreated++, p;
-  }
-  static createClassProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: n } = e;
-    if (!s || !n)
-      return t;
-    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 T = Object.getOwnPropertyDescriptor(
-              g,
-              h
-            );
-            if (T && T.get) {
-              I = !0;
-              break;
-            }
-            g = Object.getPrototypeOf(g), w++;
-          } catch {
-            break;
-          }
-        }
-        if (!I)
-          return m;
-        f.propertyAccesses++;
-        const B = m, M = B !== null && typeof B != "object" ? B : void 0;
-        return n.trackAccess(
-          s,
+      return d.cacheHits++, a;
+    d.cacheMisses++;
+  }
+  const i = new Proxy(r, {
+    get(n, a) {
+      if (typeof a == "symbol" || a === "constructor")
+        return Reflect.get(n, a);
+      const c = s ? `${s}.${a}` : a, l = Reflect.get(n, a), h = l && typeof l == "object";
+      return t.trackAccess(
+        e,
+        "state",
+        c,
+        h ? void 0 : l
+      ), h && (Array.isArray(l) || Object.getPrototypeOf(l) === Object.prototype) ? _(l, e, t, c) : l;
+    },
+    set: () => !1,
+    // State should be immutable
+    deleteProperty: () => !1
+    // State properties should not be deleted
+  });
+  return s || (I.get(r).set(e, i), d.stateProxiesCreated++, d.totalProxiesCreated++), i;
+}, M = (r, e, t) => {
+  if (!e || !t)
+    return r;
+  let s = I.get(r);
+  s || (s = /* @__PURE__ */ new WeakMap(), I.set(r, s));
+  const i = s.get(e);
+  if (i)
+    return d.cacheHits++, i;
+  d.cacheMisses++;
+  const n = new Proxy(r, {
+    get(a, c) {
+      const l = Reflect.get(a, c);
+      if (U(a, c)?.get) {
+        const p = l !== null && typeof l != "object";
+        t.trackAccess(
+          e,
           "class",
-          String(h),
-          M
-        ), m;
-      },
-      has(p, h) {
-        return h in p;
-      },
-      ownKeys(p) {
-        return Reflect.ownKeys(p);
-      },
-      getOwnPropertyDescriptor(p, h) {
-        return Reflect.getOwnPropertyDescriptor(p, h);
+          String(c),
+          p ? l : void 0
+        );
       }
-    }, u = new Proxy(t, a);
-    return r.set(s, u), f.classProxiesCreated++, f.totalProxiesCreated++, u;
-  }
-  static getProxyState(e) {
-    return b.createStateProxy({
-      target: e.state,
-      consumerRef: e.consumerRef,
-      consumerTracker: e.consumerTracker
-    });
-  }
-  static getProxyBlocInstance(e) {
-    return b.createClassProxy({
-      target: e.blocInstance,
-      consumerRef: e.consumerRef,
-      consumerTracker: e.consumerTracker
-    });
-  }
-  static getStats() {
-    const e = Date.now() - f.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",
-      lifetime: `${e}ms`,
-      proxiesPerSecond: e > 0 ? (f.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
-    };
-  }
-  static resetStats() {
-    f = {
-      stateProxiesCreated: 0,
-      classProxiesCreated: 0,
-      cacheHits: 0,
-      cacheMisses: 0,
-      propertyAccesses: 0,
-      nestedProxiesCreated: 0,
-      totalProxiesCreated: 0,
-      createdAt: Date.now()
-    };
+      return l;
+    }
+  });
+  return s.set(e, n), d.classProxiesCreated++, d.totalProxiesCreated++, n;
+}, U = (r, e, t = 10) => {
+  let s = r, i = 0;
+  for (; s && i < t; ) {
+    const n = Object.getOwnPropertyDescriptor(s, e);
+    if (n) return n;
+    s = Object.getPrototypeOf(s), i++;
+  }
+}, $ = {
+  createStateProxy: (r) => _(
+    r.target,
+    r.consumerRef,
+    r.consumerTracker,
+    r.path
+  ),
+  createClassProxy: (r) => M(
+    r.target,
+    r.consumerRef,
+    r.consumerTracker
+  ),
+  getProxyState: (r) => _(
+    r.state,
+    r.consumerRef,
+    r.consumerTracker
+  ),
+  getProxyBlocInstance: (r) => M(
+    r.blocInstance,
+    r.consumerRef,
+    r.consumerTracker
+  ),
+  // Compatibility functions that return expected structure
+  getStats: () => ({
+    ...d,
+    propertyAccesses: 0,
+    nestedProxiesCreated: 0,
+    cacheEfficiency: d.cacheHits + d.cacheMisses > 0 ? `${(d.cacheHits / (d.cacheHits + d.cacheMisses) * 100).toFixed(1)}%` : "N/A",
+    lifetime: "0ms",
+    proxiesPerSecond: "N/A"
+  }),
+  resetStats: () => {
+    d.stateProxiesCreated = 0, d.classProxiesCreated = 0, d.cacheHits = 0, d.cacheMisses = 0, d.totalProxiesCreated = 0;
   }
-}
-const v = class v {
+};
+class G {
+  id = `adapter-${A()}`;
+  blocConstructor;
+  componentRef = { current: {} };
+  blocInstance;
+  unmountTime = 0;
+  mountTime = 0;
+  // Subscription management
+  subscriptionId;
+  unsubscribe;
+  // Dependency tracking
+  dependencyValues;
+  isUsingDependencies = !1;
+  trackedPaths = /* @__PURE__ */ new Set();
+  pendingTrackedPaths = /* @__PURE__ */ new Set();
+  // Paths tracked before subscription exists
+  // Proxy caching
+  cachedStateProxy;
+  cachedBlocProxy;
+  lastProxiedState;
+  // Lifecycle state
+  hasMounted = !1;
+  mountCount = 0;
+  // Rerender tracking
+  lastState;
+  lastDependencyValues;
+  componentName;
+  renderCount = 0;
+  lastDependenciesFn;
+  options;
   constructor(e, t) {
-    i(this, "id", `consumer-${$()}`);
-    i(this, "blocConstructor");
-    i(this, "componentRef", { current: {} });
-    i(this, "blocInstance");
-    // Core components
-    i(this, "consumerTracker");
-    i(this, "lastProps");
-    i(this, "unmountTime", 0);
-    i(this, "mountTime", 0);
-    // Dependency tracking
-    i(this, "dependencyValues");
-    i(this, "isUsingDependencies", !1);
-    // Lifecycle state
-    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
-    }));
-    i(this, "createClassProxy", (e) => b.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)) {
-          const o = this.options.dependencies(this.blocInstance);
-          if (!this.hasDependencyValuesChanged(
-            this.dependencyValues,
-            o
-          ))
-            return;
-          this.dependencyValues = o;
-        } else if (d.config.proxyDependencyTracking) {
-          const o = this.consumerTracker.getConsumerInfo(
-            this.componentRef.current
-          );
-          if (o && o.hasRendered && !this.consumerTracker.hasValuesChanged(
-            this.componentRef.current,
-            s,
-            this.blocInstance
-          ))
-            return;
-        } else {
-          e.onChange();
-          return;
-        }
-        e.onChange();
-      }
-    }));
-    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 {
-          this.options.onMount(this.blocInstance);
-        } catch (s) {
-          throw s;
-        }
-    });
-    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)
-        try {
-          this.options.onUnmount(this.blocInstance);
-        } catch {
-        }
-    });
-    i(this, "getProxyState", (e) => this.isUsingDependencies || !d.config.proxyDependencyTracking ? e : b.getProxyState({
-      state: e,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this
-    }));
-    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 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, n) {
-    this.consumerTracker.trackAccess(e, t, s, n);
+    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!t?.dependencies, this.updateBlocInstance(), this.isUsingDependencies && t?.dependencies && (this.dependencyValues = t.dependencies(this.blocInstance));
+    const s = this.getAdapterMetadata();
+    o.getInstance().plugins.notifyAdapterCreated(this, s);
   }
-  getConsumerDependencies(e) {
-    return this.consumerTracker.getDependencies(e);
-  }
-  shouldNotifyConsumer(e, t) {
-    const s = this.consumerTracker.getConsumerInfo(e);
-    return !s || !s.hasRendered ? !0 : this.consumerTracker.shouldNotifyConsumer(e, t);
-  }
-  updateLastNotified(e) {
-    this.consumerTracker.updateLastNotified(e), this.consumerTracker.setHasRendered(e, !0);
-  }
-  resetConsumerTracking() {
-    this.consumerTracker.resetTracking(this.componentRef.current);
+  trackAccess(e, t, s, i) {
+    const n = t === "class" ? `_class.${s}` : s;
+    this.trackedPaths.add(n), this.subscriptionId ? this.blocInstance.trackAccess(this.subscriptionId, n, i) : (this.pendingTrackedPaths.add(n), o.config.logLevel === "debug" && o.log(`[BlacAdapter] trackAccess storing pending path: ${s}`));
   }
   updateBlocInstance() {
-    var e, t;
-    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,
+    let e = this.options?.instanceId;
+    if (!e && this.options?.staticProps) {
+      const t = N(this.options.staticProps);
+      t && (e = t);
+    }
+    return this.blocInstance = o.instance.getBloc(this.blocConstructor, {
+      constructorParams: this.options?.staticProps,
+      id: e,
       instanceRef: this.id
     }), this.blocInstance;
   }
-  // Expose calledOnMount for backward compatibility
-  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`
+  createSubscription = (e) => {
+    if (this.isUsingDependencies && this.options?.dependencies)
+      this.unsubscribe = this.blocInstance.subscribeWithSelector(
+        (t) => this.options.dependencies(this.blocInstance),
+        (t) => {
+          this.hasDependencyValuesChanged(
+            this.dependencyValues,
+            t
+          ) && (this.dependencyValues = t, e.onChange());
+        }
       );
-      return;
+    else {
+      const t = new WeakRef(this.componentRef.current);
+      this.unsubscribe = this.blocInstance.subscribeComponent(
+        t,
+        e.onChange
+      );
+      const s = this.blocInstance._subscriptionManager.subscriptions;
+      if (this.subscriptionId = Array.from(s.keys()).pop(), this.subscriptionId && this.pendingTrackedPaths.size > 0) {
+        for (const i of this.pendingTrackedPaths)
+          this.blocInstance.trackAccess(this.subscriptionId, i);
+        this.pendingTrackedPaths.clear();
+      }
     }
-    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) {
+    return () => {
+      this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0, this.subscriptionId = void 0);
+    };
+  };
+  hasDependencyValuesChanged = (e, t) => {
     if (!e || e.length !== t.length) return !0;
     for (let s = 0; s < e.length; s++)
       if (!Object.is(e[s], t[s]))
         return !0;
     return !1;
+  };
+  getStateProxy = () => {
+    if (this.isUsingDependencies || !o.config.proxyDependencyTracking)
+      return this.blocInstance.state;
+    const e = this.blocInstance.state;
+    return this.cachedStateProxy && this.lastProxiedState === e ? this.cachedStateProxy : (this.lastProxiedState = e, this.cachedStateProxy = this.createStateProxy({ target: e }), this.cachedStateProxy);
+  };
+  getBlocProxy = () => this.isUsingDependencies || !o.config.proxyDependencyTracking ? this.blocInstance : this.cachedBlocProxy ? this.cachedBlocProxy : (this.cachedBlocProxy = this.createClassProxy({ target: this.blocInstance }), this.cachedBlocProxy);
+  createStateProxy = (e) => $.createStateProxy({
+    target: e.target,
+    consumerRef: this.componentRef.current,
+    consumerTracker: this
+  });
+  createClassProxy = (e) => $.createClassProxy({
+    target: e.target,
+    consumerRef: this.componentRef.current,
+    consumerTracker: this
+  });
+  // Lifecycle methods
+  mount = () => {
+    this.hasMounted = !0, this.mountCount++, this.mountTime = Date.now(), this.options?.onMount && this.options.onMount(this.blocInstance), this.isUsingDependencies && this.options?.dependencies && (this.dependencyValues = this.options.dependencies(this.blocInstance));
+    const e = this.getAdapterMetadata();
+    o.getInstance().plugins.notifyAdapterMount(this, e);
+  };
+  unmount = () => {
+    if (this.unmountTime = Date.now(), this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0, this.subscriptionId = void 0), this.options?.onUnmount)
+      try {
+        this.options.onUnmount(this.blocInstance);
+      } catch (t) {
+        console.error("Error in onUnmount hook:", t);
+      }
+    const e = this.getAdapterMetadata();
+    o.getInstance().plugins.notifyAdapterUnmount(this, e);
+  };
+  // Reset tracking for next render
+  resetTracking() {
+    if (this.trackedPaths.clear(), this.pendingTrackedPaths.clear(), this.subscriptionId) {
+      const e = this.blocInstance._subscriptionManager.subscriptions.get(this.subscriptionId);
+      e && e.dependencies && e.dependencies.clear();
+    }
   }
-};
-// Props ownership tracking
-i(v, "propsOwners", /* @__PURE__ */ new WeakMap());
-let R = v;
+  // Set component name for rerender logging
+  setComponentName(e) {
+    this.componentName = e;
+  }
+  // Notify plugins about render
+  notifyRender() {
+    this.renderCount++, this.isUsingDependencies && this.options?.dependencies && (this.lastDependencyValues = this.dependencyValues, this.dependencyValues = this.options.dependencies(this.blocInstance));
+    const e = this.getAdapterMetadata();
+    o.getInstance().plugins.notifyAdapterRender(this, e);
+  }
+  // Get adapter metadata for plugins
+  getAdapterMetadata() {
+    return {
+      componentName: this.componentName,
+      blocInstance: this.blocInstance,
+      renderCount: this.renderCount,
+      trackedPaths: Array.from(this.trackedPaths),
+      isUsingDependencies: this.isUsingDependencies,
+      lastState: this.lastState,
+      lastDependencyValues: this.lastDependencyValues,
+      currentDependencyValues: this.dependencyValues
+    };
+  }
+  // Get value at a dot-notated path
+  getValueAtPath(e, t) {
+    const s = t.split(".");
+    let i = e;
+    for (const n of s) {
+      if (i == null) return;
+      i = i[n];
+    }
+    return i;
+  }
+  // Get paths that changed between states
+  getStateChangedPaths(e, t) {
+    const s = [];
+    if (this.trackedPaths.size > 0)
+      for (const i of this.trackedPaths) {
+        if (i.startsWith("_class.")) continue;
+        const n = this.getValueAtPath(e, i), a = this.getValueAtPath(t, i);
+        Object.is(n, a) || s.push(i);
+      }
+    else if (e !== t) {
+      const i = this.getDeepChangedPaths(e, t);
+      if (i.length > 0)
+        return i;
+      s.push("(entire state)");
+    }
+    return s;
+  }
+  // Deep comparison to find all changed paths
+  getDeepChangedPaths(e, t, s = "") {
+    const i = [];
+    if (e === t) return i;
+    if (e == null || t == null)
+      return i.push(s || "(root)"), i;
+    if (typeof e != "object" || typeof t != "object")
+      return e !== t && i.push(s || "(root)"), i;
+    if (Array.isArray(e) || Array.isArray(t)) {
+      if (!Array.isArray(e) || !Array.isArray(t) || e.length !== t.length)
+        return i.push(s || "(root)"), i;
+      for (let a = 0; a < e.length; a++) {
+        const c = s ? `${s}[${a}]` : `[${a}]`;
+        i.push(
+          ...this.getDeepChangedPaths(e[a], t[a], c)
+        );
+      }
+      return i;
+    }
+    const n = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(t)]);
+    for (const a of n) {
+      const c = s ? `${s}.${a}` : a;
+      if (!(a in e))
+        i.push(`${c} (added)`);
+      else if (!(a in t))
+        i.push(`${c} (removed)`);
+      else {
+        const l = e[a], h = t[a];
+        if (!Object.is(l, h))
+          if (typeof l != "object" || typeof h != "object" || l === null || h === null)
+            i.push(c);
+          else {
+            const p = this.getDeepChangedPaths(
+              l,
+              h,
+              c
+            );
+            p.length > 0 ? i.push(...p) : i.push(c);
+          }
+      }
+    }
+    return i;
+  }
+  // Get last rerender reason
+  getLastRerenderReason() {
+  }
+}
 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,
-  $ as generateUUID,
-  q as setBlacInstanceManager,
-  j as shallowEqual
+  o as Blac,
+  G as BlacAdapter,
+  m as BlacError,
+  R as Bloc,
+  C as BlocBase,
+  B as BlocLifecycleManager,
+  u as BlocLifecycleState,
+  w as BlocPluginRegistry,
+  j as BlocTest,
+  O as Cubit,
+  P as DefaultErrorStrategy,
+  v as ErrorCategory,
+  f as ErrorManager,
+  y as ErrorSeverity,
+  W as MemoryLeakDetector,
+  z as MockBloc,
+  q as MockCubit,
+  L as PropsUpdated,
+  $ as ProxyFactory,
+  F as RerenderLogger,
+  E as SubscriptionManager,
+  T as SystemPluginRegistry,
+  M as createBlocProxy,
+  _ as createStateProxy,
+  N as generateInstanceIdFromProps,
+  A as generateUUID,
+  x as handleError,
+  H as setBlacInstanceManager,
+  V as shallowEqual
 };
 //# sourceMappingURL=index.es.js.map