@blac/core 2.0.0-rc-5 → 2.0.0-rc-6

package/dist/index.es.js

@@ -1,92 +1,96 @@
-var v = Object.defineProperty;
-var w = (l, e, t) => e in l ? v(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
-var n = (l, e, t) => w(l, typeof e != "symbol" ? e + "" : e, t);
-const d = class d {
+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 d._instance || (d._instance = new h({ __unsafe_ignore_singleton: !0 })), d._instance;
+    return u._instance || (u._instance = new l({ __unsafe_ignore_singleton: !0 })), u._instance;
   }
   setInstance(e) {
-    d._instance = e;
+    u._instance = e;
   }
   resetInstance() {
-    const e = d._instance;
-    if (d._instance = new h({ __unsafe_ignore_singleton: !0 }), e)
+    const e = u._instance;
+    if (u._instance = new l({ __unsafe_ignore_singleton: !0 }), e)
       for (const t of e.keepAliveBlocs)
-        d._instance.keepAliveBlocs.add(t), d._instance.uidRegistry.set(t.uid, t);
+        u._instance.keepAliveBlocs.add(t), u._instance.uidRegistry.set(t.uid, t);
   }
 };
-n(d, "_instance");
-let _ = d, u = new _();
-function b(l) {
-  u = l;
+i(u, "_instance");
+let v = u, g = new v();
+function M(d) {
+  g = d;
 }
-const r = class r {
+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());
+    i(this, "createdAt", Date.now());
     /** Map storing all registered bloc instances by their class name and ID */
-    n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
+    i(this, "blocInstanceMap", /* @__PURE__ */ new Map());
     /** Map storing isolated bloc instances grouped by their constructor */
-    n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
+    i(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
     /** Map for O(1) lookup of isolated blocs by UID */
-    n(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
+    i(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
     /** Map tracking UIDs to prevent memory leaks */
-    n(this, "uidRegistry", /* @__PURE__ */ new Map());
+    i(this, "uidRegistry", /* @__PURE__ */ new Map());
     /** Set of keep-alive blocs for controlled cleanup */
-    n(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
+    i(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
     /** Flag to control whether changes should be posted to document */
-    n(this, "postChangesToDocument", !1);
+    i(this, "postChangesToDocument", !1);
     /**
      * Logs messages to console when logging is enabled
      * @param args - Arguments to log
      */
-    n(this, "log", (...e) => {
-      r.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...e);
+    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
      */
-    n(this, "warn", (e, ...t) => {
-      r.enableLog && console.warn(`🚨 [Blac ${String(r.instance.createdAt)}]`, e, ...t);
+    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
      */
-    n(this, "error", (e, ...t) => {
-      r.enableLog && console.error(`🚨 [Blac ${String(r.instance.createdAt)}]`, e, ...t);
+    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.
      */
-    n(this, "resetInstance", () => {
+    i(this, "resetInstance", () => {
       this.log("Reset Blac instance");
       const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
       e.forEach((s) => {
-        s._keepAlive || s._dispose();
+        !s._keepAlive && s._disposalState === "active" && this.disposeBloc(s);
       }), t.forEach((s) => {
-        s.forEach((i) => {
-          i._keepAlive || i._dispose();
+        s.forEach((n) => {
+          !n._keepAlive && n._disposalState === "active" && this.disposeBloc(n);
         });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), u.resetInstance();
+      }), 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
      */
-    n(this, "disposeBloc", (e) => {
+    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)}`), t.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
+      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);
     });
-    n(this, "activateBloc", (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));
     });
@@ -101,27 +105,27 @@ const r = class r {
      *   - instanceRef: Optional reference string for the instance
      * @returns The bloc instance
      */
-    n(this, "getBloc", (e, t = {}) => {
-      const { id: s } = t, i = e, a = s ?? e.name;
-      if (i.isolated) {
-        const c = this.findIsolatedBlocInstance(e, a);
-        if (c)
-          return this.log(`[${e.name}:${String(a)}] (getBloc) Found existing isolated instance.`, t), c;
+    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 c = this.findRegisteredBlocInstance(e, a);
-        if (c)
-          return this.log(`[${e.name}:${String(a)}] (getBloc) Found existing registered instance.`, t), c;
+        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 o = this.createNewBlocInstance(
+      const a = this.createNewBlocInstance(
         e,
-        a,
+        o,
         t
       );
-      return this.log(`[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`, t, o), o;
+      return this.log(`[${e.name}:${String(o)}] (getBloc) No existing instance found. Creating new one.`, t, a), a;
     });
     /**
      * Gets a bloc instance or throws an error if it doesn't exist
@@ -131,10 +135,10 @@ const r = class r {
      *   - 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, a = s ? this.findIsolatedBlocInstance(e, i) : this.findRegisteredBlocInstance(e, i);
-      if (a)
-        return a;
+    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`);
     });
     /**
@@ -144,13 +148,13 @@ const r = class r {
      *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
      * @returns Array of matching bloc instances
      */
-    n(this, "getAllBlocs", (e, t = {}) => {
+    i(this, "getAllBlocs", (e, t = {}) => {
       const s = [];
-      if (this.blocInstanceMap.forEach((i) => {
-        i.constructor === e && s.push(i);
+      if (this.blocInstanceMap.forEach((n) => {
+        n.constructor === e && s.push(n);
       }), t.searchIsolated !== !1) {
-        const i = this.isolatedBlocMap.get(e);
-        i && s.push(...i.map((a) => a));
+        const n = this.isolatedBlocMap.get(e);
+        n && s.push(...n.map((o) => o));
       }
       return s;
     });
@@ -158,7 +162,7 @@ const r = class r {
      * Disposes all keep-alive blocs of a specific type
      * @param blocClass - The bloc class to dispose
      */
-    n(this, "disposeKeepAliveBlocs", (e) => {
+    i(this, "disposeKeepAliveBlocs", (e) => {
       const t = [];
       for (const s of this.keepAliveBlocs)
         (!e || s.constructor === e) && t.push(s);
@@ -168,19 +172,19 @@ const r = class r {
      * Disposes all blocs matching a pattern
      * @param predicate - Function to test each bloc for disposal
      */
-    n(this, "disposeBlocs", (e) => {
+    i(this, "disposeBlocs", (e) => {
       const t = [];
       for (const s of this.blocInstanceMap.values())
         e(s) && t.push(s);
       for (const s of this.isolatedBlocMap.values())
-        for (const i of s)
-          e(i) && t.push(i);
+        for (const n of s)
+          e(n) && t.push(n);
       t.forEach((s) => s._dispose());
     });
     /**
      * Gets memory usage statistics for debugging
      */
-    n(this, "getMemoryStats", () => ({
+    i(this, "getMemoryStats", () => ({
       totalBlocs: this.uidRegistry.size,
       registeredBlocs: this.blocInstanceMap.size,
       isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce((e, t) => e + t.length, 0),
@@ -190,39 +194,42 @@ const r = class r {
     /**
      * Validates consumer references and cleans up orphaned consumers
      */
-    n(this, "validateConsumers", () => {
+    i(this, "validateConsumers", () => {
       for (const e of this.uidRegistry.values())
-        e._consumers.size === 0 && !e._keepAlive && setTimeout(() => {
-          e._consumers.size === 0 && !e._keepAlive && e._dispose();
+        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 r.instance;
-    u.setInstance(this);
+      return c.instance;
+    g.setInstance(this);
   }
   /** @deprecated Use getInstance() instead */
   static get instance() {
-    return u.getInstance();
+    return g.getInstance();
   }
   static get getAllBlocs() {
-    return r.instance.getAllBlocs;
+    return c.instance.getAllBlocs;
   }
   static get log() {
-    return r.instance.log;
+    return c.instance.log;
   }
   /**
    * Gets the current Blac instance
    * @returns The Blac instance
    */
   static getInstance() {
-    return u.getInstance();
+    return g.getInstance();
   }
   static get warn() {
-    return r.instance.warn;
+    return c.instance.warn;
   }
   static get error() {
-    return r.instance.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
@@ -257,8 +264,8 @@ const r = class r {
    */
   findRegisteredBlocInstance(e, t) {
     if (e.isolated) return;
-    const i = this.createBlocInstanceMapKey(e.name, t);
-    return this.blocInstanceMap.get(i);
+    const n = this.createBlocInstanceMapKey(e.name, t);
+    return this.blocInstanceMap.get(n);
   }
   /**
    * Registers an isolated bloc instance in the isolated registry
@@ -274,19 +281,23 @@ const r = class r {
    */
   unregisterIsolatedBlocInstance(e) {
     const t = e.constructor, s = this.isolatedBlocMap.get(t);
+    let n = !1;
     if (s) {
-      const i = s.findIndex((a) => a.uid === e.uid);
-      i !== -1 && s.splice(i, 1), s.length === 0 && this.isolatedBlocMap.delete(t);
+      const a = s.findIndex((r) => r.uid === e.uid);
+      a !== -1 && (s.splice(a, 1), n = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
     }
-    this.isolatedBlocIndex.delete(e.uid), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
+    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 i = this.isolatedBlocMap.get(e);
-    return i ? i.find((o) => o._id === t) : void 0;
+    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)
@@ -303,45 +314,45 @@ const r = class r {
    * @returns The newly created bloc instance
    */
   createNewBlocInstance(e, t, s = {}) {
-    const { props: i, instanceRef: a } = s, o = new e(i);
-    return o._instanceRef = a, o.props = i || null, o._updateId(t), o._setDisposalHandler((c) => this.disposeBloc(c)), o.isIsolated ? (this.registerIsolatedBlocInstance(o), o) : (this.registerBlocInstance(o), o);
+    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 r.instance.activateBloc;
+    return c.instance.activateBloc;
   }
   static get getBloc() {
-    return r.instance.getBloc;
+    return c.instance.getBloc;
   }
   static get getBlocOrThrow() {
-    return r.instance.getBlocOrThrow;
+    return c.instance.getBlocOrThrow;
   }
   static get disposeKeepAliveBlocs() {
-    return r.instance.disposeKeepAliveBlocs;
+    return c.instance.disposeKeepAliveBlocs;
   }
   static get disposeBlocs() {
-    return r.instance.disposeBlocs;
+    return c.instance.disposeBlocs;
   }
   static get getMemoryStats() {
-    return r.instance.getMemoryStats;
+    return c.instance.getMemoryStats;
   }
   static get validateConsumers() {
-    return r.instance.validateConsumers;
+    return c.instance.validateConsumers;
   }
 };
 /** Flag to enable/disable logging */
-n(r, "enableLog", !1), n(r, "resetInstance", () => {
-  u.resetInstance();
+i(c, "enableLog", !1), i(c, "resetInstance", () => {
+  g.resetInstance();
 });
-let h = r;
-class m {
+let l = c;
+class w {
   /**
    * Creates a new BlacObservable instance
    * @param bloc - The Bloc instance to observe
    */
   constructor(e) {
     /** The Bloc instance this observable is associated with */
-    n(this, "bloc");
-    n(this, "_observers", /* @__PURE__ */ new Set());
+    i(this, "bloc");
+    i(this, "_observers", /* @__PURE__ */ new Set());
     this.bloc = e;
   }
   /**
@@ -364,8 +375,8 @@ class m {
    * @returns A function that can be called to unsubscribe the observer
    */
   subscribe(e) {
-    return h.log("BlacObservable.subscribe: Subscribing observer.", this.bloc, e), this._observers.add(e), e.lastState || (e.lastState = e.dependencyArray ? e.dependencyArray(this.bloc.state) : []), () => {
-      h.log("BlacObservable.subscribe: Unsubscribing observer.", this.bloc, e), this.unsubscribe(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);
     };
   }
   /**
@@ -373,7 +384,7 @@ class m {
    * @param observer - The observer to unsubscribe
    */
   unsubscribe(e) {
-    this._observers.delete(e), this.size === 0 && (h.log("BlacObservable.unsubscribe: No observers left. Disposing bloc.", this.bloc), this.bloc._dispose());
+    this._observers.delete(e), this.size === 0 && l.log("BlacObservable.unsubscribe: No observers left.", this.bloc);
   }
   /**
    * Notifies all observers of a state change
@@ -382,34 +393,48 @@ class m {
    * @param action - Optional action that triggered the state change
    */
   notify(e, t, s) {
-    this._observers.forEach((i) => {
-      let a = !1;
-      if (i.dependencyArray) {
-        const o = i.lastState || [], c = i.dependencyArray(e);
-        for (let p = 0; p < c.length; p++) {
-          const B = c[p], I = o[p] || [];
-          for (let f = 0; f < B.length; f++)
-            if (!Object.is(B[f], I[f])) {
-              a = !0;
+    this._observers.forEach((n) => {
+      let o = !1;
+      if (n.dependencyArray) {
+        const a = n.lastState, r = n.dependencyArray(e);
+        if (!a)
+          o = !0;
+        else if (a.length !== r.length)
+          o = !0;
+        else
+          for (let h = 0; h < r.length; h++) {
+            const _ = r[h], p = a[h] || [];
+            if (_.length !== p.length) {
+              o = !0;
               break;
             }
-        }
-        i.lastState = c;
+            for (let f = 0; f < _.length; f++)
+              if (!Object.is(_[f], p[f])) {
+                o = !0;
+                break;
+              }
+            if (o) break;
+          }
+        n.lastState = r;
       } else
-        a = !0;
-      a && i.fn(e, t, s);
+        o = !0;
+      o && n.fn(e, t, s);
     });
   }
   /**
    * Clears the observer set
    */
   clear() {
-    this._observers.forEach((e) => {
-      this.unsubscribe(e);
-    }), this._observers.clear();
+    this._observers.clear();
   }
 }
-class g {
+function S() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(d) {
+    const e = Math.random() * 16 | 0;
+    return (d === "x" ? e : e & 3 | 8).toString(16);
+  });
+}
+class B {
   /**
    * Creates a new BlocBase instance with the given initial state.
    * Sets up the observer, registers with the Blac manager, and initializes addons.
@@ -417,57 +442,90 @@ class g {
    * @param initialState The initial state value for this Bloc
    */
   constructor(e) {
-    n(this, "uid", crypto.randomUUID());
+    i(this, "uid", S());
     /**
      * Defines how dependencies are selected from the state for efficient updates.
      * When provided, observers will only be notified when selected dependencies change.
      */
-    n(this, "defaultDependencySelector");
+    i(this, "defaultDependencySelector");
     /**
      * @internal
      * Indicates if this specific Bloc instance is isolated from others of the same type.
      */
-    n(this, "_isolated", !1);
+    i(this, "_isolated", !1);
     /**
      * @internal
      * Observable responsible for managing state listeners and notifying consumers.
      */
-    n(this, "_observer");
+    i(this, "_observer");
     /**
      * The unique identifier for this Bloc instance.
      * Defaults to the class name, but can be customized.
      */
-    n(this, "_id");
+    i(this, "_id");
     /**
      * @internal
      * Reference string used internally for tracking and debugging.
      */
-    n(this, "_instanceRef");
+    i(this, "_instanceRef");
     /**
      * @internal
      * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
      */
-    n(this, "_keepAlive", !1);
+    i(this, "_keepAlive", !1);
     /**
      * @readonly
      * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
      */
-    n(this, "_createdAt", Date.now());
+    i(this, "_createdAt", Date.now());
+    /**
+     * @internal
+     * Disposal state to prevent race conditions
+     */
+    i(this, "_disposalState", "active");
     /**
      * @internal
      * The current state of the Bloc.
      */
-    n(this, "_state");
+    i(this, "_state");
     /**
      * @internal
      * The previous state of the Bloc, maintained for comparison and history.
      */
-    n(this, "_oldState");
+    i(this, "_oldState");
     /**
      * Props passed during Bloc instance creation.
      * Can be used to configure or parameterize the Bloc's behavior.
      */
-    n(this, "props", null);
+    i(this, "props", null);
+    /**
+     * @internal
+     * Flag to prevent batching race conditions
+     */
+    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.
@@ -475,7 +533,7 @@ class g {
      * 
      * @param id The new ID to assign to this Bloc instance
      */
-    n(this, "_updateId", (e) => {
+    i(this, "_updateId", (e) => {
       const t = this._id;
       !e || e === t || (this._id = e);
     });
@@ -483,17 +541,12 @@ class g {
      * @internal
      * Optional function to be called when the Bloc is disposed.
      */
-    n(this, "onDispose");
+    i(this, "onDispose");
     /**
      * @internal
      * Set of consumer IDs currently listening to this Bloc's state changes.
      */
-    n(this, "_consumers", /* @__PURE__ */ new Set());
-    /**
-     * @internal
-     * WeakSet to track consumer references for cleanup validation
-     */
-    n(this, "_consumerRefs", /* @__PURE__ */ new WeakSet());
+    i(this, "_consumers", /* @__PURE__ */ new Set());
     /**
      * @internal
      * Registers a new consumer to this Bloc instance.
@@ -502,8 +555,8 @@ class g {
      * @param consumerId The unique ID of the consumer being added
      * @param consumerRef Optional reference to the consumer object for cleanup validation
      */
-    n(this, "_addConsumer", (e, t) => {
-      this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.add(t));
+    i(this, "_addConsumer", (e, t) => {
+      this._disposalState === "active" && (this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.set(e, new WeakRef(t))));
     });
     /**
      * @internal
@@ -512,25 +565,20 @@ class g {
      * 
      * @param consumerId The unique ID of the consumer being removed
      */
-    n(this, "_removeConsumer", (e) => {
-      this._consumers.has(e) && (this._consumers.delete(e), this._consumers.size === 0 && !this._keepAlive && this._scheduleDisposal());
+    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());
     });
     /**
      * @internal
      * Handler function for disposal (can be set by Blac manager)
      */
-    n(this, "_disposalHandler");
-    n(this, "lastUpdate", Date.now());
+    i(this, "_disposalHandler");
+    i(this, "lastUpdate", Date.now());
     /**
      * @internal
      * Flag to indicate if batching is enabled for this bloc
      */
-    n(this, "_batchingEnabled", !1);
-    /**
-     * @internal
-     * Pending state updates when batching is enabled
-     */
-    n(this, "_pendingUpdates", []);
+    i(this, "_batchingEnabled", !1);
     /**
      * @internal
      * Updates the state and notifies all observers of the change.
@@ -539,17 +587,17 @@ class g {
      * @param oldState The previous state for comparison
      * @param action Optional metadata about what caused the state change
      */
-    n(this, "_pushState", (e, t, s) => {
+    i(this, "_pushState", (e, t, s) => {
       if (e === void 0) {
         console.warn("BlocBase._pushState: newState is undefined", this);
         return;
       }
-      if (s != null) {
-        const i = typeof s;
-        ["string", "object", "number"].includes(i) || console.warn("BlocBase._pushState: Invalid action type", this, s);
+      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._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();
@@ -558,21 +606,22 @@ class g {
      * Enables batching for multiple state updates
      * @param batchFn Function to execute with batching enabled
      */
-    n(this, "batch", (e) => {
-      const t = this._batchingEnabled;
-      this._batchingEnabled = !0;
+    i(this, "batch", (e) => {
+      if (this._batchingLock)
+        return e();
+      this._batchingLock = !0, this._batchingEnabled = !0, this._pendingUpdates = [];
       try {
-        const s = e();
+        const t = e();
         if (this._pendingUpdates.length > 0) {
-          const i = this._pendingUpdates[this._pendingUpdates.length - 1];
-          this._oldState = this._pendingUpdates[0].oldState, this._state = i.newState, this._observer.notify(i.newState, this._oldState, i.action), this.lastUpdate = Date.now(), this._pendingUpdates = [];
+          const s = this._pendingUpdates[this._pendingUpdates.length - 1];
+          this._observer.notify(s.newState, s.oldState, s.action), this.lastUpdate = Date.now();
         }
-        return s;
+        return t;
       } finally {
-        this._batchingEnabled = t;
+        this._batchingEnabled = !1, this._batchingLock = !1, this._pendingUpdates = [];
       }
     });
-    this._state = e, this._observer = new m(this), this._id = this.constructor.name;
+    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;
   }
@@ -603,7 +652,7 @@ class g {
    */
   _dispose() {
     var e;
-    this._consumers.clear(), this._observer.clear(), (e = this.onDispose) == null || e.call(this);
+    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");
   }
   /**
    * @internal
@@ -617,9 +666,7 @@ class g {
    * Schedules disposal of this bloc instance if it has no consumers
    */
   _scheduleDisposal() {
-    setTimeout(() => {
-      this._consumers.size === 0 && !this._keepAlive && (this._disposalHandler ? this._disposalHandler(this) : this._dispose());
-    }, 0);
+    this._disposalState === "active" && this._consumers.size === 0 && !this._keepAlive && (this._disposalHandler ? this._disposalHandler(this) : this._dispose());
   }
 }
 /**
@@ -627,49 +674,36 @@ class g {
  * Use this when state should not be shared between components.
  * @default false
  */
-n(g, "isolated", !1), /**
+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
  */
-n(g, "keepAlive", !1);
-class A extends g {
+i(B, "keepAlive", !1);
+class b extends B {
   constructor() {
     super(...arguments);
     // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
     // The handler's event parameter will be correctly typed to the specific EventConstructor
     // by the 'on' method's signature.
-    n(this, "eventHandlers", /* @__PURE__ */ new Map());
+    i(this, "eventHandlers", /* @__PURE__ */ new Map());
+    /**
+     * @internal
+     * Event queue to ensure sequential processing of async events
+     */
+    i(this, "_eventQueue", []);
+    /**
+     * @internal
+     * Flag indicating if an event is currently being processed
+     */
+    i(this, "_isProcessingEvent", !1);
     /**
      * Dispatches an action/event to the Bloc.
-     * If a handler is registered for this specific event type (via 'on'), it will be invoked.
-     * Asynchronous handlers are awaited.
+     * Events are queued and processed sequentially to prevent race conditions.
      * @param action The action/event instance to be processed.
      */
-    n(this, "add", async (t) => {
-      const s = t.constructor, i = this.eventHandlers.get(s);
-      if (i) {
-        const a = (o) => {
-          const c = this.state;
-          this._pushState(o, c, t);
-        };
-        try {
-          await i(t, a);
-        } catch (o) {
-          h.error(
-            `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${s.name}':`,
-            o,
-            "Action:",
-            t
-          );
-        }
-      } else {
-        const a = t.constructor.name || "UnnamedConstructor";
-        h.warn(
-          `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${a}'. Action was:`,
-          t
-        );
-      }
+    i(this, "add", async (t) => {
+      this._eventQueue.push(t), this._isProcessingEvent || await this._processEventQueue();
     });
   }
   /**
@@ -680,15 +714,73 @@ class A extends g {
    *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
    */
   on(t, s) {
-    this.eventHandlers.has(t) && h.warn(
+    this.eventHandlers.has(t) && l.warn(
       `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
       t,
       s
     );
   }
+  /**
+   * @internal
+   * Processes events from the queue sequentially
+   */
+  async _processEventQueue() {
+    if (!this._isProcessingEvent) {
+      this._isProcessingEvent = !0;
+      try {
+        for (; this._eventQueue.length > 0; ) {
+          const t = this._eventQueue.shift();
+          await this._processEvent(t);
+        }
+      } finally {
+        this._isProcessingEvent = !1;
+      }
+    }
+  }
+  /**
+   * @internal
+   * 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);
+      };
+      try {
+        await n(t, o);
+      } catch (a) {
+        const r = t.constructor.name || "UnnamedConstructor", h = {
+          blocName: this._name,
+          blocId: String(this._id),
+          eventType: r,
+          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}':`,
+          a,
+          "Context:",
+          h
+        ), 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}'.`,
+        "Registered handlers:",
+        Array.from(this.eventHandlers.keys()).map((a) => a.name),
+        "Action was:",
+        t
+      );
+    }
+  }
 }
-class M extends g {
+class k extends B {
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),
@@ -711,7 +803,7 @@ class M extends g {
    */
   patch(e, t = !1) {
     if (typeof this.state != "object" || this.state === null) {
-      h.warn(
+      l.warn(
         "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
       );
       return;
@@ -720,10 +812,10 @@ class M extends g {
     if (t)
       s = !0;
     else
-      for (const i in e)
-        if (Object.prototype.hasOwnProperty.call(e, i)) {
-          const o = this.state[i];
-          if (!Object.is(e[i], o)) {
+      for (const n in e)
+        if (Object.prototype.hasOwnProperty.call(e, n)) {
+          const a = this.state[n];
+          if (!Object.is(e[n], a)) {
             s = !0;
             break;
           }
@@ -734,12 +826,160 @@ class M extends g {
     });
   }
 }
+class x {
+  /**
+   * Sets up a clean test environment
+   */
+  static setUp() {
+    this.originalInstance = l.instance, l.resetInstance(), l.enableLog = !1;
+  }
+  /**
+   * Tears down the test environment and restores original state
+   */
+  static tearDown() {
+    l.resetInstance();
+  }
+  /**
+   * Creates a test bloc with automatic cleanup
+   */
+  static createBloc(e, ...t) {
+    const s = new e(...t);
+    return l.activateBloc(s), s;
+  }
+  /**
+   * Waits for a bloc to emit a specific state
+   */
+  static async waitForState(e, t, s = 5e3) {
+    return new Promise((n, o) => {
+      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));
+        }
+      });
+      t(e.state) && (clearTimeout(a), r(), n(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({
+        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)}`
+                ));
+                return;
+              }
+            }
+            o();
+          }
+        }
+      });
+    });
+  }
+}
+i(x, "originalInstance");
+class A extends b {
+  constructor(t) {
+    super(t);
+    i(this, "mockHandlers", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Mock an event handler for testing
+   */
+  mockEventHandler(t, s) {
+    this.on(t, s);
+  }
+  /**
+   * Get the number of registered handlers
+   */
+  getHandlerCount() {
+    return this.eventHandlers.size;
+  }
+  /**
+   * Check if a handler is registered for an event type
+   */
+  hasHandler(t) {
+    return this.eventHandlers.has(t);
+  }
+}
+class E extends k {
+  constructor(t) {
+    super(t);
+    i(this, "stateHistory", []);
+    this.stateHistory.push(t);
+  }
+  /**
+   * Override emit to track state history
+   */
+  emit(t) {
+    this.stateHistory.push(t), super.emit(t);
+  }
+  /**
+   * Get the history of all states
+   */
+  getStateHistory() {
+    return [...this.stateHistory];
+  }
+  /**
+   * Clear state history
+   */
+  clearStateHistory() {
+    this.stateHistory = [this.state];
+  }
+}
+class R {
+  constructor() {
+    i(this, "initialStats");
+    this.initialStats = l.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 = `
+Memory Leak Detection Report:
+- Initial registered blocs: ${this.initialStats.registeredBlocs}
+- Current registered blocs: ${e.registeredBlocs}
+- Initial isolated blocs: ${this.initialStats.isolatedBlocs}  
+- Current isolated blocs: ${e.isolatedBlocs}
+- Initial keep-alive blocs: ${this.initialStats.keepAliveBlocs}
+- Current keep-alive blocs: ${e.keepAliveBlocs}
+- Potential leaks detected: ${t ? "YES" : "NO"}
+    `.trim();
+    return {
+      hasLeaks: t,
+      report: s,
+      stats: e
+    };
+  }
+}
 export {
-  h as Blac,
-  m as BlacObservable,
-  A as Bloc,
-  g as BlocBase,
-  M as Cubit,
-  b as setBlacInstanceManager
+  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
 };
 //# sourceMappingURL=index.es.js.map