@yoltra/core 0.1.0 → 0.3.0

package/dist/yoltra.esm.js

@@ -1,19 +1,22 @@
 /*!
- * @yoltra/core v0.1.0
+ * @yoltra/core v0.3.0
  * (c) 2026 Manu Ramirez <@pixerael>
  * License: MIT
  * Homepage: https://yoltra.dev
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree
  */
-var M = Object.defineProperty;
-var P = (a, e, t) => e in a ? M(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
-var u = (a, e, t) => P(a, typeof e != "symbol" ? e + "" : e, t);
-class z {
+var P = Object.defineProperty;
+var z = (a, e, t) => e in a ? P(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var d = (a, e, t) => z(a, typeof e != "symbol" ? e + "" : e, t);
+class O {
   constructor() {
     /**
      * Internal registry: `channel → type → Set<handler>`.
      * @internal
      */
-    u(this, "handlers", /* @__PURE__ */ new Map());
+    d(this, "handlers", /* @__PURE__ */ new Map());
   }
   /**
    * Subscribes a handler to an exact `(channel, type)`.
@@ -37,11 +40,11 @@ class z {
    *
    * @public
    */
-  on(e, t, s) {
+  on(e, t, r) {
     let n = this.handlers.get(e);
     n || (n = /* @__PURE__ */ new Map(), this.handlers.set(e, n));
-    let r = n.get(t);
-    return r || (r = /* @__PURE__ */ new Set(), n.set(t, r)), r.add(s), () => this.off(e, t, s);
+    let s = n.get(t);
+    return s || (s = /* @__PURE__ */ new Set(), n.set(t, s)), s.add(r), () => this.off(e, t, r);
   }
   /**
    * Removes a specific handler previously added with {@link EventBus.on | `on`}.
@@ -63,11 +66,11 @@ class z {
    *
    * @public
    */
-  off(e, t, s) {
+  off(e, t, r) {
     const n = this.handlers.get(e);
     if (!n) return;
-    const r = n.get(t);
-    r && (r.delete(s), r.size === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e));
+    const s = n.get(t);
+    s && (s.delete(r), s.size === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e));
   }
   /**
    * Emits an event to all subscribers of the exact `(channel, type)`.
@@ -88,14 +91,14 @@ class z {
    *
    * @public
    */
-  emit(e, t, s) {
+  emit(e, t, r) {
     const n = this.handlers.get(e);
     if (!n) return;
-    const r = n.get(t);
-    if (!(!r || r.size === 0))
-      for (const o of [...r])
+    const s = n.get(t);
+    if (!(!s || s.size === 0))
+      for (const c of [...s])
         try {
-          o(s);
+          c(r);
         } catch (i) {
           console.error("EventBus handler error:", i);
         }
@@ -123,12 +126,12 @@ class k {
      * Exact handlers: `channel → type → [handlers]`.
      * @internal
      */
-    u(this, "handlers", /* @__PURE__ */ new Map());
+    d(this, "handlers", /* @__PURE__ */ new Map());
     /**
      * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
      * @internal
      */
-    u(this, "patternHandlers", /* @__PURE__ */ new Map());
+    d(this, "patternHandlers", /* @__PURE__ */ new Map());
   }
   /**
    * Subscribes a handler to either an **exact** type or a **pattern**.
@@ -162,18 +165,18 @@ class k {
    *
    * @public
    */
-  on(e, t, s) {
+  on(e, t, r) {
     const n = String(t);
     if (this.isPattern(n)) {
-      const r = n;
+      const s = n;
       this.patternHandlers.has(e) || this.patternHandlers.set(e, /* @__PURE__ */ new Map());
-      const o = this.patternHandlers.get(e);
-      return o.has(r) || o.set(r, []), o.get(r).push(s), () => this.offPattern(e, r, s);
+      const c = this.patternHandlers.get(e);
+      return c.has(s) || c.set(s, []), c.get(s).push(r), () => this.offPattern(e, s, r);
     } else {
-      const r = this.normalizeTypeKey(n);
+      const s = this.normalizeTypeKey(n);
       this.handlers.has(e) || this.handlers.set(e, /* @__PURE__ */ new Map());
-      const o = this.handlers.get(e);
-      return o.has(r) || o.set(r, []), o.get(r).push(s), () => this.offExactNormalized(e, r, s);
+      const c = this.handlers.get(e);
+      return c.has(s) || c.set(s, []), c.get(s).push(r), () => this.offExactNormalized(e, s, r);
     }
   }
   /**
@@ -194,9 +197,9 @@ class k {
    *
    * @public
    */
-  off(e, t, s) {
+  off(e, t, r) {
     const n = this.normalizeTypeKey(String(t));
-    this.offExactNormalized(e, n, s);
+    this.offExactNormalized(e, n, r);
   }
   /**
    * Internal exact unsubscription using an already **normalized** type key.
@@ -206,13 +209,13 @@ class k {
    * @param handler - Handler to remove.
    * @internal
    */
-  offExactNormalized(e, t, s) {
+  offExactNormalized(e, t, r) {
     const n = this.handlers.get(e);
     if (!n) return;
-    const r = n.get(t);
-    if (!r) return;
-    const o = r.indexOf(s);
-    o !== -1 && r.splice(o, 1), r.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
+    const s = n.get(t);
+    if (!s) return;
+    const c = s.indexOf(r);
+    c !== -1 && s.splice(c, 1), s.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
   }
   /**
    * Internal removal for a **pattern** subscription. No-ops if missing.
@@ -222,13 +225,13 @@ class k {
    * @param handler - Handler to remove.
    * @internal
    */
-  offPattern(e, t, s) {
+  offPattern(e, t, r) {
     const n = this.patternHandlers.get(e);
     if (!n) return;
-    const r = n.get(t);
-    if (!r) return;
-    const o = r.indexOf(s);
-    o !== -1 && r.splice(o, 1), r.length === 0 && n.delete(t), n.size === 0 && this.patternHandlers.delete(e);
+    const s = n.get(t);
+    if (!s) return;
+    const c = s.indexOf(r);
+    c !== -1 && s.splice(c, 1), s.length === 0 && n.delete(t), n.size === 0 && this.patternHandlers.delete(e);
   }
   /**
    * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
@@ -250,27 +253,27 @@ class k {
    *
    * @public
    */
-  emit(e, t, s) {
-    const n = String(t), r = this.normalizeTypeKey(n), o = this.handlers.get(e)?.get(r) ?? [], i = this.patternHandlers.get(e), c = [];
+  emit(e, t, r) {
+    const n = String(t), s = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(s) ?? [], i = this.patternHandlers.get(e), o = [];
     if (i && i.size) {
       const l = this.normalizeTypeKey(n);
-      for (const [p, d] of i.entries())
-        this.matchPattern(p, l) && c.push(d);
+      for (const [u, p] of i.entries())
+        this.matchPattern(u, l) && o.push(p);
     }
     const f = /* @__PURE__ */ new Set(), h = (l) => {
-      for (const p of [...l])
-        if (!f.has(p)) {
-          f.add(p);
+      for (const u of [...l])
+        if (!f.has(u)) {
+          f.add(u);
           try {
-            p(s);
-          } catch (d) {
-            console.error(d);
+            u(r);
+          } catch (p) {
+            console.error(p);
             continue;
           }
         }
     };
-    h(o);
-    for (const l of c) h(l);
+    h(c);
+    for (const l of o) h(l);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -328,29 +331,19 @@ class k {
    * @internal
    */
   matchPattern(e, t) {
-    const s = this.splitPath(e), n = this.splitPath(t);
-    let r = 0, o = 0;
-    for (; r < s.length && o < n.length; ) {
-      const i = s[r];
-      if (i === "**") {
-        if (r === s.length - 1 || s.slice(r).filter((f) => f !== "**").length === 0) return !0;
-        for (let f = o; f <= n.length; f++)
-          if (this.matchPattern(s.slice(r + 1).join("."), n.slice(f).join(".")))
-            return !0;
+    const r = this.splitPath(e), n = this.splitPath(t);
+    let s = 0, c = 0, i = -1, o = 0;
+    for (; c < n.length; )
+      if (s < r.length && (r[s] === "*" || r[s] === n[c]))
+        s++, c++;
+      else if (s < r.length && r[s] === "**")
+        i = s, o = c, s++;
+      else if (i !== -1)
+        s = i + 1, c = ++o;
+      else
         return !1;
-      }
-      if (i === "*" || i === n[o]) {
-        r++, o++;
-        continue;
-      }
-      return !1;
-    }
-    if (o === n.length) {
-      for (; r < s.length; r++)
-        if (s[r] !== "**") return !1;
-      return !0;
-    }
-    return !1;
+    for (; s < r.length && r[s] === "**"; ) s++;
+    return s === r.length;
   }
   /**
    * Removes **all** listeners (exact and pattern). Useful for tests/HMR teardown.
@@ -375,12 +368,12 @@ class k {
    */
   __introspect() {
     const e = [];
-    for (const [t, s] of this.handlers)
-      for (const [n, r] of s)
-        r.length > 0 && e.push({ channel: t, type: n, count: r.length });
-    for (const [t, s] of this.patternHandlers)
-      for (const [n, r] of s)
-        r.length > 0 && e.push({ channel: t, type: n, count: r.length });
+    for (const [t, r] of this.handlers)
+      for (const [n, s] of r)
+        s.length > 0 && e.push({ channel: t, type: n, count: s.length });
+    for (const [t, r] of this.patternHandlers)
+      for (const [n, s] of r)
+        s.length > 0 && e.push({ channel: t, type: n, count: s.length });
     return e;
   }
 }
@@ -405,7 +398,7 @@ class _ {
      * The underlying pure reducer function.
      * @internal
      */
-    u(this, "_reduce");
+    d(this, "_reduce");
     this._reduce = e;
   }
   /**
@@ -426,67 +419,67 @@ class _ {
     return this._reduce(e, t);
   }
 }
-function b(a, e, t = "", s = /* @__PURE__ */ new WeakMap()) {
+function g(a, e, t = "", r = /* @__PURE__ */ new Map()) {
   if (a === e) return [];
   if (typeof a != "object" || typeof e != "object" || a === null || e === null)
-    return [t];
+    return typeof a == "number" && Number.isNaN(a) && Number.isNaN(e) ? [] : [t];
   if (a instanceof Date && e instanceof Date)
     return a.getTime() === e.getTime() ? [] : [t];
   if (a instanceof RegExp && e instanceof RegExp)
     return a.source === e.source && e.flags === a.flags ? [] : [t];
-  const n = a, r = e;
-  let o = s.get(n);
-  if (o) {
-    if (o.has(r)) return [];
-    o.add(r);
-  } else
-    o = /* @__PURE__ */ new WeakSet(), o.add(r), s.set(n, o);
-  const i = Array.isArray(a), c = Array.isArray(e);
-  if (i !== c) return [t];
-  const f = [];
-  if (i) {
-    const d = a, m = e;
-    if (d.length !== m.length) return [t];
-    for (let y = 0; y < d.length; y++) {
-      const g = t ? `${t}.${y}` : `${y}`, E = b(d[y], m[y], g, s);
-      f.push(...E);
-    }
-    return f.filter(Boolean);
-  }
-  const h = Object.keys(a), l = Object.keys(e), p = /* @__PURE__ */ new Set([...h, ...l]);
-  for (const d of p) {
-    const m = t ? `${t}.${d}` : d, y = Object.prototype.hasOwnProperty.call(a, d), g = Object.prototype.hasOwnProperty.call(e, d);
-    if (!y) {
-      f.push(m);
-      continue;
+  const n = a, s = e, c = r.get(n);
+  if (c?.has(s)) return [];
+  const i = c ?? /* @__PURE__ */ new Set();
+  i.add(s), c || r.set(n, i);
+  try {
+    const o = Array.isArray(a), f = Array.isArray(e);
+    if (o !== f) return [t];
+    const h = [];
+    if (o) {
+      const u = a, p = e;
+      if (u.length !== p.length) return [t];
+      for (let y = 0; y < u.length; y++) {
+        const m = t ? `${t}.${y}` : `${y}`;
+        h.push(...g(u[y], p[y], m, r));
+      }
+      return h.filter(Boolean);
     }
-    if (!g) {
-      f.push(m);
-      continue;
+    const l = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(e)]);
+    for (const u of l) {
+      const p = t ? `${t}.${u}` : u, y = Object.prototype.hasOwnProperty.call(a, u), m = Object.prototype.hasOwnProperty.call(e, u);
+      if (!y || !m) {
+        h.push(p);
+        continue;
+      }
+      h.push(...g(a[u], e[u], p, r));
     }
-    const E = b(a[d], e[d], m, s);
-    f.push(...E);
+    return h.filter(Boolean);
+  } finally {
+    i.delete(s), i.size === 0 && r.delete(n);
   }
-  return f.filter(Boolean);
 }
-function w(a, e = /* @__PURE__ */ new WeakSet()) {
+function E(a, e = /* @__PURE__ */ new WeakSet()) {
   if (a === null || typeof a != "object" || e.has(a) || Object.isFrozen(a)) return a;
   if (e.add(a), Array.isArray(a)) {
     const t = a;
-    for (let s = 0; s < t.length; s++)
-      t[s] = w(t[s], e);
+    for (let r = 0; r < t.length; r++)
+      t[r] = E(t[r], e);
     return Object.freeze(t);
   }
   for (const t of Object.getOwnPropertyNames(a)) {
-    const s = Object.getOwnPropertyDescriptor(a, t);
-    !s || !("value" in s) || (a[t] = w(a[t], e));
+    const r = Object.getOwnPropertyDescriptor(a, t);
+    !r || !("value" in r) || (a[t] = E(a[t], e));
   }
   for (const t of Object.getOwnPropertySymbols(a)) {
-    const s = Object.getOwnPropertyDescriptor(a, t);
-    !s || !("value" in s) || (a[t] = w(a[t], e));
+    const r = Object.getOwnPropertyDescriptor(a, t);
+    !r || !("value" in r) || (a[t] = E(a[t], e));
   }
   return Object.freeze(a);
 }
+function b(a) {
+  return process.env.NODE_ENV === "production" ? a : E(a);
+}
+const w = 100, S = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
 class v {
   /**
    * Creates a store from a {@link StoreSpec}.
@@ -501,7 +494,7 @@ class v {
      *
      * @public
      */
-    u(this, "name");
+    d(this, "name");
     /**
      * Registered middleware pipeline (run **before** reducers).
      * Stores either raw functions (legacy) or MiddlewareSpec objects.
@@ -509,45 +502,45 @@ class v {
      *
      * @internal
      */
-    u(this, "middleware");
+    d(this, "middleware");
     /**
      * Installed slice reducers keyed by slice name.
      *
      * @internal
      */
-    u(this, "reducers");
+    d(this, "reducers");
     /**
      * Current immutable snapshot of the store state.
      * This reference changes whenever any slice changes (shallow immutability).
      *
      * @internal
      */
-    u(this, "state");
+    d(this, "state");
     /**
      * Bus for reducer wiring (emit by `(channel, type)`).
      *
      * @internal
      */
-    u(this, "reducerBus");
+    d(this, "reducerBus");
     /**
      * Bus for **granular** connector events (emit by **dotted path** inside a slice).
      *
      * @internal
      */
-    u(this, "connectorBus");
+    d(this, "connectorBus");
     /**
      * Coarse-grained listeners (called once per committed event, only if state changed).
      *
      * @internal
      */
-    u(this, "listeners", /* @__PURE__ */ new Set());
+    d(this, "listeners", /* @__PURE__ */ new Set());
     /**
      * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
      * Used for effects with explicit `keys` or legacy `events` targeting.
      *
      * @internal
      */
-    u(this, "effects", /* @__PURE__ */ new Map());
+    d(this, "effects", /* @__PURE__ */ new Map());
     /**
      * Pattern-based effects that need runtime matching.
      * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
@@ -555,34 +548,34 @@ class v {
      *
      * @internal
      */
-    u(this, "patternEffects", /* @__PURE__ */ new Set());
+    d(this, "patternEffects", /* @__PURE__ */ new Set());
     /**
      * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
      * Notified after reducers, before effects, for events that passed middleware.
      *
      * @internal
      */
-    u(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
+    d(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
      * Notified when middleware rejects an event.
      *
      * @internal
      */
-    u(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
+    d(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
      * Notified for both committed and uncommitted events with phase parameter.
      *
      * @internal
      */
-    u(this, "allEventSubscribers", /* @__PURE__ */ new Map());
+    d(this, "allEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * Track reducerBus unsubs per slice for HMR/register/unregister.
      *
      * @internal
      */
-    u(this, "sliceUnsubs", /* @__PURE__ */ new Map());
+    d(this, "sliceUnsubs", /* @__PURE__ */ new Map());
     /**
      * Pattern-based reducers that need runtime matching.
      * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
@@ -590,26 +583,54 @@ class v {
      *
      * @internal
      */
-    u(this, "patternReducers", /* @__PURE__ */ new Map());
+    d(this, "patternReducers", /* @__PURE__ */ new Map());
     /**
      * Whether `__replayEvents()` is allowed.
      * Set from `spec.devtools.allowReplay`.
      *
      * @internal
      */
-    u(this, "replayEnabled");
+    d(this, "replayEnabled");
     /**
-     * FIFO event queue for serialized emission.
+     * Optional hook invoked when an effect throws/rejects. See
+     * {@link StoreSpec.onEffectError}. `await emit()` never rejects on effect
+     * failure — this is how callers observe effect errors.
+     */
+    d(this, "onEffectError");
+    /**
+     * Pending events awaiting the **synchronous** reduce phase (middleware +
+     * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
      *
      * @internal
      */
-    u(this, "eventQueue", []);
+    d(this, "reduceQueue", []);
     /**
-     * Re-entrancy guard while draining the queue.
+     * Re-entrancy guard for the synchronous reduce phase.
      *
      * @internal
      */
-    u(this, "isProcessingQueue", !1);
+    d(this, "isReducing", !1);
+    /**
+     * Registered instrumentation observers (DevTools seam). See {@link instrument}.
+     *
+     * @internal
+     */
+    d(this, "instrumentObservers", /* @__PURE__ */ new Set());
+    /**
+     * Scratch array collecting slice-prefixed changed leaf paths during an
+     * instrumented reduce. Set by {@link drainReduce} while observers are active;
+     * appended to by {@link forwardEvent}. `null` when not instrumenting.
+     *
+     * @internal
+     */
+    d(this, "changedPathSink", null);
+    /**
+     * Count of effect tasks currently in flight; surfaced as queue depth by
+     * {@link __devtoolsIntrospect}.
+     *
+     * @internal
+     */
+    d(this, "inFlightEffects", 0);
     /**
      * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
      *
@@ -626,31 +647,44 @@ class v {
      *
      * @internal
      */
-    u(this, "processedEvents", /* @__PURE__ */ new Map());
+    d(this, "processedEvents", /* @__PURE__ */ new Map());
+    /**
+     * Lifetime count of events suppressed by the deduplication cache.
+     * Exposed via {@link __devtoolsIntrospect} so the DevTools agent can
+     * surface it in the STORE_METRICS response without further core changes.
+     *
+     * @internal
+     */
+    d(this, "dedupCount", 0);
+    /**
+     * Store-owned metadata for registered effects, keyed by the effect function.
+     * Kept **off** the caller's function object: mutating a user-owned function
+     * (the old `fn.__quoMeta`) bled metadata across stores that share a handler
+     * and left it attached after unregister. Cleared on {@link dispose}.
+     *
+     * @internal
+     */
+    d(this, "effectMeta", /* @__PURE__ */ new WeakMap());
     /**
      * Configuration for event deduplication.
      * @internal
      */
-    u(this, "dedupConfig");
+    d(this, "dedupConfig");
     /**
      * Timer for periodic cleanup of processed events.
      *
      * @internal
      */
-    u(this, "eventCleanupTimer", null);
-    this.name = e.name ?? "yoltra Store", this.reducerBus = new z(), this.connectorBus = new k(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1;
-    const t = process.env.NODE_ENV === "production" ? 100 : 50;
-    if (this.dedupConfig = {
-      windowMs: e.dedupWindowMs ?? t,
+    d(this, "eventCleanupTimer", null);
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new O(), this.connectorBus = new k(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.onEffectError = e.onEffectError, this.dedupConfig = {
+      windowMs: e.dedupWindowMs ?? 0,
       maxCacheSize: 1e3
-    }, Object.entries(e.reducer).forEach(([s, n]) => {
-      this.mountSlice(s, n, { preserveState: !1 });
+    }, Object.entries(e.reducer).forEach(([t, r]) => {
+      this.mountSlice(t, r, { preserveState: !1 });
     }), e.effects?.length)
-      for (const s of e.effects)
-        this.registerEffect(s);
-    this.eventCleanupTimer = setInterval(() => {
-      this.pruneProcessedEvents(Date.now());
-    }, 5e3), this.dispose = this.dispose.bind(this), this.notifyEffects = this.notifyEffects.bind(this), this.forwardEvent = this.forwardEvent.bind(this), this.__applyExternalState = this.__applyExternalState.bind(this), this.__replayEvents = this.__replayEvents.bind(this), this.__devtoolsIntrospect = this.__devtoolsIntrospect.bind(this), this.mountSlice = this.mountSlice.bind(this), this.unmountSlice = this.unmountSlice.bind(this), this.getAtPath = this.getAtPath.bind(this), this.emit = this.emit.bind(this), this.subscribe = this.subscribe.bind(this), this.connect = this.connect.bind(this), this.onEffect = this.onEffect.bind(this), this.onEvent = this.onEvent.bind(this), this.getState = this.getState.bind(this), this.registerEffect = this.registerEffect.bind(this), this.registerMiddleware = this.registerMiddleware.bind(this), this.registerReducer = this.registerReducer.bind(this), this.replaceMiddleware = this.replaceMiddleware.bind(this), this.replaceEffects = this.replaceEffects.bind(this), this.replaceReducers = this.replaceReducers.bind(this), this.hotReplace = this.hotReplace.bind(this);
+      for (const t of e.effects)
+        this.registerEffect(t);
+    this.dispose = this.dispose.bind(this), this.notifyEffects = this.notifyEffects.bind(this), this.forwardEvent = this.forwardEvent.bind(this), this.__applyExternalState = this.__applyExternalState.bind(this), this.__replayEvents = this.__replayEvents.bind(this), this.__devtoolsIntrospect = this.__devtoolsIntrospect.bind(this), this.mountSlice = this.mountSlice.bind(this), this.unmountSlice = this.unmountSlice.bind(this), this.getAtPath = this.getAtPath.bind(this), this.emit = this.emit.bind(this), this.subscribe = this.subscribe.bind(this), this.connect = this.connect.bind(this), this.onEffect = this.onEffect.bind(this), this.onEvent = this.onEvent.bind(this), this.getState = this.getState.bind(this), this.registerEffect = this.registerEffect.bind(this), this.registerMiddleware = this.registerMiddleware.bind(this), this.registerReducer = this.registerReducer.bind(this), this.replaceMiddleware = this.replaceMiddleware.bind(this), this.replaceEffects = this.replaceEffects.bind(this), this.replaceReducers = this.replaceReducers.bind(this), this.hotReplace = this.hotReplace.bind(this);
   }
   /**
    * Cleanup resources (timers, etc.) when disposing the store.
@@ -666,7 +700,7 @@ class v {
    * @public
    */
   dispose() {
-    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear();
+    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.allEventSubscribers.clear(), this.instrumentObservers.clear(), this.connectorBus.clear(), this.reducerBus.clear(), this.patternReducers.clear(), this.sliceUnsubs.clear(), this.changedPathSink = null;
   }
   /**
    * Generates a fingerprint for an event for deduplication purposes.
@@ -679,15 +713,15 @@ class v {
    *
    * @internal
    */
-  fingerprint(e, t, s) {
+  fingerprint(e, t, r) {
     const n = `${e}::${t}`;
     try {
-      if (s == null)
+      if (r == null)
         return `${n}::null`;
-      if (typeof s != "object")
-        return `${n}::${String(s)}`;
-      const r = JSON.stringify(s);
-      return `${n}::${r}`;
+      if (typeof r != "object")
+        return `${n}::${String(r)}`;
+      const s = JSON.stringify(r);
+      return `${n}::${s}`;
     } catch {
       return `${n}::${Date.now()}::${Math.random()}`;
     }
@@ -701,9 +735,21 @@ class v {
    *
    * @internal
    */
-  shouldDedupe(e) {
-    const t = Date.now(), s = this.processedEvents.get(e);
-    return s !== void 0 && t - s < this.dedupConfig.windowMs ? !0 : (this.processedEvents.set(e, t), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(t), !1);
+  shouldDedupe(e, t) {
+    const r = Date.now(), n = this.processedEvents.get(e);
+    return n !== void 0 && r - n < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, r), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(r), !1);
+  }
+  /**
+   * Starts the periodic prune interval if it isn't already running. Called when
+   * the first entry is cached so the timer's lifetime tracks actual dedup use
+   * (content window or identity `dedupKey`), independent of `dedupWindowMs`.
+   *
+   * @internal
+   */
+  ensureCleanupTimer() {
+    this.eventCleanupTimer === null && (this.eventCleanupTimer = setInterval(() => {
+      this.pruneProcessedEvents(Date.now());
+    }, 5e3), this.eventCleanupTimer.unref?.());
   }
   /**
    * Removes expired entries from the processed events cache.
@@ -713,9 +759,10 @@ class v {
    * @internal
    */
   pruneProcessedEvents(e) {
-    const t = e - this.dedupConfig.windowMs * 2;
-    for (const [s, n] of this.processedEvents)
-      n < t && this.processedEvents.delete(s);
+    const t = Math.max(this.dedupConfig.windowMs, w), r = e - t * 2;
+    for (const [n, s] of this.processedEvents)
+      s < r && this.processedEvents.delete(n);
+    this.processedEvents.size === 0 && this.eventCleanupTimer !== null && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null);
   }
   /**
    * Checks if an event matches a `When` matcher.
@@ -735,7 +782,7 @@ class v {
    */
   matchesWhen(e, t) {
     return !e || "any" in e && e.any === !0 ? !0 : "keys" in e ? e.keys.some(
-      ([s, n]) => t.channel === s && t.type === n
+      ([r, n]) => t.channel === r && t.type === n
     ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
   }
   /**
@@ -771,20 +818,20 @@ class v {
    * @internal
    */
   async notifyEffects(e) {
-    const t = `${String(e.channel)}::${String(e.type)}`, s = this.effects.get(t);
-    if (s && s.size > 0)
-      for (const n of [...s])
+    const t = `${String(e.channel)}::${String(e.type)}`, r = this.effects.get(t);
+    if (r && r.size > 0)
+      for (const n of [...r])
         try {
           await n(e, this.getState, this.emit);
-        } catch (r) {
-          console.error("Effect error:", r);
+        } catch (s) {
+          console.error("Effect error:", s), this.onEffectError?.(s, e);
         }
-    for (const { effect: n, when: r } of this.patternEffects)
-      if (this.matchesWhen(r, e))
+    for (const { effect: n, when: s } of this.patternEffects)
+      if (this.matchesWhen(s, e))
         try {
           await n(e, this.getState, this.emit);
-        } catch (o) {
-          console.error("Effect error:", o);
+        } catch (c) {
+          console.error("Effect error:", c), this.onEffectError?.(c, e);
         }
   }
   /**
@@ -797,23 +844,28 @@ class v {
    * @param phase - The phase ('committed' or 'uncommitted').
    * @internal
    */
-  async notifyEventSubscribers(e, t) {
-    const s = `${String(e.channel)}::${String(e.type)}`, r = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(s);
-    if (r?.size)
-      for (const i of [...r])
-        try {
-          await i(e, this.getState, this.emit, t);
-        } catch (c) {
-          console.error("Event subscription error:", c);
-        }
-    const o = this.allEventSubscribers.get(s);
-    if (o?.size)
-      for (const i of [...o])
-        try {
-          await i(e, this.getState, this.emit, t);
-        } catch (c) {
-          console.error("Event subscription error:", c);
-        }
+  notifyEventSubscribers(e, t) {
+    const r = `${String(e.channel)}::${String(e.type)}`, s = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(r);
+    if (s?.size)
+      for (const i of [...s]) this.invokeEventSubscriber(i, e, t);
+    const c = this.allEventSubscribers.get(r);
+    if (c?.size)
+      for (const i of [...c]) this.invokeEventSubscriber(i, e, t);
+  }
+  /**
+   * Invokes a single event-subscription handler **fire-and-forget**: synchronous
+   * throws and async rejections are logged but never block the emit pipeline.
+   * Event subscribers are notifications, not part of the committed reduce result.
+   *
+   * @internal
+   */
+  invokeEventSubscriber(e, t, r) {
+    try {
+      const n = e(t, this.getState, this.emit, r);
+      n && typeof n.then == "function" && n.catch((s) => console.error("Event subscription error:", s));
+    } catch (n) {
+      console.error("Event subscription error:", n);
+    }
   }
   /**
    * Applies a reduced event to a slice and emits **precise** connector events.
@@ -832,18 +884,20 @@ class v {
    * @internal
    */
   forwardEvent(e, t) {
-    const s = this.state[e], n = this.reducers[e].reduce(s, t);
-    if (s === n) return !1;
-    const r = b(s, n).filter(Boolean);
-    if (r.length === 0) return !1;
-    const o = w(structuredClone(n));
-    this.state = { ...this.state, [e]: o };
+    const r = this.state[e], n = this.reducers[e].reduce(r, t);
+    if (r === n) return !1;
+    const s = g(r, n).filter(Boolean);
+    if (s.length === 0) return !1;
+    const c = b(n);
+    if (this.state = { ...this.state, [e]: c }, this.changedPathSink)
+      for (const o of s)
+        this.changedPathSink.push(o ? `${e}.${o}` : e);
     const i = /* @__PURE__ */ new Set();
-    for (const c of r)
-      for (const f of v.buildAncestorPaths(c)) i.add(f);
-    for (const c of i) {
-      const f = this.getAtPath(s, c), h = this.getAtPath(o, c);
-      this.connectorBus.emit(e, c, { oldValue: f, newValue: h, path: c });
+    for (const o of s)
+      for (const f of v.buildAncestorPaths(o)) i.add(f);
+    for (const o of i) {
+      const f = this.getAtPath(r, o), h = this.getAtPath(c, o);
+      this.connectorBus.emit(e, o, { oldValue: f, newValue: h, path: o });
     }
     return !0;
   }
@@ -859,58 +913,67 @@ class v {
    */
   __devtoolsIntrospect() {
     const e = Object.keys(this.reducers).map((i) => {
-      const c = this.patternReducers.get(i);
-      return { name: i, when: c };
+      const o = this.patternReducers.get(i);
+      return { name: i, when: o };
     }), t = [];
-    for (const [i, c] of this.effects) {
-      if (c.size === 0) continue;
+    for (const [i, o] of this.effects) {
+      if (o.size === 0) continue;
       const [f, h] = i.split("::");
-      for (const l of c) {
-        const p = l.__quoMeta;
-        t.push({ channel: f, type: h, name: p?.name, description: p?.description });
+      for (const l of o) {
+        const u = this.effectMeta.get(l);
+        t.push({ channel: f, type: h, name: u?.name, description: u?.description });
       }
     }
     for (const i of this.patternEffects) {
-      const c = i.effect.__quoMeta;
+      const o = this.effectMeta.get(i.effect);
       t.push({
         channel: "*",
         type: "*",
-        name: c?.name,
-        description: c?.description
+        name: o?.name,
+        description: o?.description
       });
     }
-    const s = [];
+    const r = [];
     for (const i of this.middleware)
-      typeof i == "function" ? s.push({ name: i.name || void 0 }) : s.push({
+      typeof i == "function" ? r.push({ name: i.name || void 0 }) : r.push({
         name: i.meta?.name,
         description: i.meta?.description,
         when: i.when
       });
     const n = [];
     for (const i of this.connectorBus.__introspect())
-      for (let c = 0; c < i.count; c++)
+      for (let o = 0; o < i.count; o++)
         n.push({ reducer: i.channel, property: i.type });
-    const r = [];
-    for (const [i, c] of this.committedEventSubscribers) {
-      if (c.size === 0) continue;
+    const s = [];
+    for (const [i, o] of this.committedEventSubscribers) {
+      if (o.size === 0) continue;
       const [f, h] = i.split("::");
-      for (let l = 0; l < c.size; l++)
-        r.push({ channel: f, type: h, phase: "committed" });
+      for (let l = 0; l < o.size; l++)
+        s.push({ channel: f, type: h, phase: "committed" });
     }
-    for (const [i, c] of this.uncommittedEventSubscribers) {
-      if (c.size === 0) continue;
+    for (const [i, o] of this.uncommittedEventSubscribers) {
+      if (o.size === 0) continue;
       const [f, h] = i.split("::");
-      for (let l = 0; l < c.size; l++)
-        r.push({ channel: f, type: h, phase: "uncommitted" });
+      for (let l = 0; l < o.size; l++)
+        s.push({ channel: f, type: h, phase: "uncommitted" });
     }
-    for (const [i, c] of this.allEventSubscribers) {
-      if (c.size === 0) continue;
+    for (const [i, o] of this.allEventSubscribers) {
+      if (o.size === 0) continue;
       const [f, h] = i.split("::");
-      for (let l = 0; l < c.size; l++)
-        r.push({ channel: f, type: h, phase: "all" });
+      for (let l = 0; l < o.size; l++)
+        s.push({ channel: f, type: h, phase: "all" });
     }
-    const o = this.listeners.size;
-    return { reducers: e, effects: t, middleware: s, atomic: n, event: r, coarse: o };
+    const c = this.listeners.size;
+    return {
+      reducers: e,
+      effects: t,
+      middleware: r,
+      atomic: n,
+      event: s,
+      coarse: c,
+      dedupHits: this.dedupCount,
+      queueDepth: this.reduceQueue.length + this.inFlightEffects
+    };
   }
   /**
    * Applies an externally provided **whole-state** (e.g., DevTools time travel) and emits
@@ -919,27 +982,45 @@ class v {
    * **State Immutability**: If any slices change, a new state object is created via
    * shallow spread. This ensures consistent immutability with {@link forwardEvent}.
    *
+   * **Missing slices**: the snapshot should contain every slice. A slice absent
+   * from `nextPlain` is **retained at its current value** (not blanked to
+   * `undefined`, which would make `getState().<slice>` throw on next access).
+   *
    * @param nextPlain - Plain JS object to become the new state.
    *
    * @internal
    */
   __applyExternalState(e) {
-    const t = this.state, s = e;
-    let n = { ...this.state }, r = !1;
-    Object.keys(this.reducers).forEach((o) => {
-      const i = t?.[o], c = s?.[o];
-      if (i === c) return;
-      const f = w(structuredClone(c));
-      n[o] = f, r = !0;
-      const h = b(i, c).filter(Boolean);
+    if (!this.replayEnabled) {
+      console.warn(
+        "[yoltra] External state apply (time-travel) is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
+      );
+      return;
+    }
+    const t = this.state, r = e, n = { ...this.state };
+    let s = !1;
+    Object.keys(this.reducers).forEach((c) => {
+      const i = t?.[c], o = r?.[c];
+      if (o === void 0) {
+        process.env.NODE_ENV !== "production" && console.warn(
+          `[yoltra] External state is missing slice "${String(
+            c
+          )}"; retaining its current value. Time-travel snapshots should contain all slices.`
+        );
+        return;
+      }
+      if (i === o) return;
+      const f = b(o);
+      n[c] = f, s = !0;
+      const h = g(i, o).filter(Boolean);
       if (h.length === 0) return;
       const l = /* @__PURE__ */ new Set();
-      for (const p of h) for (const d of v.buildAncestorPaths(p)) l.add(d);
-      for (const p of l) {
-        const d = this.getAtPath(i, p), m = this.getAtPath(f, p);
-        this.connectorBus.emit(o, p, { oldValue: d, newValue: m, path: p });
+      for (const u of h) for (const p of v.buildAncestorPaths(u)) l.add(p);
+      for (const u of l) {
+        const p = this.getAtPath(i, u), y = this.getAtPath(f, u);
+        this.connectorBus.emit(c, u, { oldValue: p, newValue: y, path: u });
       }
-    }), r && (this.state = n), r && this.listeners.forEach((o) => o());
+    }), s && (this.state = n), s && this.listeners.forEach((c) => c());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -959,25 +1040,27 @@ class v {
         "[yoltra] Event replay is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
     this.__applyExternalState(e);
-    for (const s of t) {
-      const n = s, r = this.state;
+    for (const r of t) {
+      const n = r, s = this.state;
       this.reducerBus.emit(n.channel, n.type, n.payload);
-      for (const [c, f] of this.patternReducers)
-        this.matchesWhen(f, n) && this.forwardEvent(c, n);
-      const o = this.state, i = r !== o;
-      this.notifyEventSubscribers(n, "committed"), i && this.listeners.forEach((c) => c());
+      for (const [o, f] of this.patternReducers)
+        this.matchesWhen(f, n) && this.forwardEvent(o, n);
+      const c = this.state, i = s !== c;
+      this.notifyEventSubscribers(n, "committed"), i && this.listeners.forEach((o) => o());
     }
   }
   /**
    * Emits a typed event `(channel, type, payload)`.
    * Events are queued and processed **sequentially** (FIFO).
    *
-   * **Pipeline per event:**
-   * 1. **Deduplication check** - Skip if event ID already processed (React Strict Mode safety)
-   * 2. **Middleware** - Pre-reducer hooks; may cancel by returning `false`
-   * 3. **Reducers** - Synchronous state updates via internal event bus
-   * 4. **Effects** - Async side-effects keyed by `(channel, type)` for O(1) lookup
-   * 5. **Coarse subscribers** - External store subscribers (only if state changed)
+   * **Pipeline per event:** the *reduce phase* (steps 1-4) runs **synchronously**,
+   * so `getState()` reflects the change as soon as `emit()` returns; the *effect
+   * phase* (step 5) runs afterwards, asynchronously.
+   * 1. **Deduplication** (opt-in) - Skip when content-dedup is enabled (`dedupWindowMs > 0`) or a matching `dedupKey` recurs; off by default
+   * 2. **Middleware** (sync) - Pre-reducer hooks; may cancel by returning `false`
+   * 3. **Reducers** (sync) - state updates + fine-grained path notifications
+   * 4. **Subscribers + coarse** (sync) - event subscribers (fire-and-forget) then coarse listeners (only if state changed)
+   * 5. **Effects** (async) - side-effects keyed by `(channel, type)`; the returned promise resolves once they complete
    *
    * **Change Detection**: Uses reference equality (`===`) on `this.state` to determine
    * if any slice changed. Works because {@link forwardEvent} creates a new state reference
@@ -988,7 +1071,9 @@ class v {
    * @param channel - Channel name.
    * @param type - Event type name.
    * @param payload - Payload typed as `EM[C][T]`.
-   * @returns A promise that resolves when the event has finished processing.
+   * @param opts - Optional per-emit options (e.g. `dedupKey` for identity-based dedup).
+   * @returns A promise that resolves once this event's effects have finished.
+   * State is already updated synchronously before `emit()` returns.
    *
    * @example Basic usage
    * ```ts
@@ -1007,55 +1092,156 @@ class v {
    *
    * @public
    */
-  async emit(e, t, s) {
-    const n = this.fingerprint(e, t, s);
-    if (this.shouldDedupe(n))
-      return;
-    const r = crypto.randomUUID();
-    if (this.eventQueue.push({
+  async emit(e, t, r, n) {
+    const s = n?.dedupKey, c = this.dedupConfig.windowMs;
+    if (c > 0 || s !== void 0) {
+      const h = s !== void 0 && c <= 0 ? w : c, l = s !== void 0 ? `${e}::${t}::#${s}` : this.fingerprint(e, t, r);
+      if (this.shouldDedupe(l, h))
+        return;
+    }
+    const i = crypto.randomUUID();
+    let o;
+    const f = new Promise((h) => {
+      o = h;
+    });
+    return this.reduceQueue.push({
       channel: e,
       type: t,
-      payload: s,
-      id: r
-    }), !this.isProcessingQueue) {
-      this.isProcessingQueue = !0;
+      payload: r,
+      id: i,
+      resolve: o
+    }), this.drainReduce(), f;
+  }
+  /**
+   * Drains the reduce queue **synchronously**. For each event it runs middleware,
+   * reducers, event subscribers, and coarse listeners in the same tick, so
+   * `getState()` reflects the change the moment {@link emit} returns. Re-entrant
+   * emits (from middleware or subscribers) are appended and drained in the same
+   * pass — preserving FIFO order without interleaving reducers. Each committed
+   * event's effects then run in an independent task (see {@link runEventEffects}).
+   *
+   * @internal
+   */
+  drainReduce() {
+    if (!this.isReducing) {
+      this.isReducing = !0;
       try {
-        for (; this.eventQueue.length; ) {
-          const { channel: o, type: i, payload: c, id: f } = this.eventQueue.shift(), h = { channel: o, type: i, payload: c, id: f };
-          let l = !0;
-          for (const y of this.middleware) {
-            const g = this.getMiddlewareWhen(y);
-            if (!this.matchesWhen(g, h))
-              continue;
-            const E = this.getMiddlewareFunction(y);
-            try {
-              if (!await E(this.state, h, this.emit)) {
-                l = !1;
-                break;
-              }
-            } catch (S) {
-              console.error("Middleware error:", S), l = !1;
-              break;
-            }
-          }
-          if (!l) {
-            await this.notifyEventSubscribers(h, "uncommitted");
-            continue;
+        for (; this.reduceQueue.length > 0; ) {
+          const { channel: e, type: t, payload: r, id: n, resolve: s } = this.reduceQueue.shift(), c = { channel: e, type: t, payload: r, id: n }, i = this.instrumentObservers.size > 0, o = i ? this.state : void 0, f = [];
+          i && (this.changedPathSink = f);
+          const h = i ? S() : 0;
+          let l = !1;
+          try {
+            l = this.applyEventSync(c);
+          } catch (u) {
+            console.error("Emit reduce error:", u);
+          } finally {
+            i && (this.changedPathSink = null);
           }
-          const p = this.state;
-          this.reducerBus.emit(o, i, c);
-          for (const [y, g] of this.patternReducers)
-            this.matchesWhen(g, h) && this.forwardEvent(y, h);
-          const d = this.state, m = p !== d;
-          await this.notifyEventSubscribers(h, "committed"), await this.notifyEffects(h), m && this.listeners.forEach((y) => y());
+          i && this.emitInstrumentation(
+            c,
+            l,
+            f,
+            o,
+            S() - h
+          ), this.runEventEffects(c, l, s);
         }
-      } catch (o) {
-        console.error("Emit queue error:", o);
       } finally {
-        this.isProcessingQueue = !1;
+        this.isReducing = !1;
+      }
+    }
+  }
+  /**
+   * Runs the **synchronous** part of the pipeline for a single event: middleware
+   * (may veto), key- and pattern-based reducers, committed/uncommitted event
+   * subscribers (fire-and-forget), and coarse listeners.
+   *
+   * @returns `true` if the event was committed (passed middleware), `false` if a
+   * middleware vetoed it.
+   *
+   * @internal
+   */
+  applyEventSync(e) {
+    for (const n of this.middleware) {
+      const s = this.getMiddlewareWhen(n);
+      if (!this.matchesWhen(s, e)) continue;
+      const c = this.getMiddlewareFunction(n);
+      let i;
+      try {
+        i = c(this.state, e, this.emit);
+      } catch (o) {
+        console.error("Middleware error:", o), i = !1;
       }
+      if (!i)
+        return this.notifyEventSubscribers(e, "uncommitted"), !1;
+    }
+    const t = this.state;
+    this.reducerBus.emit(e.channel, e.type, e.payload);
+    for (const [n, s] of this.patternReducers)
+      this.matchesWhen(s, e) && this.forwardEvent(n, e);
+    const r = t !== this.state;
+    return this.notifyEventSubscribers(e, "committed"), r && this.listeners.forEach((n) => n()), !0;
+  }
+  /**
+   * Runs a single committed event's effects as an **independent async task**,
+   * then resolves that event's completion deferred so `await emit(...)` settles
+   * once its effects finish. Per-event tasks (rather than one shared serialized
+   * loop) let an effect `await` a re-entrant emit without deadlocking.
+   *
+   * @internal
+   */
+  async runEventEffects(e, t, r) {
+    this.inFlightEffects++;
+    try {
+      t && await this.notifyEffects(e);
+    } catch (n) {
+      console.error("Effect error:", n);
+    } finally {
+      this.inFlightEffects--, r();
     }
   }
+  /**
+   * Registers an instrumentation observer. See {@link StoreInstance.instrument}.
+   *
+   * @public
+   */
+  instrument(e) {
+    return this.instrumentObservers.add(e), () => {
+      this.instrumentObservers.delete(e);
+    };
+  }
+  /**
+   * Builds an {@link InstrumentedEvent} from the reduce result and notifies
+   * observers. `changedPaths` are the exact slice-prefixed leaf paths recorded
+   * by {@link forwardEvent} during this reduce, so DevTools patches need no
+   * re-diff.
+   *
+   * @internal
+   */
+  emitInstrumentation(e, t, r, n, s) {
+    const c = {}, i = {};
+    for (const f of r)
+      c[f] = this.getAtPath(n, f), i[f] = this.getAtPath(this.state, f);
+    const o = {
+      event: {
+        id: e.id,
+        channel: e.channel,
+        type: e.type,
+        payload: e.payload
+      },
+      committed: t,
+      changedPaths: r,
+      prevValues: c,
+      nextValues: i,
+      reduceTimeMs: s
+    };
+    for (const f of [...this.instrumentObservers])
+      try {
+        f(o);
+      } catch (h) {
+        console.error("Instrumentation observer error:", h);
+      }
+  }
   /**
    * Connects a **fine-grained** listener to a dotted path under a slice.
    *
@@ -1133,11 +1319,11 @@ class v {
    *
    * @public
    */
-  onEvent(e, t, s, n = "committed") {
-    const r = `${e}::${String(t)}`, o = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
-    return o.has(r) || o.set(r, /* @__PURE__ */ new Set()), o.get(r).add(s), () => {
-      const i = o.get(r);
-      i && (i.delete(s), i.size === 0 && o.delete(r));
+  onEvent(e, t, r, n = "committed") {
+    const s = `${e}::${String(t)}`, c = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
+    return c.has(s) || c.set(s, /* @__PURE__ */ new Set()), c.get(s).add(r), () => {
+      const i = c.get(s);
+      i && (i.delete(r), i.size === 0 && c.delete(s));
     };
   }
   /**
@@ -1234,8 +1420,8 @@ class v {
     if (e in this.reducers) throw new Error(`Reducer ${e} already exists`);
     return this.mountSlice(e, t, {
       preserveState: !1
-    }), this.listeners.forEach((s) => s()), () => {
-      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((s) => s());
+    }), this.listeners.forEach((r) => r()), () => {
+      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((r) => r());
     };
   }
   /**
@@ -1271,29 +1457,29 @@ class v {
    * @public
    */
   registerEffect(e) {
-    const { effect: t, meta: s, when: n } = e, r = [];
-    if (s && (t.__quoMeta = s), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
-      const c = { effect: t, when: n };
-      return this.patternEffects.add(c), () => {
-        this.patternEffects.delete(c);
+    const { effect: t, meta: r, when: n } = e, s = [];
+    if (r && this.effectMeta.set(t, r), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
+      const o = { effect: t, when: n };
+      return this.patternEffects.add(o), () => {
+        this.patternEffects.delete(o);
       };
     }
     const i = this.normalizeEventKeys(e);
     if (i.length === 0 && !n && !e.events) {
-      const c = { effect: t, when: { any: !0 } };
-      return this.patternEffects.add(c), () => {
-        this.patternEffects.delete(c);
+      const o = { effect: t, when: { any: !0 } };
+      return this.patternEffects.add(o), () => {
+        this.patternEffects.delete(o);
       };
     }
-    for (const [c, f] of i) {
-      const h = `${String(c)}::${String(f)}`;
-      this.effects.has(h) || this.effects.set(h, /* @__PURE__ */ new Set()), this.effects.get(h).add(t), r.push(() => {
+    for (const [o, f] of i) {
+      const h = `${String(o)}::${String(f)}`;
+      this.effects.has(h) || this.effects.set(h, /* @__PURE__ */ new Set()), this.effects.get(h).add(t), s.push(() => {
         const l = this.effects.get(h);
         l && (l.delete(t), l.size === 0 && this.effects.delete(h));
       });
     }
     return () => {
-      for (const c of r) c();
+      for (const o of s) o();
     };
   }
   /**
@@ -1317,11 +1503,11 @@ class v {
    *
    * @public
    */
-  onEffect(e, t, s) {
-    const n = async (r, o, i) => {
-      if (r.channel !== e || r.type !== t) return;
-      const c = r;
-      return s(c.payload, o, i, c);
+  onEffect(e, t, r) {
+    const n = async (s, c, i) => {
+      if (s.channel !== e || s.type !== t) return;
+      const o = s;
+      return r(o.payload, c, i, o);
     };
     return this.registerEffect({
       events: [[e, t]],
@@ -1387,11 +1573,11 @@ class v {
    * @public
    */
   replaceReducers(e, t = {}) {
-    const s = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), r = Object.entries(e), o = new Set(r.map(([i]) => i));
+    const r = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), s = Object.entries(e), c = new Set(s.map(([i]) => i));
     for (const i of n)
-      o.has(i) || this.unmountSlice(i, { deleteState: !0 });
-    for (const [i, c] of r)
-      n.has(i) ? (this.unmountSlice(i, { deleteState: !1 }), this.mountSlice(i, c, { preserveState: s })) : this.mountSlice(i, c, { preserveState: !1 });
+      c.has(i) || this.unmountSlice(i, { deleteState: !0 });
+    for (const [i, o] of s)
+      n.has(i) ? (this.unmountSlice(i, { deleteState: !1 }), this.mountSlice(i, o, { preserveState: r })) : this.mountSlice(i, o, { preserveState: !1 });
   }
   /**
    * Convenience API to replace **any subset** of store parts (HMR patterns).
@@ -1423,24 +1609,24 @@ class v {
    *
    * @internal
    */
-  mountSlice(e, t, s) {
-    const n = e, { events: r, reducer: o, state: i, when: c } = t;
-    if (this.reducers[e] = new _(o), (!s.preserveState || this.state[n] === void 0) && (this.state[n] = w(structuredClone(i))), c && ("any" in c && c.any === !0 || "channel" in c || "channels" in c)) {
-      this.patternReducers.set(e, c), this.sliceUnsubs.set(n, []);
+  mountSlice(e, t, r) {
+    const n = e, { events: s, reducer: c, state: i, when: o } = t;
+    if (this.reducers[e] = new _(c), (!r.preserveState || this.state[n] === void 0) && (this.state[n] = b(structuredClone(i))), o && ("any" in o && o.any === !0 || "channel" in o || "channels" in o)) {
+      this.patternReducers.set(e, o), this.sliceUnsubs.set(n, []);
       return;
     }
     const h = this.normalizeEventKeys(t);
-    if (h.length === 0 && !c && !r) {
+    if (h.length === 0 && !o && !s) {
       this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
       return;
     }
     const l = [];
-    for (const [p, d] of h) {
-      const m = this.reducerBus.on(p, d, (y) => {
-        const g = { channel: p, type: d, payload: y, id: crypto.randomUUID() };
-        this.forwardEvent(e, g);
+    for (const [u, p] of h) {
+      const y = this.reducerBus.on(u, p, (m) => {
+        const M = { channel: u, type: p, payload: m, id: crypto.randomUUID() };
+        this.forwardEvent(e, M);
       });
-      l.push(m);
+      l.push(y);
     }
     this.sliceUnsubs.set(n, l);
   }
@@ -1454,19 +1640,19 @@ class v {
    * @internal
    */
   unmountSlice(e, t) {
-    const s = e;
+    const r = e;
     this.patternReducers.delete(e);
-    const n = this.sliceUnsubs.get(s);
+    const n = this.sliceUnsubs.get(r);
     if (n) {
-      for (const r of n)
+      for (const s of n)
         try {
-          r();
-        } catch (o) {
-          console.error(`[Store error]: ${o}`);
+          s();
+        } catch (c) {
+          console.error(`[Store error]: ${c}`);
         }
-      this.sliceUnsubs.delete(s);
+      this.sliceUnsubs.delete(r);
     }
-    delete this.reducers[e], t.deleteState && delete this.state[s];
+    delete this.reducers[e], t.deleteState && delete this.state[r];
   }
   /**
    * Normalizes event targeting from `when` or legacy `events` to an array of EventKeys.
@@ -1502,12 +1688,12 @@ class v {
   getAtPath(e, t) {
     if (!t) return e;
     const n = (t[0] === "." ? t.slice(1) : t).split(".");
-    let r = e;
-    for (const o of n) {
-      if (r == null) return;
-      r = r[o];
+    let s = e;
+    for (const c of n) {
+      if (s == null) return;
+      s = s[c];
     }
-    return r;
+    return s;
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -1526,32 +1712,33 @@ class v {
    */
   static buildAncestorPaths(e) {
     if (!e) return [];
-    const s = (e[0] === "." ? e.slice(1) : e).split("."), n = [];
-    for (let r = 0; r < s.length; r++)
-      n.push(s.slice(0, r + 1).join("."));
+    const r = (e[0] === "." ? e.slice(1) : e).split("."), n = [];
+    for (let s = 0; s < r.length; s++)
+      n.push(r.slice(0, s + 1).join("."));
     return n;
   }
 }
-function x(a) {
+function R(a) {
   return new v({
     name: a.name,
     reducer: a.reducer ?? {},
     middleware: a.middleware ?? [],
     effects: a.effects ?? [],
     dedupWindowMs: a.dedupWindowMs,
-    devtools: a.devtools
+    devtools: a.devtools,
+    onEffectError: a.onEffectError
   });
 }
-const B = (a) => (e, t) => t.map((s) => [e, s]), $ = () => (a) => a;
+const $ = (a) => (e, t) => t.map((r) => [e, r]), B = () => (a) => a;
 export {
-  z as EventBus,
+  O as EventBus,
   k as LooseEventBus,
   _ as Reducer,
   v as Store,
-  x as createStore,
-  b as detectChangedProps,
-  $ as eventKeys,
-  w as freezeState,
-  B as typedEvents
+  R as createStore,
+  g as detectChangedProps,
+  B as eventKeys,
+  E as freezeState,
+  $ as typedEvents
 };
 //# sourceMappingURL=yoltra.esm.js.map