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

package/dist/index.es.js

@@ -1,360 +1,15 @@
-var m = Object.defineProperty;
-var y = (d, e, t) => e in d ? m(d, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : d[e] = t;
-var i = (d, e, t) => y(d, typeof e != "symbol" ? e + "" : e, t);
-const u = class u {
-  getInstance() {
-    return u._instance || (u._instance = new l({ __unsafe_ignore_singleton: !0 })), u._instance;
-  }
-  setInstance(e) {
-    u._instance = e;
-  }
-  resetInstance() {
-    const e = u._instance;
-    if (u._instance = new l({ __unsafe_ignore_singleton: !0 }), e)
-      for (const t of e.keepAliveBlocs)
-        u._instance.keepAliveBlocs.add(t), u._instance.uidRegistry.set(t.uid, t);
-  }
-};
-i(u, "_instance");
-let v = u, g = new v();
-function M(d) {
-  g = d;
-}
-const c = class c {
-  /**
-   * 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 */
-    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) => {
-      c.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...e);
-    });
-    /**
-     * Logs a warning message
-     * @param message - Warning message
-     * @param args - Additional arguments
-     */
-    i(this, "warn", (e, ...t) => {
-      c.enableLog && console.warn(`🚨 [Blac ${String(c.instance.createdAt)}]`, e, ...t);
-    });
-    /**
-     * Logs an error message
-     * @param message - Error message
-     * @param args - Additional arguments
-     */
-    i(this, "error", (e, ...t) => {
-      c.enableLog && console.error(`🚨 [Blac ${String(c.instance.createdAt)}]`, e, ...t);
-    });
-    /**
-     * 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(), g.resetInstance();
-    });
-    /**
-     * Disposes of a bloc instance by removing it from the appropriate registry
-     * @param bloc - The bloc instance to dispose
-     */
-    i(this, "disposeBloc", (e) => {
-      if (e._disposalState !== "active") {
-        this.log(`[${e._name}:${String(e._id)}] disposeBloc called on already disposed bloc`);
-        return;
-      }
-      const t = e.constructor, s = this.createBlocInstanceMapKey(e._name, e._id);
-      this.log(`[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(t.isolated)}`), e._dispose(), t.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
-    });
-    i(this, "activateBloc", (e) => {
-      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 } = t, n = e, o = s ?? e.name;
-      if (n.isolated) {
-        const r = this.findIsolatedBlocInstance(e, o);
-        if (r)
-          return this.log(`[${e.name}:${String(o)}] (getBloc) Found existing isolated instance.`, t), r;
-        if (t.throwIfNotFound)
-          throw new Error(`Isolated bloc ${e.name} not found`);
-      } else {
-        const r = this.findRegisteredBlocInstance(e, o);
-        if (r)
-          return this.log(`[${e.name}:${String(o)}] (getBloc) Found existing registered instance.`, t), r;
-        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, o = s ? this.findIsolatedBlocInstance(e, n) : this.findRegisteredBlocInstance(e, n);
-      if (o)
-        return o;
-      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((o) => o));
-      }
-      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 c.instance;
-    g.setInstance(this);
-  }
-  /** @deprecated Use getInstance() instead */
-  static get instance() {
-    return g.getInstance();
-  }
-  static get getAllBlocs() {
-    return c.instance.getAllBlocs;
-  }
-  static get log() {
-    return c.instance.log;
-  }
-  /**
-   * Gets the current Blac instance
-   * @returns The Blac instance
-   */
-  static getInstance() {
-    return g.getInstance();
-  }
-  static get warn() {
-    return c.instance.warn;
-  }
-  static get error() {
-    return c.instance.error;
-  }
-  static get disposeBloc() {
-    return c.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 n = this.createBlocInstanceMapKey(e.name, t);
-    return this.blocInstanceMap.get(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 n = !1;
-    if (s) {
-      const a = s.findIndex((r) => r.uid === e.uid);
-      a !== -1 && (s.splice(a, 1), n = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
-    }
-    const o = this.isolatedBlocIndex.delete(e.uid);
-    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), n !== o && this.warn(
-      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${n}, Index removal: ${o}`
-    );
-  }
-  /**
-   * Finds an isolated bloc instance by its class and ID (O(n) lookup)
-   */
-  findIsolatedBlocInstance(e, t) {
-    if (!e.isolated) return;
-    const n = this.isolatedBlocMap.get(e);
-    return n ? n.find((a) => a._id === t) : 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 { props: n, instanceRef: o } = s, a = new e(n);
-    return a._instanceRef = o, a.props = n || null, a._updateId(t), a._setDisposalHandler((r) => this.disposeBloc(r)), a.isIsolated ? (this.registerIsolatedBlocInstance(a), a) : (this.registerBlocInstance(a), a);
-  }
-  static get activateBloc() {
-    return c.instance.activateBloc;
-  }
-  static get getBloc() {
-    return c.instance.getBloc;
-  }
-  static get getBlocOrThrow() {
-    return c.instance.getBlocOrThrow;
-  }
-  static get disposeKeepAliveBlocs() {
-    return c.instance.disposeKeepAliveBlocs;
-  }
-  static get disposeBlocs() {
-    return c.instance.disposeBlocs;
-  }
-  static get getMemoryStats() {
-    return c.instance.getMemoryStats;
-  }
-  static get validateConsumers() {
-    return c.instance.validateConsumers;
-  }
-};
-/** Flag to enable/disable logging */
-i(c, "enableLog", !1), i(c, "resetInstance", () => {
-  g.resetInstance();
-});
-let l = c;
-class w {
+var M = Object.defineProperty;
+var P = (u, e, t) => e in u ? M(u, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : u[e] = t;
+var n = (u, e, t) => P(u, typeof e != "symbol" ? e + "" : e, t);
+class E {
   /**
    * Creates a new BlacObservable instance
    * @param bloc - The Bloc instance to observe
    */
   constructor(e) {
     /** The Bloc instance this observable is associated with */
-    i(this, "bloc");
-    i(this, "_observers", /* @__PURE__ */ new Set());
+    n(this, "bloc");
+    n(this, "_observers", /* @__PURE__ */ new Set());
     this.bloc = e;
   }
   /**
@@ -377,16 +32,38 @@ class w {
    * @returns A function that can be called to unsubscribe the observer
    */
   subscribe(e) {
-    return l.log("BlacObservable.subscribe: Subscribing observer.", this.bloc, e), this._observers.add(e), () => {
-      l.log("BlacObservable.subscribe: Unsubscribing observer.", this.bloc, e), this.unsubscribe(e);
-    };
+    const t = this.bloc._disposalState;
+    return t === _.DISPOSED || t === _.DISPOSING ? (f.log(
+      "BlacObservable.subscribe: Cannot subscribe to disposed/disposing bloc.",
+      this.bloc,
+      e
+    ), () => {
+    }) : (f.log(
+      "BlacObservable.subscribe: Subscribing observer.",
+      this.bloc,
+      e
+    ), this._observers.add(e), t === _.DISPOSAL_REQUESTED && (f.log(
+      "BlacObservable.subscribe: Cancelling disposal due to new subscription.",
+      this.bloc
+    ), this.bloc._atomicStateTransition(
+      _.DISPOSAL_REQUESTED,
+      _.ACTIVE
+    )), () => {
+      f.log(
+        "BlacObservable.subscribe: Unsubscribing observer.",
+        this.bloc,
+        e
+      ), this.unsubscribe(e);
+    });
   }
   /**
    * Unsubscribes an observer from state changes
    * @param observer - The observer to unsubscribe
    */
   unsubscribe(e) {
-    this._observers.delete(e), this.size === 0 && l.log("BlacObservable.unsubscribe: No observers left.", this.bloc);
+    this._observers.delete(e), this.size === 0 && (f.log("BlacObservable.unsubscribe: No observers left.", this.bloc), this.bloc._consumers.size === 0 && !this.bloc._keepAlive && this.bloc._disposalState === _.ACTIVE && (f.log(
+      `[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`
+    ), this.bloc._scheduleDisposal()));
   }
   /**
    * Notifies all observers of a state change
@@ -395,32 +72,28 @@ class w {
    * @param action - Optional action that triggered the state change
    */
   notify(e, t, s) {
-    this._observers.forEach((n) => {
-      let o = !1;
-      if (n.dependencyArray) {
-        const a = n.lastState, r = n.dependencyArray(e);
+    this._observers.forEach((i) => {
+      let r = !1;
+      if (i.dependencyArray) {
+        const a = i.lastState, o = i.dependencyArray(
+          e,
+          t,
+          this.bloc
+        );
         if (!a)
-          o = !0;
-        else if (a.length !== r.length)
-          o = !0;
+          r = !0;
+        else if (a.length !== o.length)
+          r = !0;
         else
-          for (let h = 0; h < r.length; h++) {
-            const _ = r[h], p = a[h] || [];
-            if (_.length !== p.length) {
-              o = !0;
+          for (let l = 0; l < o.length; l++)
+            if (!Object.is(a[l], o[l])) {
+              r = !0;
               break;
             }
-            for (let f = 0; f < _.length; f++)
-              if (!Object.is(_[f], p[f])) {
-                o = !0;
-                break;
-              }
-            if (o) break;
-          }
-        n.lastState = r;
+        i.lastState = o;
       } else
-        o = !0;
-      o && n.fn(e, t, s);
+        r = !0;
+      r && i.fn(e, t, s);
     });
   }
   /**
@@ -430,97 +103,103 @@ class w {
     this._observers.clear();
   }
 }
-function S() {
-  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(d) {
+function R() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(u) {
     const e = Math.random() * 16 | 0;
-    return (d === "x" ? e : e & 3 | 8).toString(16);
+    return (u === "x" ? e : e & 3 | 8).toString(16);
   });
 }
-class B {
+var _ = /* @__PURE__ */ ((u) => (u.ACTIVE = "active", u.DISPOSAL_REQUESTED = "disposal_requested", u.DISPOSING = "disposing", u.DISPOSED = "disposed", u))(_ || {});
+class k {
   /**
    * 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
    */
   constructor(e) {
-    i(this, "uid", S());
+    n(this, "uid", R());
     /**
      * 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");
+    n(this, "defaultDependencySelector");
     /**
      * @internal
      * Indicates if this specific Bloc instance is isolated from others of the same type.
      */
-    i(this, "_isolated", !1);
+    n(this, "_isolated", !1);
     /**
      * @internal
      * Observable responsible for managing state listeners and notifying consumers.
      */
-    i(this, "_observer");
+    n(this, "_observer");
     /**
      * The unique identifier for this Bloc instance.
      * Defaults to the class name, but can be customized.
      */
-    i(this, "_id");
+    n(this, "_id");
     /**
      * @internal
      * Reference string used internally for tracking and debugging.
      */
-    i(this, "_instanceRef");
+    n(this, "_instanceRef");
     /**
      * @internal
      * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
      */
-    i(this, "_keepAlive", !1);
+    n(this, "_keepAlive", !1);
     /**
      * @readonly
      * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
      */
-    i(this, "_createdAt", Date.now());
+    n(this, "_createdAt", Date.now());
     /**
      * @internal
-     * Disposal state to prevent race conditions
+     * Atomic disposal state to prevent race conditions
      */
-    i(this, "_disposalState", "active");
+    n(this, "_disposalState", "active");
+    /**
+     * @internal
+     * Timestamp when disposal was requested (for React Strict Mode grace period)
+     */
+    n(this, "_disposalRequestTime", 0);
     /**
      * @internal
      * The current state of the Bloc.
      */
-    i(this, "_state");
+    n(this, "_state");
     /**
      * @internal
      * The previous state of the Bloc, maintained for comparison and history.
      */
-    i(this, "_oldState");
+    n(this, "_oldState");
     /**
      * Props passed during Bloc instance creation.
      * Can be used to configure or parameterize the Bloc's behavior.
      */
-    i(this, "props", null);
+    n(this, "props", null);
     /**
      * @internal
      * Flag to prevent batching race conditions
      */
-    i(this, "_batchingLock", !1);
+    n(this, "_batchingLock", !1);
     /**
      * @internal
      * Pending batched updates
      */
-    i(this, "_pendingUpdates", []);
+    n(this, "_pendingUpdates", []);
     /**
      * @internal
      * Map of consumer IDs to their WeakRef objects for proper cleanup
      */
-    i(this, "_consumerRefs", /* @__PURE__ */ new Map());
+    n(this, "_consumerRefs", /* @__PURE__ */ new Map());
     /**
      * @internal
      * Validates that all consumer references are still alive
      * Removes dead consumers automatically
      */
-    i(this, "_validateConsumers", () => {
+    n(this, "_validateConsumers", () => {
       const e = [];
       for (const [t, s] of this._consumerRefs)
         s.deref() === void 0 && e.push(t);
@@ -532,10 +211,10 @@ class B {
      * @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) => {
+    n(this, "_updateId", (e) => {
       const t = this._id;
       !e || e === t || (this._id = e);
     });
@@ -543,168 +222,631 @@ class B {
      * @internal
      * Optional function to be called when the Bloc is disposed.
      */
-    i(this, "onDispose");
+    n(this, "onDispose");
     /**
      * @internal
      * Set of consumer IDs currently listening to this Bloc's state changes.
      */
-    i(this, "_consumers", /* @__PURE__ */ new Set());
+    n(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) => {
-      this._disposalState === "active" && (this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.set(e, new WeakRef(t))));
+    n(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) => {
-      this._consumers.has(e) && (this._consumers.delete(e), this._consumerRefs.delete(e), this._consumers.size === 0 && !this._keepAlive && this._disposalState === "active" && this._scheduleDisposal());
+    n(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());
+    n(this, "_disposalHandler");
+    n(this, "lastUpdate", Date.now());
     /**
      * @internal
      * Flag to indicate if batching is enabled for this bloc
      */
-    i(this, "_batchingEnabled", !1);
+    n(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
+     */
+    n(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
+     */
+    n(this, "batch", (e) => {
+      if (this._batchingLock)
+        return e();
+      this._batchingLock = !0, this._batchingEnabled = !0, this._pendingUpdates = [];
+      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 = [];
+      }
+    });
+    this._state = e, this._observer = new E(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;
+  }
+  get isKeepAlive() {
+    return this._keepAlive;
+  }
+  /**
+   * 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.
+   */
+  get state() {
+    return this._disposalState === "disposed" ? this._state : this._state;
+  }
+  /**
+   * Returns whether this Bloc instance has been disposed.
+   * @returns true if the bloc is in DISPOSED state
+   */
+  get isDisposed() {
+    return this._disposalState === "disposed";
+  }
+  /**
+   * @internal
+   * Returns the name of the Bloc class for identification and debugging.
+   */
+  get _name() {
+    return this.constructor.name;
+  }
+  /**
+   * @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
+   */
+  _atomicStateTransition(e, t) {
+    var s, i, r, a;
+    if (this._disposalState === e) {
+      const o = this._disposalState;
+      return this._disposalState = t, (s = globalThis.Blac) != null && s.enableLog && ((i = globalThis.Blac) == null || i.log(
+        `[${this._name}:${this._id}] State transition: ${o} -> ${t} (SUCCESS)`
+      )), {
+        success: !0,
+        currentState: t,
+        previousState: o
+      };
+    }
+    return (r = globalThis.Blac) != null && r.enableLog && ((a = globalThis.Blac) == null || a.log(
+      `[${this._name}:${this._id}] State transition failed: expected ${e}, current ${this._disposalState}`
+    )), {
+      success: !1,
+      currentState: this._disposalState,
+      previousState: e
+    };
+  }
+  /**
+   * @internal
+   * Cleans up resources and removes this Bloc from the system.
+   * Notifies the Blac manager and clears all observers.
+   */
+  _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;
+    }
+  }
+  /**
+   * @internal
+   * Sets the disposal handler for this bloc
+   */
+  _setDisposalHandler(e) {
+    this._disposalHandler = e;
+  }
+  /**
+   * @internal
+   * Schedules disposal of this bloc instance if it has no consumers
+   * Uses atomic state transitions to prevent race conditions
+   */
+  _scheduleDisposal() {
+    if (!this._atomicStateTransition(
+      "active",
+      "disposal_requested"
+      /* DISPOSAL_REQUESTED */
+    ).success)
+      return;
+    if (!(this._consumers.size === 0 && !this._keepAlive)) {
+      this._atomicStateTransition(
+        "disposal_requested",
+        "active"
+        /* ACTIVE */
+      );
+      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
+ */
+n(k, "isolated", !1), /**
+ * When true, the Bloc instance persists even when there are no active consumers.
+ * Useful for maintaining state between component unmount/remount cycles.
+ * @default false
+ */
+n(k, "keepAlive", !1);
+const I = class I {
+  getInstance() {
+    return I._instance || (I._instance = new f({
+      __unsafe_ignore_singleton: !0
+    })), I._instance;
+  }
+  setInstance(e) {
+    I._instance = e;
+  }
+  resetInstance() {
+    const e = I._instance;
+    if (I._instance = new f({
+      __unsafe_ignore_singleton: !0
+    }), e)
+      for (const t of e.keepAliveBlocs)
+        I._instance.keepAliveBlocs.add(t), I._instance.uidRegistry.set(t.uid, t);
+  }
+};
+n(I, "_instance");
+let T = I, b = new T();
+function L(u) {
+  b = u;
+}
+const c = class c {
+  /**
+   * Creates a new Blac instance.
+   * @param options - Configuration options including singleton control
+   */
+  constructor(e = {}) {
+    /** Timestamp when the instance was created */
+    n(this, "createdAt", Date.now());
+    /** Map storing all registered bloc instances by their class name and ID */
+    n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
+    /** Map storing isolated bloc instances grouped by their constructor */
+    // Using BlocConstructor<BlocBase<unknown>> would break type inference when storing
+    // different bloc types in the same map. The 'any' allows proper polymorphic storage
+    // while maintaining type safety at usage sites through the BlocConstructor constraint.
+    n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
+    /** Map for O(1) lookup of isolated blocs by UID */
+    n(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
+    /** Map tracking UIDs to prevent memory leaks */
+    n(this, "uidRegistry", /* @__PURE__ */ new Map());
+    /** Set of keep-alive blocs for controlled cleanup */
+    n(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
+    /** Flag to control whether changes should be posted to document */
+    n(this, "postChangesToDocument", !1);
+    /**
+     * Logs messages to console when logging is enabled
+     * @param args - Arguments to log
+     */
+    n(this, "log", (...e) => {
+      c.logSpy && c.logSpy(e), c.enableLog && c.logLevel, c.enableLog && c.logLevel;
+    });
+    /**
+     * Logs a warning message
+     * @param message - Warning message
+     * @param args - Additional arguments
+     */
+    n(this, "warn", (e, ...t) => {
+      c.enableLog;
+    });
+    /**
+     * Logs an error message
+     * @param message - Error message
+     * @param args - Additional arguments
+     */
+    n(this, "error", (e, ...t) => {
+      c.enableLog;
+    });
+    /**
+     * Resets the Blac instance to a new one, disposing non-keepAlive blocs
+     * from the old instance.
+     */
+    n(this, "resetInstance", () => {
+      this.log("Reset Blac instance");
+      const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
+      e.forEach((s) => {
+        !s._keepAlive && s._disposalState === _.ACTIVE && this.disposeBloc(s);
+      }), t.forEach((s) => {
+        s.forEach((i) => {
+          !i._keepAlive && i._disposalState === _.ACTIVE && this.disposeBloc(i);
+        });
+      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), b.resetInstance();
+    });
+    /**
+     * Disposes of a bloc instance by removing it from the appropriate registry
+     * @param bloc - The bloc instance to dispose
+     */
+    n(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 i = e.constructor, r = this.createBlocInstanceMapKey(e._name, e._id);
+      this.log(
+        `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(i.isolated)}`
+      ), e._dispose(), i.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(r)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
+    });
+    n(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
+     */
+    n(this, "getBloc", (e, t = {}) => {
+      const { id: s, forceNewInstance: i } = t, r = e, a = s ?? e.name;
+      if (this.log(`[${e.name}:${String(a)}] (getBloc) Called:`, {
+        options: t,
+        base: r
+      }), !i)
+        if (r.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 o = this.createNewBlocInstance(e, a, t);
+      if (this.log(
+        `[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`,
+        t,
+        o
+      ), !o)
+        throw new Error(
+          `[getBloc] Failed to create bloc instance for ${e.name}. This should never happen.`
+        );
+      return o;
+    });
+    /**
+     * 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
+     */
+    n(this, "getBlocOrThrow", (e, t = {}) => {
+      const s = e.isolated, i = t.id || e.name, r = s ? this.findIsolatedBlocInstance(e, i) : this.findRegisteredBlocInstance(e, i);
+      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
+     */
+    n(this, "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((r) => r));
+      }
+      return s;
+    });
+    /**
+     * Disposes all keep-alive blocs of a specific type
+     * @param blocClass - The bloc class to dispose
+     */
+    n(this, "disposeKeepAliveBlocs", (e) => {
+      const t = [];
+      for (const s of this.keepAliveBlocs)
+        (!e || s.constructor === e) && t.push(s);
+      t.forEach((s) => s._dispose());
+    });
     /**
-     * @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
+     * Disposes all blocs matching a pattern
+     * @param predicate - Function to test each bloc for disposal
      */
-    i(this, "_pushState", (e, t, s) => {
-      if (e === void 0) {
-        console.warn("BlocBase._pushState: newState is undefined", this);
-        return;
-      }
-      if (s !== void 0 && typeof s != "object" && typeof s != "function") {
-        console.warn("BlocBase._pushState: Invalid action type", this, s);
-        return;
-      }
-      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();
+    n(this, "disposeBlocs", (e) => {
+      const t = [];
+      for (const s of this.blocInstanceMap.values())
+        e(s) && t.push(s);
+      for (const s of this.isolatedBlocMap.values())
+        for (const i of s)
+          e(i) && t.push(i);
+      t.forEach((s) => s._dispose());
     });
     /**
-     * Enables batching for multiple state updates
-     * @param batchFn Function to execute with batching enabled
+     * Gets memory usage statistics for debugging
      */
-    i(this, "batch", (e) => {
-      if (this._batchingLock)
-        return e();
-      this._batchingLock = !0, this._batchingEnabled = !0, this._pendingUpdates = [];
-      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 = [];
-      }
+    n(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
+     */
+    n(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);
     });
-    this._state = e, this._observer = new w(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;
+    const { __unsafe_ignore_singleton: t = !1 } = e;
+    if (!t)
+      return c.instance;
+    b.setInstance(this);
   }
-  get isIsolated() {
-    return this._isolated;
+  static get instance() {
+    return b.getInstance();
   }
-  get isKeepAlive() {
-    return this._keepAlive;
+  static get getAllBlocs() {
+    return c.instance.getAllBlocs;
+  }
+  static get log() {
+    return c.instance.log;
   }
   /**
-   * Returns the current state of the Bloc.
-   * Use this getter to access the state in a read-only manner.
+   * Gets the current Blac instance
+   * @returns The Blac instance
    */
-  get state() {
-    return this._state;
+  static getInstance() {
+    return b.getInstance();
+  }
+  static get warn() {
+    return c.instance.warn;
+  }
+  static get error() {
+    return c.instance.error;
+  }
+  static get disposeBloc() {
+    return c.instance.disposeBloc;
   }
   /**
-   * @internal
-   * Returns the name of the Bloc class for identification and debugging.
+   * 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"
    */
-  get _name() {
-    return this.constructor.name;
+  createBlocInstanceMapKey(e, t) {
+    return `${e}:${String(t)}`;
   }
   /**
-   * @internal
-   * Cleans up resources and removes this Bloc from the system.
-   * Notifies the Blac manager and clears all observers.
+   * Unregister a bloc instance from the main registry
+   * @param bloc - The bloc instance to unregister
    */
-  _dispose() {
-    var e;
-    this._disposalState === "active" && (this._disposalState = "disposing", this._consumers.clear(), this._consumerRefs.clear(), this._observer.clear(), (e = this.onDispose) == null || e.call(this), this._disposalState = "disposed");
+  unregisterBlocInstance(e) {
+    const t = this.createBlocInstanceMapKey(e._name, e._id);
+    this.blocInstanceMap.delete(t), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
   }
   /**
-   * @internal
-   * Sets the disposal handler for this bloc
+   * Registers a bloc instance in the main registry
+   * @param bloc - The bloc instance to register
    */
-  _setDisposalHandler(e) {
-    this._disposalHandler = e;
+  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);
   }
   /**
-   * @internal
-   * Schedules disposal of this bloc instance if it has no consumers
+   * 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
    */
-  _scheduleDisposal() {
-    this._disposalState === "active" && this._consumers.size === 0 && !this._keepAlive && (this._disposalHandler ? this._disposalHandler(this) : this._dispose());
+  findRegisteredBlocInstance(e, t) {
+    if (e.isolated) return;
+    const i = this.createBlocInstanceMapKey(e.name, t);
+    return this.blocInstanceMap.get(i);
   }
-}
-/**
- * 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(B, "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(B, "keepAlive", !1);
-class b extends B {
+  /**
+   * 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((o) => o.uid === e.uid);
+      a !== -1 && (s.splice(a, 1), i = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
+    }
+    const r = this.isolatedBlocIndex.delete(e.uid);
+    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), i !== r && this.warn(
+      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${i}, Index removal: ${r}`
+    );
+  }
+  /**
+   * 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) : 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 { props: i, instanceRef: r } = s, a = new e(i);
+    return a._instanceRef = r, a.props = i || null, a._updateId(t), a._setDisposalHandler((o) => this.disposeBloc(o)), a.isIsolated ? (this.registerIsolatedBlocInstance(a), a) : (this.registerBlocInstance(a), a);
+  }
+  static get activateBloc() {
+    return c.instance.activateBloc;
+  }
+  static get getBloc() {
+    return c.instance.getBloc;
+  }
+  static get getBlocOrThrow() {
+    return c.instance.getBlocOrThrow;
+  }
+  static get disposeKeepAliveBlocs() {
+    return c.instance.disposeKeepAliveBlocs;
+  }
+  static get disposeBlocs() {
+    return c.instance.disposeBlocs;
+  }
+  static get getMemoryStats() {
+    return c.instance.getMemoryStats;
+  }
+  static get validateConsumers() {
+    return c.instance.validateConsumers;
+  }
+};
+/** Flag to enable/disable logging */
+n(c, "enableLog", !1), n(c, "logLevel", "warn"), n(c, "logSpy", null), n(c, "resetInstance", () => {
+  b.resetInstance();
+});
+let f = c;
+class O extends k {
   constructor() {
     super(...arguments);
     // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
     // The handler's event parameter will be correctly typed to the specific EventConstructor
     // by the 'on' method's signature.
-    i(this, "eventHandlers", /* @__PURE__ */ new Map());
+    n(this, "eventHandlers", /* @__PURE__ */ new Map());
     /**
      * @internal
      * Event queue to ensure sequential processing of async events
      */
-    i(this, "_eventQueue", []);
+    n(this, "_eventQueue", []);
     /**
      * @internal
      * Flag indicating if an event is currently being processed
      */
-    i(this, "_isProcessingEvent", !1);
+    n(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) => {
+    n(this, "add", async (t) => {
       this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
     });
   }
@@ -716,7 +858,7 @@ class b extends B {
    *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
    */
   on(t, s) {
-    this.eventHandlers.has(t) && l.warn(
+    this.eventHandlers.has(t) && f.warn(
       `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
       t,
@@ -745,35 +887,35 @@ class b extends B {
    * Processes a single event
    */
   async _processEvent(t) {
-    const s = t.constructor, n = this.eventHandlers.get(s);
-    if (n) {
-      const o = (a) => {
-        const r = this.state;
-        this._pushState(a, r, t);
+    const s = t.constructor, i = this.eventHandlers.get(s);
+    if (i) {
+      const r = (a) => {
+        const o = this.state;
+        this._pushState(a, o, t);
       };
       try {
-        await n(t, o);
+        await i(t, r);
       } catch (a) {
-        const r = t.constructor.name || "UnnamedConstructor", h = {
+        const o = t.constructor.name || "UnnamedConstructor", l = {
           blocName: this._name,
           blocId: String(this._id),
-          eventType: r,
+          eventType: o,
           currentState: this.state,
           action: t,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        if (l.error(
-          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${r}':`,
+        if (f.error(
+          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${o}':`,
           a,
           "Context:",
-          h
+          l
         ), a instanceof Error && a.name === "CriticalError")
           throw a;
       }
     } else {
-      const o = t.constructor.name || "UnnamedConstructor";
-      l.warn(
-        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${o}'.`,
+      const r = t.constructor.name || "UnnamedConstructor";
+      f.warn(
+        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${r}'.`,
         "Registered handlers:",
         Array.from(this.eventHandlers.keys()).map((a) => a.name),
         "Action was:",
@@ -782,7 +924,7 @@ class b extends B {
     }
   }
 }
-class k extends B {
+class V extends k {
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),
@@ -798,14 +940,14 @@ class k extends B {
   /**
    * Partially updates the current state by merging it with the provided state patch.
    * This method is only applicable when the state is an object type.
-   * 
+   *
    * @param statePatch - A partial state object containing only the properties to update
    * @param ignoreChangeCheck - If true, skips checking if the state has actually changed
    * @throws {TypeError} If the state is not an object type
    */
   patch(e, t = !1) {
     if (typeof this.state != "object" || this.state === null) {
-      l.warn(
+      f.warn(
         "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
       );
       return;
@@ -814,10 +956,10 @@ class k extends B {
     if (t)
       s = !0;
     else
-      for (const n in e)
-        if (Object.prototype.hasOwnProperty.call(e, n)) {
-          const a = this.state[n];
-          if (!Object.is(e[n], a)) {
+      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;
           }
@@ -828,78 +970,86 @@ class k extends B {
     });
   }
 }
-class x {
+class U {
   /**
    * Sets up a clean test environment
    */
   static setUp() {
-    this.originalInstance = l.instance, l.resetInstance(), l.enableLog = !1;
+    this.originalInstance = f.instance, f.resetInstance(), f.enableLog = !1;
   }
   /**
    * Tears down the test environment and restores original state
    */
   static tearDown() {
-    l.resetInstance();
+    f.resetInstance();
   }
   /**
    * Creates a test bloc with automatic cleanup
    */
   static createBloc(e, ...t) {
     const s = new e(...t);
-    return l.activateBloc(s), s;
+    return f.activateBloc(s), s;
   }
   /**
    * Waits for a bloc to emit a specific state
    */
   static async waitForState(e, t, s = 5e3) {
-    return new Promise((n, o) => {
+    return new Promise((i, r) => {
       const a = setTimeout(() => {
-        o(new Error(`Timeout waiting for state matching predicate after ${s}ms`));
-      }, s), r = e._observer.subscribe({
-        id: `test-waiter-${crypto.randomUUID()}`,
-        fn: (h) => {
-          t(h) && (clearTimeout(a), r(), n(h));
+        r(
+          new Error(
+            `Timeout waiting for state matching predicate after ${s}ms`
+          )
+        );
+      }, s), o = e._observer.subscribe({
+        id: `test-waiter-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        fn: (l) => {
+          t(l) && (clearTimeout(a), o(), i(l));
         }
       });
-      t(e.state) && (clearTimeout(a), r(), n(e.state));
+      t(e.state) && (clearTimeout(a), o(), i(e.state));
     });
   }
   /**
    * Expects a bloc to emit specific states in order
    */
   static async expectStates(e, t, s = 5e3) {
-    const n = [];
-    return new Promise((o, a) => {
-      const r = setTimeout(() => {
-        a(new Error(
-          `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(n)}`
-        ));
-      }, s), h = e._observer.subscribe({
+    const i = [];
+    return new Promise((r, a) => {
+      const o = setTimeout(() => {
+        a(
+          new Error(
+            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(i)}`
+          )
+        );
+      }, s), l = e._observer.subscribe({
         id: `test-expecter-${crypto.randomUUID()}`,
-        fn: (_) => {
-          if (n.push(_), n.length === t.length) {
-            clearTimeout(r), h();
-            for (let p = 0; p < t.length; p++) {
-              const f = t[p], I = n[p];
-              if (JSON.stringify(f) !== JSON.stringify(I)) {
-                a(new Error(
-                  `State mismatch at index ${p}. Expected: ${JSON.stringify(f)}, Received: ${JSON.stringify(I)}`
-                ));
+        fn: (p) => {
+          if (i.push(p), i.length === t.length) {
+            clearTimeout(o), l();
+            for (let d = 0; d < t.length; d++) {
+              const m = t[d], v = i[d];
+              if (JSON.stringify(m) !== JSON.stringify(v)) {
+                a(
+                  new Error(
+                    `State mismatch at index ${d}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(v)}`
+                  )
+                );
                 return;
               }
             }
-            o();
+            r();
           }
         }
       });
     });
   }
 }
-i(x, "originalInstance");
-class A extends b {
+n(U, "originalInstance");
+class z extends O {
   constructor(t) {
     super(t);
-    i(this, "mockHandlers", /* @__PURE__ */ new Map());
+    n(this, "mockHandlers", /* @__PURE__ */ new Map());
   }
   /**
    * Mock an event handler for testing
@@ -920,10 +1070,10 @@ class A extends b {
     return this.eventHandlers.has(t);
   }
 }
-class E extends k {
+class j extends V {
   constructor(t) {
     super(t);
-    i(this, "stateHistory", []);
+    n(this, "stateHistory", []);
     this.stateHistory.push(t);
   }
   /**
@@ -945,16 +1095,16 @@ class E extends k {
     this.stateHistory = [this.state];
   }
 }
-class R {
+class K {
   constructor() {
-    i(this, "initialStats");
-    this.initialStats = l.getMemoryStats();
+    n(this, "initialStats");
+    this.initialStats = f.getMemoryStats();
   }
   /**
    * Check for memory leaks and return a report
    */
   checkForLeaks() {
-    const e = l.getMemoryStats(), t = e.registeredBlocs > this.initialStats.registeredBlocs || e.isolatedBlocs > this.initialStats.isolatedBlocs || e.keepAliveBlocs > this.initialStats.keepAliveBlocs, s = `
+    const e = f.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}
@@ -971,17 +1121,400 @@ Memory Leak Detection Report:
     };
   }
 }
+class H {
+  constructor() {
+    n(this, "consumers", /* @__PURE__ */ new WeakMap());
+    n(this, "registrationCount", 0);
+    n(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, i) {
+    const r = this.consumers.get(e);
+    if (!r) return;
+    const a = Date.now();
+    r.firstAccessTime || (r.firstAccessTime = a), r.accessCount++, r.lastAccessTime = a, t === "state" ? (r.stateAccesses.add(s), i !== void 0 && r.stateValues.set(s, { value: i, lastAccessTime: a })) : (r.classAccesses.add(s), i !== void 0 && r.classValues.set(s, { value: i, lastAccessTime: a }));
+  }
+  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 i = this.consumers.get(e);
+    if (!i) return !0;
+    let r = !1;
+    const a = Date.now();
+    if (i.stateValues.size === 0 && i.classValues.size === 0 && (i.stateAccesses.size > 0 || i.classAccesses.size > 0))
+      return !0;
+    for (const [o, l] of i.stateValues)
+      try {
+        const p = this.getValueAtPath(t, o);
+        p !== l.value && (i.stateValues.set(o, {
+          value: p,
+          lastAccessTime: a
+        }), r = !0);
+      } catch {
+        r = !0;
+      }
+    for (const [o, l] of i.classValues)
+      try {
+        const p = this.getValueAtPath(s, o);
+        p !== l.value && (i.classValues.set(o, {
+          value: p,
+          lastAccessTime: a
+        }), r = !0);
+      } catch {
+        r = !0;
+      }
+    return r;
+  }
+  shouldNotifyConsumer(e, t) {
+    const s = this.consumers.get(e);
+    if (!s) return !1;
+    for (const i of t) {
+      if (s.stateAccesses.has(i) || s.classAccesses.has(i)) return !0;
+      for (const r of s.stateAccesses)
+        if (i.startsWith(r + ".") || r.startsWith(i + "."))
+          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 i = e;
+    for (const r of s) {
+      if (i == null) return;
+      i = i[r];
+    }
+    return i;
+  }
+}
+const w = /* @__PURE__ */ new WeakMap();
+let h = {
+  stateProxiesCreated: 0,
+  classProxiesCreated: 0,
+  cacheHits: 0,
+  cacheMisses: 0,
+  propertyAccesses: 0,
+  nestedProxiesCreated: 0,
+  totalProxiesCreated: 0,
+  createdAt: Date.now()
+};
+class y {
+  static createStateProxy(e) {
+    const { target: t, consumerRef: s, consumerTracker: i, path: r = "" } = e;
+    if (!s || !i || typeof t != "object" || t === null)
+      return t;
+    let a = w.get(t);
+    a || (a = /* @__PURE__ */ new WeakMap(), w.set(t, a));
+    const o = a.get(s);
+    if (o)
+      return h.cacheHits++, o;
+    h.cacheMisses++;
+    const l = {
+      get(d, m) {
+        if (typeof m == "symbol" || m === "constructor")
+          return Reflect.get(d, m);
+        const v = r ? `${r}.${m}` : m;
+        h.propertyAccesses++;
+        const g = Reflect.get(d, m), S = g && typeof g === "object" && g !== null ? void 0 : g;
+        if (i.trackAccess(s, "state", v, S), g && typeof g == "object" && g !== null) {
+          const B = Object.getPrototypeOf(g) === Object.prototype, D = Array.isArray(g);
+          if (B || D)
+            return h.nestedProxiesCreated++, y.createStateProxy({
+              target: g,
+              consumerRef: s,
+              consumerTracker: i,
+              path: v
+            });
+        }
+        return g;
+      },
+      has(d, m) {
+        return m in d;
+      },
+      ownKeys(d) {
+        return Reflect.ownKeys(d);
+      },
+      getOwnPropertyDescriptor(d, m) {
+        return Reflect.getOwnPropertyDescriptor(d, m);
+      },
+      set() {
+        return !1;
+      },
+      deleteProperty() {
+        return !1;
+      }
+    }, p = new Proxy(t, l);
+    return a.set(s, p), h.stateProxiesCreated++, h.totalProxiesCreated++, p;
+  }
+  static createClassProxy(e) {
+    const { target: t, consumerRef: s, consumerTracker: i } = e;
+    if (!s || !i)
+      return t;
+    let r = w.get(t);
+    r || (r = /* @__PURE__ */ new WeakMap(), w.set(t, r));
+    const a = r.get(s);
+    if (a)
+      return h.cacheHits++, a;
+    h.cacheMisses++;
+    const o = {
+      get(p, d) {
+        const m = Reflect.get(p, d);
+        let v = !1, g = p;
+        const A = /* @__PURE__ */ new WeakSet(), C = 10;
+        let S = 0;
+        for (; g && !v && S < C && !A.has(g); ) {
+          A.add(g);
+          try {
+            const x = Object.getOwnPropertyDescriptor(
+              g,
+              d
+            );
+            if (x && x.get) {
+              v = !0;
+              break;
+            }
+            g = Object.getPrototypeOf(g), S++;
+          } catch {
+            break;
+          }
+        }
+        if (!v)
+          return m;
+        h.propertyAccesses++;
+        const B = m, $ = B !== null && typeof B != "object" ? B : void 0;
+        return i.trackAccess(
+          s,
+          "class",
+          String(d),
+          $
+        ), m;
+      },
+      has(p, d) {
+        return d in p;
+      },
+      ownKeys(p) {
+        return Reflect.ownKeys(p);
+      },
+      getOwnPropertyDescriptor(p, d) {
+        return Reflect.getOwnPropertyDescriptor(p, d);
+      }
+    }, l = new Proxy(t, o);
+    return r.set(s, l), h.classProxiesCreated++, h.totalProxiesCreated++, l;
+  }
+  static getProxyState(e) {
+    return y.createStateProxy({
+      target: e.state,
+      consumerRef: e.consumerRef,
+      consumerTracker: e.consumerTracker
+    });
+  }
+  static getProxyBlocInstance(e) {
+    return y.createClassProxy({
+      target: e.blocInstance,
+      consumerRef: e.consumerRef,
+      consumerTracker: e.consumerTracker
+    });
+  }
+  static getStats() {
+    const e = Date.now() - h.createdAt;
+    return {
+      ...h,
+      totalProxies: h.stateProxiesCreated + h.classProxiesCreated,
+      cacheEfficiency: h.cacheHits + h.cacheMisses > 0 ? `${(h.cacheHits / (h.cacheHits + h.cacheMisses) * 100).toFixed(1)}%` : "N/A",
+      lifetime: `${e}ms`,
+      proxiesPerSecond: e > 0 ? (h.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
+    };
+  }
+  static resetStats() {
+    h = {
+      stateProxiesCreated: 0,
+      classProxiesCreated: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      propertyAccesses: 0,
+      nestedProxiesCreated: 0,
+      totalProxiesCreated: 0,
+      createdAt: Date.now()
+    };
+  }
+}
+class q {
+  constructor(e, t) {
+    n(this, "id", `consumer-${R()}`);
+    n(this, "blocConstructor");
+    n(this, "componentRef", { current: {} });
+    n(this, "blocInstance");
+    // Core components
+    n(this, "consumerTracker");
+    n(this, "unmountTime", 0);
+    n(this, "mountTime", 0);
+    // Dependency tracking
+    n(this, "dependencyValues");
+    n(this, "isUsingDependencies", !1);
+    // Lifecycle state
+    n(this, "hasMounted", !1);
+    n(this, "mountCount", 0);
+    n(this, "options");
+    n(this, "createStateProxy", (e) => y.createStateProxy({
+      target: e.target,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this
+    }));
+    n(this, "createClassProxy", (e) => y.createClassProxy({
+      target: e.target,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this
+    }));
+    n(this, "createSubscription", (e) => this.blocInstance._observer.subscribe({
+      id: this.id,
+      fn: (s, i) => {
+        var r;
+        if (this.isUsingDependencies && ((r = this.options) != null && r.dependencies)) {
+          const a = this.options.dependencies(this.blocInstance);
+          if (!this.hasDependencyValuesChanged(
+            this.dependencyValues,
+            a
+          ))
+            return;
+          this.dependencyValues = a;
+        } else {
+          const a = this.consumerTracker.getConsumerInfo(
+            this.componentRef.current
+          );
+          if (a && a.hasRendered && !this.consumerTracker.hasValuesChanged(
+            this.componentRef.current,
+            s,
+            this.blocInstance
+          ))
+            return;
+        }
+        e.onChange();
+      }
+    }));
+    n(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;
+        }
+    });
+    n(this, "unmount", () => {
+      var e;
+      if (this.unmountTime = Date.now(), this.consumerTracker.unregister(this.componentRef.current), this.blocInstance._removeConsumer(this.id), (e = this.options) != null && e.onUnmount)
+        try {
+          this.options.onUnmount(this.blocInstance);
+        } catch {
+        }
+    });
+    n(this, "getProxyState", (e) => this.isUsingDependencies ? e : y.getProxyState({
+      state: e,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this
+    }));
+    n(this, "getProxyBlocInstance", () => this.isUsingDependencies ? this.blocInstance : y.getProxyBlocInstance({
+      blocInstance: this.blocInstance,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this
+    }));
+    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!(t != null && t.dependencies), this.consumerTracker = new H(), this.blocInstance = this.updateBlocInstance(), this.consumerTracker.register(e.componentRef.current, this.id), this.isUsingDependencies && (t != null && t.dependencies) && (this.dependencyValues = t.dependencies(this.blocInstance));
+  }
+  trackAccess(e, t, s, i) {
+    this.consumerTracker.trackAccess(e, t, s, i);
+  }
+  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);
+  }
+  updateBlocInstance() {
+    var e, t;
+    return this.blocInstance = f.instance.getBloc(this.blocConstructor, {
+      props: (e = this.options) == null ? void 0 : e.props,
+      id: (t = this.options) == null ? void 0 : t.id,
+      instanceRef: this.id
+    }), this.blocInstance;
+  }
+  // Expose calledOnMount for backward compatibility
+  get calledOnMount() {
+    return this.hasMounted;
+  }
+  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;
+  }
+}
 export {
-  l as Blac,
-  w as BlacObservable,
-  b as Bloc,
-  B as BlocBase,
-  x as BlocTest,
-  k as Cubit,
-  R as MemoryLeakDetector,
-  A as MockBloc,
-  E as MockCubit,
-  S as generateUUID,
-  M as setBlacInstanceManager
+  f as Blac,
+  q as BlacAdapter,
+  E as BlacObservable,
+  O as Bloc,
+  k as BlocBase,
+  _ as BlocLifecycleState,
+  U as BlocTest,
+  H as ConsumerTracker,
+  V as Cubit,
+  K as MemoryLeakDetector,
+  z as MockBloc,
+  j as MockCubit,
+  y as ProxyFactory,
+  R as generateUUID,
+  L as setBlacInstanceManager
 };
 //# sourceMappingURL=index.es.js.map