@yoltra/core 0.5.0 → 0.7.0

package/dist/yoltra.mjs

@@ -1,23 +1,13 @@
 /*!
- * @yoltra/core v0.5.0
+ * @yoltra/core v0.7.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 T = Object.defineProperty;
-var C = (o, e, t) => e in o ? T(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
-var p = (o, e, t) => C(o, typeof e != "symbol" ? e + "" : e, t);
-class B {
-  constructor() {
-    /**
-     * Internal registry: `channel → type → Set<handler>`.
-     * @internal
-     */
-    p(this, "handlers", /* @__PURE__ */ new Map());
-  }
+ * License: MIT */
+class W {
+  /**
+   * Internal registry: `channel → type → Set<handler>`.
+   * @internal
+   */
+  handlers = /* @__PURE__ */ new Map();
   /**
    * Subscribes a handler to an exact `(channel, type)`.
    *
@@ -50,11 +40,11 @@ class B {
    *
    * @public
    */
-  on(e, t, n) {
-    let s = this.handlers.get(e);
-    s || (s = /* @__PURE__ */ new Map(), this.handlers.set(e, s));
-    let i = s.get(t);
-    return i || (i = /* @__PURE__ */ new Set(), s.set(t, i)), i.add(n), () => this.off(e, t, n);
+  on(e, t, s) {
+    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);
   }
   /**
    * Removes a specific handler previously added with {@link EventBus.on | `on`}.
@@ -76,11 +66,11 @@ class B {
    *
    * @public
    */
-  off(e, t, n) {
-    const s = this.handlers.get(e);
-    if (!s) return;
-    const i = s.get(t);
-    i && (i.delete(n), i.size === 0 && s.delete(t), s.size === 0 && this.handlers.delete(e));
+  off(e, t, s) {
+    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));
   }
   /**
    * Emits an event to all subscribers of the exact `(channel, type)`.
@@ -104,16 +94,16 @@ class B {
    *
    * @public
    */
-  emit(e, t, n, s) {
-    const i = this.handlers.get(e);
-    if (!i) return;
-    const d = i.get(t);
-    if (!(!d || d.size === 0))
-      for (const a of [...d])
+  emit(e, t, s, n) {
+    const r = this.handlers.get(e);
+    if (!r) return;
+    const c = r.get(t);
+    if (!(!c || c.size === 0))
+      for (const l of [...c])
         try {
-          a(n, s);
-        } catch (r) {
-          console.error("EventBus handler error:", r);
+          l(s, n);
+        } catch (i) {
+          console.error("EventBus handler error:", i);
         }
   }
   /**
@@ -133,37 +123,35 @@ class B {
     this.handlers.clear();
   }
 }
-class H {
-  constructor() {
-    /**
-     * Exact handlers: `channel → type → [handlers]`.
-     * @internal
-     */
-    p(this, "handlers", /* @__PURE__ */ new Map());
-    /**
-     * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
-     * @internal
-     */
-    p(this, "patternHandlers", /* @__PURE__ */ new Map());
-    /**
-     * Patterns bucketed by their first segment, so an emit tests only what could match.
-     *
-     * @remarks
-     * Delivery used to walk every pattern registered on the channel and run the full segment
-     * matcher against each. That is linear in the number of patterns rather than in the number
-     * that match, and it re-split both the pattern and the subject on every test — for a thousand
-     * patterns, two thousand string splits to deliver one event.
-     *
-     * A subject's first segment can only be matched by a pattern whose first segment is that same
-     * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
-     * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
-     * the handful that begin with a wildcard.
-     *
-     * It buys nothing for a channel where every pattern starts with `**`, since all of those must
-     * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
-     */
-    p(this, "patternIndex", /* @__PURE__ */ new Map());
-  }
+class U {
+  /**
+   * Exact handlers: `channel → type → [handlers]`.
+   * @internal
+   */
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
+   * @internal
+   */
+  patternHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Patterns bucketed by their first segment, so an emit tests only what could match.
+   *
+   * @remarks
+   * Delivery used to walk every pattern registered on the channel and run the full segment
+   * matcher against each. That is linear in the number of patterns rather than in the number
+   * that match, and it re-split both the pattern and the subject on every test — for a thousand
+   * patterns, two thousand string splits to deliver one event.
+   *
+   * A subject's first segment can only be matched by a pattern whose first segment is that same
+   * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
+   * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
+   * the handful that begin with a wildcard.
+   *
+   * It buys nothing for a channel where every pattern starts with `**`, since all of those must
+   * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
+   */
+  patternIndex = /* @__PURE__ */ new Map();
   /**
    * Subscribes a handler to either an **exact** type or a **pattern**.
    *
@@ -196,18 +184,18 @@ class H {
    *
    * @public
    */
-  on(e, t, n) {
-    const s = String(t);
-    if (this.isPattern(s)) {
-      const i = s;
+  on(e, t, s) {
+    const n = String(t);
+    if (this.isPattern(n)) {
+      const r = n;
       this.patternHandlers.has(e) || this.patternHandlers.set(e, /* @__PURE__ */ new Map());
-      const d = this.patternHandlers.get(e);
-      return d.has(i) || (d.set(i, []), this.indexPattern(e, i)), d.get(i).push(n), () => this.offPattern(e, i, n);
+      const c = this.patternHandlers.get(e);
+      return c.has(r) || (c.set(r, []), this.indexPattern(e, r)), c.get(r).push(s), () => this.offPattern(e, r, s);
     } else {
-      const i = this.normalizeTypeKey(s);
+      const r = this.normalizeTypeKey(n);
       this.handlers.has(e) || this.handlers.set(e, /* @__PURE__ */ new Map());
-      const d = this.handlers.get(e);
-      return d.has(i) || d.set(i, []), d.get(i).push(n), () => this.offExactNormalized(e, i, n);
+      const c = this.handlers.get(e);
+      return c.has(r) || c.set(r, []), c.get(r).push(s), () => this.offExactNormalized(e, r, s);
     }
   }
   /**
@@ -228,9 +216,9 @@ class H {
    *
    * @public
    */
-  off(e, t, n) {
-    const s = this.normalizeTypeKey(String(t));
-    this.offExactNormalized(e, s, n);
+  off(e, t, s) {
+    const n = this.normalizeTypeKey(String(t));
+    this.offExactNormalized(e, n, s);
   }
   /**
    * Internal exact unsubscription using an already **normalized** type key.
@@ -240,13 +228,13 @@ class H {
    * @param handler - Handler to remove.
    * @internal
    */
-  offExactNormalized(e, t, n) {
-    const s = this.handlers.get(e);
-    if (!s) return;
-    const i = s.get(t);
-    if (!i) return;
-    const d = i.indexOf(n);
-    d !== -1 && i.splice(d, 1), i.length === 0 && s.delete(t), s.size === 0 && this.handlers.delete(e);
+  offExactNormalized(e, t, s) {
+    const n = this.handlers.get(e);
+    if (!n) return;
+    const r = n.get(t);
+    if (!r) return;
+    const c = r.indexOf(s);
+    c !== -1 && r.splice(c, 1), r.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
   }
   /**
    * Internal removal for a **pattern** subscription. No-ops if missing.
@@ -256,13 +244,13 @@ class H {
    * @param handler - Handler to remove.
    * @internal
    */
-  offPattern(e, t, n) {
-    const s = this.patternHandlers.get(e);
-    if (!s) return;
-    const i = s.get(t);
-    if (!i) return;
-    const d = i.indexOf(n);
-    d !== -1 && i.splice(d, 1), i.length === 0 && (s.delete(t), this.unindexPattern(e, t)), s.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
+  offPattern(e, t, s) {
+    const n = this.patternHandlers.get(e);
+    if (!n) return;
+    const r = n.get(t);
+    if (!r) return;
+    const c = r.indexOf(s);
+    c !== -1 && r.splice(c, 1), r.length === 0 && (n.delete(t), this.unindexPattern(e, t)), n.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
   }
   /**
    * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
@@ -284,21 +272,21 @@ class H {
    *
    * @public
    */
-  emit(e, t, n) {
-    const s = String(t), i = this.normalizeTypeKey(s), d = this.handlers.get(e)?.get(i) ?? [], a = this.matchingPatternHandlers(e, s), r = /* @__PURE__ */ new Set(), f = (c) => {
-      for (const u of [...c])
-        if (!r.has(u)) {
-          r.add(u);
+  emit(e, t, s) {
+    const n = String(t), r = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n), i = /* @__PURE__ */ new Set(), a = (u) => {
+      for (const d of [...u])
+        if (!i.has(d)) {
+          i.add(d);
           try {
-            u(n);
-          } catch (l) {
-            console.error(l);
+            d(s);
+          } catch (h) {
+            console.error(h);
             continue;
           }
         }
     };
-    f(d);
-    for (const c of a) f(c);
+    a(c);
+    for (const u of l) a(u);
   }
   /**
    * Emits a payload that is only built if somebody is listening.
@@ -316,23 +304,23 @@ class H {
    *
    * @public
    */
-  emitWith(e, t, n) {
-    const s = String(t), i = this.normalizeTypeKey(s), d = this.handlers.get(e)?.get(i) ?? [], a = this.matchingPatternHandlers(e, s);
-    if (d.length === 0 && a.length === 0) return;
-    const r = n(), f = /* @__PURE__ */ new Set(), c = (u) => {
-      for (const l of [...u])
-        if (!f.has(l)) {
-          f.add(l);
+  emitWith(e, t, s) {
+    const n = String(t), r = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n);
+    if (c.length === 0 && l.length === 0) return;
+    const i = s(), a = /* @__PURE__ */ new Set(), u = (d) => {
+      for (const h of [...d])
+        if (!a.has(h)) {
+          a.add(h);
           try {
-            l(r);
-          } catch (y) {
-            console.error(y);
+            h(i);
+          } catch (p) {
+            console.error(p);
             continue;
           }
         }
     };
-    c(d);
-    for (const u of a) c(u);
+    u(c);
+    for (const d of l) u(d);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -371,27 +359,27 @@ class H {
    * @internal
    */
   indexPattern(e, t) {
-    let n = this.patternIndex.get(e);
-    n === void 0 && (n = { byHead: /* @__PURE__ */ new Map(), anyHead: [] }, this.patternIndex.set(e, n));
-    const s = this.splitPath(t), i = { pattern: t, segments: s }, d = s[0];
-    if (d === void 0 || d === "*" || d === "**") {
-      n.anyHead.push(i);
+    let s = this.patternIndex.get(e);
+    s === void 0 && (s = { byHead: /* @__PURE__ */ new Map(), anyHead: [] }, this.patternIndex.set(e, s));
+    const n = this.splitPath(t), r = { pattern: t, segments: n }, c = n[0];
+    if (c === void 0 || c === "*" || c === "**") {
+      s.anyHead.push(r);
       return;
     }
-    const a = n.byHead.get(d);
-    a === void 0 ? n.byHead.set(d, [i]) : a.push(i);
+    const l = s.byHead.get(c);
+    l === void 0 ? s.byHead.set(c, [r]) : l.push(r);
   }
   /**
    * Removes a pattern from the index. Paired with {@link LooseEventBus.offPattern}.
    * @internal
    */
   unindexPattern(e, t) {
-    const n = this.patternIndex.get(e);
-    if (n === void 0) return;
-    const s = this.splitPath(t)[0], i = s === void 0 || s === "*" || s === "**" ? n.anyHead : n.byHead.get(s);
-    if (i === void 0) return;
-    const d = i.findIndex((a) => a.pattern === t);
-    d !== -1 && i.splice(d, 1), i.length === 0 && i !== n.anyHead && s !== void 0 && n.byHead.delete(s);
+    const s = this.patternIndex.get(e);
+    if (s === void 0) return;
+    const n = this.splitPath(t)[0], r = n === void 0 || n === "*" || n === "**" ? s.anyHead : s.byHead.get(n);
+    if (r === void 0) return;
+    const c = r.findIndex((l) => l.pattern === t);
+    c !== -1 && r.splice(c, 1), r.length === 0 && r !== s.anyHead && n !== void 0 && s.byHead.delete(n);
   }
   /**
    * The handler lists of every pattern matching this subject.
@@ -405,20 +393,20 @@ class H {
    * @internal
    */
   matchingPatternHandlers(e, t) {
-    const n = this.patternHandlers.get(e), s = this.patternIndex.get(e);
-    if (n === void 0 || n.size === 0 || s === void 0) return [];
-    const i = this.splitPath(t), d = [], a = (f) => {
-      for (const c of f) {
-        if (!this.matchSegments(c.segments, i)) continue;
-        const u = n.get(c.pattern);
-        u !== void 0 && d.push(u);
+    const s = this.patternHandlers.get(e), n = this.patternIndex.get(e);
+    if (s === void 0 || s.size === 0 || n === void 0) return [];
+    const r = this.splitPath(t), c = [], l = (a) => {
+      for (const u of a) {
+        if (!this.matchSegments(u.segments, r)) continue;
+        const d = s.get(u.pattern);
+        d !== void 0 && c.push(d);
       }
-    }, r = i[0];
-    if (r !== void 0) {
-      const f = s.byHead.get(r);
-      f !== void 0 && a(f);
+    }, i = r[0];
+    if (i !== void 0) {
+      const a = n.byHead.get(i);
+      a !== void 0 && l(a);
     }
-    return a(s.anyHead), d;
+    return l(n.anyHead), c;
   }
   /**
    * Pattern matcher over dot-separated segments, which arrive already split.
@@ -449,18 +437,18 @@ class H {
    * @internal
    */
   matchSegments(e, t) {
-    let n = 0, s = 0, i = -1, d = 0;
-    for (; s < t.length; )
-      if (n < e.length && (e[n] === "*" || e[n] === t[s]))
-        n++, s++;
-      else if (n < e.length && e[n] === "**")
-        i = n, d = s, n++;
-      else if (i !== -1)
-        n = i + 1, s = ++d;
+    let s = 0, n = 0, r = -1, c = 0;
+    for (; n < t.length; )
+      if (s < e.length && (e[s] === "*" || e[s] === t[n]))
+        s++, n++;
+      else if (s < e.length && e[s] === "**")
+        r = s, c = n, s++;
+      else if (r !== -1)
+        s = r + 1, n = ++c;
       else
         return !1;
-    for (; n < e.length && e[n] === "**"; ) n++;
-    return n === e.length;
+    for (; s < e.length && e[s] === "**"; ) s++;
+    return s === e.length;
   }
   /**
    * Removes **all** listeners (exact and pattern). Useful for tests/HMR teardown.
@@ -485,16 +473,21 @@ class H {
    */
   __introspect() {
     const e = [];
-    for (const [t, n] of this.handlers)
-      for (const [s, i] of n)
-        i.length > 0 && e.push({ channel: t, type: s, count: i.length });
-    for (const [t, n] of this.patternHandlers)
-      for (const [s, i] of n)
-        i.length > 0 && e.push({ channel: t, type: s, count: i.length });
+    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 });
     return e;
   }
 }
-class K {
+class L {
+  /**
+   * The underlying pure reducer function.
+   * @internal
+   */
+  _reduce;
   /**
    * Creates a new {@link Reducer} from a pure reducer function.
    *
@@ -511,11 +504,6 @@ class K {
    * @public
    */
   constructor(e) {
-    /**
-     * The underlying pure reducer function.
-     * @internal
-     */
-    p(this, "_reduce");
     this._reduce = e;
   }
   /**
@@ -523,7 +511,7 @@ class K {
     *
     * @param state  - Current state.
     * @param event - An event drawn from {@link EventUnion | `EventUnion<EM>`}.
-    * @returns The next state produced by the underlying reducer function.
+    * @returns The next state, or a {@link Rejection} if the reducer refused the write.
     *
     * @example
     * ```ts
@@ -536,115 +524,336 @@ class K {
     return this._reduce(e, t);
   }
 }
-const k = /* @__PURE__ */ new Set();
-function M(o, e) {
+const T = /* @__PURE__ */ new Set();
+function O(o, e) {
   const t = o ? `${o}.${e}` : e;
-  k.has(t) || (k.add(t), console.warn(
+  T.has(t) || (T.add(t), console.warn(
     `[yoltra] State key "${e}"${o ? ` under "${o}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
   ));
 }
-function O(o, e, t = "", n = /* @__PURE__ */ new Map()) {
-  const s = [];
-  return v(o, e, t, n, s), s;
+function I(o, e, t = "", s = /* @__PURE__ */ new Map()) {
+  const n = [];
+  return P(o, e, t, s, n), n;
 }
-function v(o, e, t, n, s) {
+function P(o, e, t, s, n) {
   if (o === e) return;
   if (typeof o != "object" || typeof e != "object" || o === null || e === null) {
     if (typeof o == "number" && Number.isNaN(o) && Number.isNaN(e))
       return;
-    s.push(t);
+    n.push(t);
     return;
   }
   if (o instanceof Date && e instanceof Date) {
-    o.getTime() !== e.getTime() && s.push(t);
+    o.getTime() !== e.getTime() && n.push(t);
     return;
   }
   if (o instanceof RegExp && e instanceof RegExp) {
-    (o.source !== e.source || e.flags !== o.flags) && s.push(t);
+    (o.source !== e.source || e.flags !== o.flags) && n.push(t);
     return;
   }
   if (o instanceof Map || e instanceof Map) {
-    s.push(t);
+    n.push(t);
     return;
   }
   if (o instanceof Set || e instanceof Set) {
-    s.push(t);
+    n.push(t);
     return;
   }
-  const i = o, d = e, a = n.get(i);
-  if (a?.has(d)) return;
-  const r = a ?? /* @__PURE__ */ new Set();
-  r.add(d), a || n.set(i, r);
+  const r = o, c = e, l = s.get(r);
+  if (l?.has(c)) return;
+  const i = l ?? /* @__PURE__ */ new Set();
+  i.add(c), l || s.set(r, i);
   try {
-    const f = Array.isArray(o), c = Array.isArray(e);
-    if (f !== c) {
-      s.push(t);
+    const a = Array.isArray(o), u = Array.isArray(e);
+    if (a !== u) {
+      n.push(t);
       return;
     }
-    if (f) {
-      const h = o, m = e;
-      h.length !== m.length && t && s.push(t);
-      const g = Math.min(h.length, m.length);
-      for (let w = 0; w < g; w++)
-        h[w] !== m[w] && v(h[w], m[w], t ? `${t}.${w}` : `${w}`, n, s);
-      for (let w = g; w < Math.max(h.length, m.length); w++)
-        s.push(t ? `${t}.${w}` : `${w}`);
+    if (a) {
+      const f = o, m = e;
+      f.length !== m.length && t && n.push(t);
+      const y = Math.min(f.length, m.length);
+      for (let g = 0; g < y; g++)
+        f[g] !== m[g] && P(f[g], m[g], t ? `${t}.${g}` : `${g}`, s, n);
+      for (let g = y; g < Math.max(f.length, m.length); g++)
+        n.push(t ? `${t}.${g}` : `${g}`);
       return;
     }
-    const u = Object.keys(o), l = Object.keys(e);
-    if (u.length === 0 && l.length === 0) {
-      s.push(t);
+    const d = Object.keys(o), h = Object.keys(e);
+    if (d.length === 0 && h.length === 0) {
+      n.push(t);
       return;
     }
-    let y = u.length === l.length;
-    if (y) {
-      for (let h = 0; h < l.length; h++)
-        if (!Object.prototype.hasOwnProperty.call(o, l[h])) {
-          y = !1;
+    let p = d.length === h.length;
+    if (p) {
+      for (let f = 0; f < h.length; f++)
+        if (!Object.prototype.hasOwnProperty.call(o, h[f])) {
+          p = !1;
           break;
         }
     }
-    if (y) {
-      for (const h of l)
-        o[h] !== e[h] && (process.env.NODE_ENV !== "production" && h.includes(".") && M(t, h), v(o[h], e[h], t ? `${t}.${h}` : h, n, s));
+    if (p) {
+      for (const f of h)
+        o[f] !== e[f] && (process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f), P(o[f], e[f], t ? `${t}.${f}` : f, s, n));
       return;
     }
-    for (const h of l) {
-      const m = Object.prototype.hasOwnProperty.call(o, h);
-      if (m && o[h] === e[h]) continue;
-      process.env.NODE_ENV !== "production" && h.includes(".") && M(t, h);
-      const g = t ? `${t}.${h}` : h;
+    for (const f of h) {
+      const m = Object.prototype.hasOwnProperty.call(o, f);
+      if (m && o[f] === e[f]) continue;
+      process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f);
+      const y = t ? `${t}.${f}` : f;
       if (!m) {
-        s.push(g);
+        n.push(y);
         continue;
       }
-      v(o[h], e[h], g, n, s);
+      P(o[f], e[f], y, s, n);
     }
-    for (const h of u)
-      Object.prototype.hasOwnProperty.call(e, h) || (process.env.NODE_ENV !== "production" && h.includes(".") && M(t, h), s.push(t ? `${t}.${h}` : h));
+    for (const f of d)
+      Object.prototype.hasOwnProperty.call(e, f) || (process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f), n.push(t ? `${t}.${f}` : f));
   } finally {
-    r.delete(d), r.size === 0 && n.delete(i);
+    i.delete(c), i.size === 0 && s.delete(r);
   }
 }
-function S(o, e = /* @__PURE__ */ new WeakSet(), t) {
+function M(o, e = /* @__PURE__ */ new WeakSet(), t) {
   if (o === null || typeof o != "object" || e.has(o) || (t !== void 0 && o === t.watch && t.onFound(), Object.isFrozen(o))) return o;
   if (e.add(o), Array.isArray(o)) {
-    const n = o;
-    for (let s = 0; s < n.length; s++)
-      n[s] = S(n[s], e, t);
-    return Object.freeze(n);
+    const s = o;
+    for (let n = 0; n < s.length; n++)
+      s[n] = M(s[n], e, t);
+    return Object.freeze(s);
   }
-  for (const n of Object.getOwnPropertyNames(o)) {
-    const s = Object.getOwnPropertyDescriptor(o, n);
-    !s || !("value" in s) || (o[n] = S(o[n], e, t));
+  for (const s of Object.getOwnPropertyNames(o)) {
+    const n = Object.getOwnPropertyDescriptor(o, s);
+    !n || !("value" in n) || (o[s] = M(o[s], e, t));
   }
-  for (const n of Object.getOwnPropertySymbols(o)) {
-    const s = Object.getOwnPropertyDescriptor(o, n);
-    !s || !("value" in s) || (o[n] = S(o[n], e, t));
+  for (const s of Object.getOwnPropertySymbols(o)) {
+    const n = Object.getOwnPropertyDescriptor(o, s);
+    !n || !("value" in n) || (o[s] = M(o[s], e, t));
   }
   return Object.freeze(o);
 }
-function W(o, e) {
+const B = /* @__PURE__ */ Symbol.for("yoltra.rejected");
+function fe(o) {
+  return { [B]: !0, reason: o };
+}
+function V(o) {
+  return typeof o == "object" && o !== null && o[B] === !0;
+}
+class Q extends Error {
+  channel;
+  type;
+  idleMs;
+  constructor(e, t, s) {
+    super(
+      `[yoltra] call to "${e}/${t}" saw no correlated reply for ${s}ms. The timeout is idle rather than total, so this means the responder went quiet, not that it was slow. Check that something handles "${e}/${t}" and that its reply is emitted through the \`emit\` it was handed — a reply emitted from an unrelated context carries no causal link, and needs an explicit correlationId instead.`
+    ), this.name = "CallTimeoutError", this.channel = e, this.type = t, this.idleMs = s;
+  }
+}
+class C extends Error {
+  constructor(e) {
+    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
+  }
+}
+function G(o) {
+  const [e, t] = o;
+  if (t === void 0) return { channel: e, isTerminal: () => !0 };
+  if (typeof t == "string") return { channel: e, isTerminal: (n) => n === t };
+  const s = new Set(t);
+  return { channel: e, isTerminal: (n) => s.has(n) };
+}
+function J(o, e, t) {
+  return o.parentId === e ? !0 : t === void 0 ? !1 : o.meta?.correlationId === t;
+}
+class q {
+  constructor(e) {
+    this.highWaterMark = e;
+  }
+  highWaterMark;
+  buffer = [];
+  /** Consumers parked in `take`, oldest first. */
+  takers = [];
+  /** Producers parked in `put`, each with the item they are waiting to hand over. */
+  putters = [];
+  consuming = !1;
+  /** No more items will be accepted, but what is already here is still owed to the consumer. */
+  ended = !1;
+  /** Abandoned: nothing further is owed to anybody. */
+  closed = !1;
+  /** Items discarded because nobody was iterating and the buffer was full. */
+  dropped = 0;
+  /** How many items were discarded for want of a consumer. */
+  get droppedCount() {
+    return this.dropped;
+  }
+  /**
+   * Marks that a consumer has started pulling. From here on, a full buffer parks the producer
+   * rather than dropping.
+   */
+  beginConsuming() {
+    this.consuming = !0;
+  }
+  /**
+   * Offers an item. The returned promise settles when the item has been taken — or immediately,
+   * if it fit in the buffer or was dropped.
+   */
+  put(e) {
+    if (this.closed || this.ended) return Promise.resolve();
+    const t = this.takers.shift();
+    return t !== void 0 ? (t({ value: e, done: !1 }), Promise.resolve()) : this.buffer.length < this.highWaterMark ? (this.buffer.push(e), Promise.resolve()) : this.consuming ? new Promise((s) => {
+      this.putters.push({ item: e, release: s });
+    }) : (this.dropped++, Promise.resolve());
+  }
+  /** Takes the next item, waiting if none is available. Resolves `done` once closed and drained. */
+  take() {
+    this.consuming = !0;
+    const e = this.buffer.shift();
+    if (e !== void 0) {
+      const s = this.putters.shift();
+      return s !== void 0 && (this.buffer.push(s.item), s.release()), Promise.resolve({ value: e, done: !1 });
+    }
+    const t = this.putters.shift();
+    return t !== void 0 ? (t.release(), Promise.resolve({ value: t.item, done: !1 })) : this.closed || this.ended ? Promise.resolve({ value: void 0, done: !0 }) : new Promise((s) => {
+      this.takers.push(s);
+    });
+  }
+  /**
+   * Stops accepting items, but keeps owing the consumer everything already queued.
+   *
+   * @remarks
+   * What the terminal reply does. Closing outright at that moment would throw away progress the
+   * responder had already handed over and the consumer had not yet read — which is exactly what
+   * happened before this existed: a six-step job delivered five steps, because the sixth was in
+   * the buffer when `done` arrived and the buffer was cleared. The terminal event says "no more
+   * is coming", not "forget what you were given".
+   */
+  end() {
+    if (this.ended || this.closed) return;
+    this.ended = !0;
+    let e = this.putters.shift();
+    for (; e !== void 0; )
+      this.buffer.push(e.item), e.release(), e = this.putters.shift();
+    let t = this.takers.shift();
+    for (; t !== void 0; ) {
+      const s = this.buffer.shift();
+      t(
+        s !== void 0 ? { value: s, done: !1 } : { value: void 0, done: !0 }
+      ), t = this.takers.shift();
+    }
+  }
+  /**
+   * Closes the queue: waiting consumers are told `done`, and **every parked producer is
+   * released**.
+   *
+   * @remarks
+   * Releasing producers is not tidying up. A producer parked on `put` is a pending `await emit`
+   * somewhere; leaving it parked when the call has already settled would hang the responder for
+   * good — turning a timed-out call into a wedged process, which is worse than the problem
+   * backpressure was added to solve.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = !0, this.buffer.length = 0;
+    let e = this.takers.shift();
+    for (; e !== void 0; )
+      e({ value: void 0, done: !0 }), e = this.takers.shift();
+    let t = this.putters.shift();
+    for (; t !== void 0; )
+      t.release(), t = this.putters.shift();
+  }
+}
+const Y = 3e4, X = 16;
+function Z(o, e, t, s, n) {
+  const { channel: r, isTerminal: c } = G(n.reply), l = n.timeoutMs ?? Y, i = new q(n.highWaterMark ?? X), a = o.idFactory();
+  let u, d, h = !1;
+  const p = new Promise((E, v) => {
+    u = E, d = v;
+  });
+  p.catch(() => {
+  });
+  let f = null, m = null;
+  const y = (E, v = !1) => {
+    h || (h = !0, f !== null && clearTimeout(f), f = null, m?.(), m = null, v ? i.end() : i.close(), n.signal?.removeEventListener("abort", g), E());
+  };
+  function g() {
+    y(() => d(new C(String(n.signal?.reason ?? "signal aborted"))));
+  }
+  const $ = () => {
+    f !== null && clearTimeout(f), f = setTimeout(() => {
+      y(() => d(new Q(e, t, l)));
+    }, l), f.unref?.();
+  };
+  return m = o.registerEffect({
+    // A pattern effect on the reply channel: which types are terminal is known, which are
+    // progress is not, so the filter cannot be a key list.
+    when: { channel: r },
+    effect: async (E) => {
+      if (!h && J(E, a, n.correlationId)) {
+        if ($(), c(String(E.type))) {
+          y(() => u(E), !0);
+          return;
+        }
+        await i.put(E);
+      }
+    }
+  }), n.signal !== void 0 && (n.signal.aborted ? g() : n.signal.addEventListener("abort", g, { once: !0 })), $(), o.emit(e, t, s, {
+    id: a,
+    ...n.correlationId !== void 0 ? { meta: { correlationId: n.correlationId } } : {}
+  }), {
+    then: (E, v) => p.then(E, v),
+    catch: (E) => p.catch(E),
+    finally: (E) => p.finally(E),
+    get dropped() {
+      return i.droppedCount;
+    },
+    cancel: (E = "cancelled") => {
+      y(() => d(new C(E)));
+    },
+    [Symbol.asyncIterator]: () => (i.beginConsuming(), {
+      next: () => i.take(),
+      // Called by `for await` on `break`, `return` or a throw. Without it, abandoning the
+      // loop would leave the effect registered and the producer parked for good.
+      return: async () => (i.close(), { value: void 0, done: !0 })
+    })
+  };
+}
+function ee(o, e) {
+  if (!e) return o;
+  const s = (e[0] === "." ? e.slice(1) : e).split(".");
+  let n = o;
+  for (const r of s) {
+    if (n == null) return;
+    n = n[r];
+  }
+  return n;
+}
+function te(o) {
+  if (!o) return [];
+  const t = (o[0] === "." ? o.slice(1) : o).split("."), s = [];
+  for (let n = 0; n < t.length; n++)
+    s.push(t.slice(0, n + 1).join("."));
+  return s;
+}
+function k(o, e) {
+  return !o || "any" in o && o.any === !0 ? !0 : "keys" in o ? o.keys.some(
+    ([t, s]) => e.channel === t && e.type === s
+  ) : "channel" in o ? e.channel === o.channel : "channels" in o ? o.channels.includes(e.channel) : !1;
+}
+function ne(o) {
+  return typeof o == "function" ? o : o.middleware;
+}
+function se(o) {
+  if (typeof o != "function")
+    return o.when;
+}
+function D(o) {
+  if (o.when) {
+    const e = o.when;
+    if ("keys" in e)
+      return e.keys;
+  }
+  return [];
+}
+function re(o, e) {
   try {
     return structuredClone(e);
   } catch (t) {
@@ -653,11 +862,274 @@ function W(o, e) {
     );
   }
 }
-function P(o, e) {
-  return process.env.NODE_ENV === "production" ? o : S(o, /* @__PURE__ */ new WeakSet(), e);
+function R(o, e) {
+  return process.env.NODE_ENV === "production" ? o : M(o, /* @__PURE__ */ new WeakSet(), e);
 }
-const x = 100, z = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
-class $ {
+const A = 100, ie = 64, z = 16, S = Object.freeze({ committed: !1, written: !1 }), oe = Object.freeze({ committed: !0, written: !1 }), ce = Object.freeze({ committed: !0, written: !0 }), _ = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+class x {
+  /**
+   * Store name (used by DevTools & diagnostics).
+   *
+   * @public
+   */
+  name;
+  /**
+   * Registered middleware pipeline (run **before** reducers).
+   * Stores either raw functions (legacy) or MiddlewareSpec objects.
+   * Return `false` from the middleware function to stop propagation.
+   *
+   * @internal
+   */
+  middleware;
+  /**
+   * Installed slice reducers keyed by slice name.
+   *
+   * @internal
+   */
+  reducers;
+  /**
+   * Current immutable snapshot of the store state.
+   * This reference changes whenever any slice changes (shallow immutability).
+   *
+   * @internal
+   */
+  state;
+  /**
+   * Bus for reducer wiring (emit by `(channel, type)`).
+   *
+   * @internal
+   */
+  reducerBus;
+  /**
+   * Bus for **granular** connector events (emit by **dotted path** inside a slice).
+   *
+   * @internal
+   */
+  connectorBus;
+  /**
+   * Coarse-grained listeners (called once per committed event, only if state changed).
+   *
+   * @internal
+   */
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
+   * Used for effects with explicit `keys` targeting.
+   *
+   * @internal
+   */
+  effects = /* @__PURE__ */ new Map();
+  /**
+   * Pattern-based effects that need runtime matching.
+   * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
+   * Stores tuples of [effect function, when matcher].
+   *
+   * @internal
+   */
+  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
+   */
+  committedEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified when middleware rejects an event.
+   *
+   * @internal
+   */
+  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
+   */
+  /**
+   * Subscribers to events that actually changed state, notified after the commit.
+   *
+   * @remarks
+   * Separate from `committedEventSubscribers` rather than a filter over it, because the two
+   * answer different questions and one of them is load bearing: `committed` means "not vetoed"
+   * and fires for every event a store accepts, including every event in a store with no
+   * reducers. Narrowing it would have silently stopped toasts and analytics firing.
+   *
+   * @internal
+   */
+  writtenEventSubscribers = /* @__PURE__ */ new Map();
+  allEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * Track reducerBus unsubs per slice for HMR/register/unregister.
+   *
+   * @internal
+   */
+  sliceUnsubs = /* @__PURE__ */ new Map();
+  /**
+   * Pattern-based reducers that need runtime matching.
+   * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
+   * Maps slice name to the `when` matcher.
+   *
+   * @internal
+   */
+  patternReducers = /* @__PURE__ */ new Map();
+  /**
+   * Whether `__replayEvents()` is allowed.
+   * Set from `spec.devtools.allowReplay`.
+   *
+   * @internal
+   */
+  replayEnabled;
+  /**
+   * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
+   * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
+   *
+   * @internal
+   */
+  idFactory;
+  /**
+   * 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.
+   */
+  onEffectError;
+  /**
+   * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
+   * failing slice is isolated rather than the event being rolled back, so this is the only
+   * signal that a reducer misbehaved.
+   */
+  onReducerError;
+  /**
+   * `slice:channel:type` combinations already warned about for payload aliasing.
+   *
+   * @remarks
+   * Development-only diagnostics have to stay quiet enough to be read. One warning names the
+   * pattern; repeating it once per event would bury it.
+   */
+  warnedPayloadAliases = /* @__PURE__ */ new Set();
+  /**
+   * Pending events awaiting the **synchronous** reduce phase (middleware +
+   * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
+   *
+   * @internal
+   */
+  reduceQueue = [];
+  /**
+   * Re-entrancy guard for the synchronous reduce phase.
+   *
+   * @internal
+   */
+  isReducing = !1;
+  /**
+   * The event currently being reduced, or `null` outside the drain.
+   *
+   * @remarks
+   * This is what makes causality exact rather than best-effort. The drain is synchronous — no
+   * `await` can interleave — so any `emit` that arrives while it is set is, without ambiguity, a
+   * consequence of this event. That catches the case a scoped `emit` closure cannot: a
+   * middleware or subscriber that captured the store and calls `store.emit` directly instead of
+   * using the injected one. Attribution should not depend on which reference a consumer reached
+   * for.
+   *
+   * @internal
+   */
+  currentEvent = null;
+  /**
+   * Events processed by the drain currently in progress. Compared against
+   * `maxTransitionsPerDrain`, which is off unless configured.
+   *
+   * @internal
+   */
+  transitionsThisDrain = 0;
+  /**
+   * Ceilings that stop a cascade from becoming a hung process. See {@link StoreSpec.maxReduceDepth}.
+   *
+   * @internal
+   */
+  maxReduceDepth;
+  maxTransitionsPerDrain;
+  onCascade;
+  onRejected;
+  /**
+   * Registered instrumentation observers (DevTools seam). See {@link instrument}.
+   *
+   * @internal
+   */
+  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 commitStaged}. `null` when not instrumenting.
+   *
+   * @internal
+   */
+  changedPathSink = null;
+  /**
+   * Where keyed reducers put their pending writes during a reduce, and the refusal one of them
+   * returned.
+   *
+   * @remarks
+   * Keyed reducers are invoked through `reducerBus`, which delivers to handlers and has no way
+   * to hand a value back — the same reason `changedPathSink` exists. `null` outside a reduce.
+   *
+   * @internal
+   */
+  stagingSink = null;
+  stagedRejection = null;
+  stagedRejectedBy = "";
+  /**
+   * Count of effect tasks currently in flight; surfaced as queue depth by
+   * {@link __devtoolsIntrospect}.
+   *
+   * @internal
+   */
+  inFlightEffects = 0;
+  /**
+   * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
+   *
+   * **Deduplication Behavior:**
+   * - Events are fingerprinted using `channel::type::JSON(payload)`
+   * - If an identical fingerprint is seen within the dedup window, it's skipped
+   * - The window is 50ms in development, 100ms in production
+   *
+   * **Limitations:**
+   * - Non-serializable payloads (functions, symbols, circular refs) get unique
+   *   fingerprints and won't be deduplicated
+   * - Legitimate rapid-fire identical events may be incorrectly deduplicated
+   * - The cache is bounded to 1000 entries with lazy pruning
+   *
+   * @internal
+   */
+  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
+   */
+  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
+   */
+  effectMeta = /* @__PURE__ */ new WeakMap();
+  /**
+   * Configuration for event deduplication.
+   * @internal
+   */
+  dedupConfig;
+  /**
+   * Timer for periodic cleanup of processed events.
+   *
+   * @internal
+   */
+  eventCleanupTimer = null;
   /**
    * Creates a store from a {@link StoreSpec}.
    *
@@ -666,223 +1138,15 @@ class $ {
    * @public
    */
   constructor(e) {
-    /**
-     * Store name (used by DevTools & diagnostics).
-     *
-     * @public
-     */
-    p(this, "name");
-    /**
-     * Registered middleware pipeline (run **before** reducers).
-     * Stores either raw functions (legacy) or MiddlewareSpec objects.
-     * Return `false` from the middleware function to stop propagation.
-     *
-     * @internal
-     */
-    p(this, "middleware");
-    /**
-     * Installed slice reducers keyed by slice name.
-     *
-     * @internal
-     */
-    p(this, "reducers");
-    /**
-     * Current immutable snapshot of the store state.
-     * This reference changes whenever any slice changes (shallow immutability).
-     *
-     * @internal
-     */
-    p(this, "state");
-    /**
-     * Bus for reducer wiring (emit by `(channel, type)`).
-     *
-     * @internal
-     */
-    p(this, "reducerBus");
-    /**
-     * Bus for **granular** connector events (emit by **dotted path** inside a slice).
-     *
-     * @internal
-     */
-    p(this, "connectorBus");
-    /**
-     * Coarse-grained listeners (called once per committed event, only if state changed).
-     *
-     * @internal
-     */
-    p(this, "listeners", /* @__PURE__ */ new Set());
-    /**
-     * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
-     * Used for effects with explicit `keys` targeting.
-     *
-     * @internal
-     */
-    p(this, "effects", /* @__PURE__ */ new Map());
-    /**
-     * Pattern-based effects that need runtime matching.
-     * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
-     * Stores tuples of [effect function, when matcher].
-     *
-     * @internal
-     */
-    p(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
-     */
-    p(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
-    /**
-     * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
-     * Notified when middleware rejects an event.
-     *
-     * @internal
-     */
-    p(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
-     */
-    p(this, "allEventSubscribers", /* @__PURE__ */ new Map());
-    /**
-     * Track reducerBus unsubs per slice for HMR/register/unregister.
-     *
-     * @internal
-     */
-    p(this, "sliceUnsubs", /* @__PURE__ */ new Map());
-    /**
-     * Pattern-based reducers that need runtime matching.
-     * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
-     * Maps slice name to the `when` matcher.
-     *
-     * @internal
-     */
-    p(this, "patternReducers", /* @__PURE__ */ new Map());
-    /**
-     * Whether `__replayEvents()` is allowed.
-     * Set from `spec.devtools.allowReplay`.
-     *
-     * @internal
-     */
-    p(this, "replayEnabled");
-    /**
-     * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
-     * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
-     *
-     * @internal
-     */
-    p(this, "idFactory");
-    /**
-     * 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.
-     */
-    p(this, "onEffectError");
-    /**
-     * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
-     * failing slice is isolated rather than the event being rolled back, so this is the only
-     * signal that a reducer misbehaved.
-     */
-    p(this, "onReducerError");
-    /**
-     * `slice:channel:type` combinations already warned about for payload aliasing.
-     *
-     * @remarks
-     * Development-only diagnostics have to stay quiet enough to be read. One warning names the
-     * pattern; repeating it once per event would bury it.
-     */
-    p(this, "warnedPayloadAliases", /* @__PURE__ */ new Set());
-    /**
-     * Pending events awaiting the **synchronous** reduce phase (middleware +
-     * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
-     *
-     * @internal
-     */
-    p(this, "reduceQueue", []);
-    /**
-     * Re-entrancy guard for the synchronous reduce phase.
-     *
-     * @internal
-     */
-    p(this, "isReducing", !1);
-    /**
-     * Registered instrumentation observers (DevTools seam). See {@link instrument}.
-     *
-     * @internal
-     */
-    p(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
-     */
-    p(this, "changedPathSink", null);
-    /**
-     * Count of effect tasks currently in flight; surfaced as queue depth by
-     * {@link __devtoolsIntrospect}.
-     *
-     * @internal
-     */
-    p(this, "inFlightEffects", 0);
-    /**
-     * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
-     *
-     * **Deduplication Behavior:**
-     * - Events are fingerprinted using `channel::type::JSON(payload)`
-     * - If an identical fingerprint is seen within the dedup window, it's skipped
-     * - The window is 50ms in development, 100ms in production
-     *
-     * **Limitations:**
-     * - Non-serializable payloads (functions, symbols, circular refs) get unique
-     *   fingerprints and won't be deduplicated
-     * - Legitimate rapid-fire identical events may be incorrectly deduplicated
-     * - The cache is bounded to 1000 entries with lazy pruning
-     *
-     * @internal
-     */
-    p(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
-     */
-    p(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
-     */
-    p(this, "effectMeta", /* @__PURE__ */ new WeakMap());
-    /**
-     * Configuration for event deduplication.
-     * @internal
-     */
-    p(this, "dedupConfig");
-    /**
-     * Timer for periodic cleanup of processed events.
-     *
-     * @internal
-     */
-    p(this, "eventCleanupTimer", null);
-    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new B(), this.connectorBus = new H(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.idFactory = e.idFactory ?? (() => crypto.randomUUID()), this.onEffectError = e.onEffectError, this.onReducerError = e.onReducerError, this.dedupConfig = {
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new W(), this.connectorBus = new U(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.idFactory = e.idFactory ?? (() => crypto.randomUUID()), this.onEffectError = e.onEffectError, this.onReducerError = e.onReducerError, this.maxReduceDepth = e.maxReduceDepth ?? ie, this.maxTransitionsPerDrain = e.maxTransitionsPerDrain ?? 1 / 0, this.onCascade = e.onCascade, this.onRejected = e.onRejected, this.dedupConfig = {
       windowMs: e.dedupWindowMs ?? 0,
       maxCacheSize: 1e3
-    }, Object.entries(e.reducer).forEach(([t, n]) => {
-      this.mountSlice(t, n, { preserveState: !1 });
+    }, Object.entries(e.reducer).forEach(([t, s]) => {
+      this.mountSlice(t, s, { preserveState: !1 });
     }), e.effects?.length)
       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);
+    this.dispose = this.dispose.bind(this), this.notifyEffects = this.notifyEffects.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.
@@ -898,7 +1162,7 @@ class $ {
    * @public
    */
   dispose() {
-    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), 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;
+    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.writtenEventSubscribers.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.
@@ -911,17 +1175,17 @@ class $ {
    *
    * @internal
    */
-  fingerprint(e, t, n) {
-    const s = `${e}::${t}`;
+  fingerprint(e, t, s) {
+    const n = `${e}::${t}`;
     try {
-      if (n == null)
-        return `${s}::null`;
-      if (typeof n != "object")
-        return `${s}::${String(n)}`;
-      const i = JSON.stringify(n);
-      return `${s}::${i}`;
+      if (s == null)
+        return `${n}::null`;
+      if (typeof s != "object")
+        return `${n}::${String(s)}`;
+      const r = JSON.stringify(s);
+      return `${n}::${r}`;
     } catch {
-      return `${s}::${Date.now()}::${Math.random()}`;
+      return `${n}::${Date.now()}::${Math.random()}`;
     }
   }
   /**
@@ -934,8 +1198,8 @@ class $ {
    * @internal
    */
   shouldDedupe(e, t) {
-    const n = Date.now(), s = this.processedEvents.get(e);
-    return s !== void 0 && n - s < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, n), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(n), !1);
+    const s = Date.now(), n = this.processedEvents.get(e);
+    return n !== void 0 && s - n < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, s), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(s), !1);
   }
   /**
    * Starts the periodic prune interval if it isn't already running. Called when
@@ -957,55 +1221,31 @@ class $ {
    * @internal
    */
   pruneProcessedEvents(e) {
-    const t = Math.max(this.dedupConfig.windowMs, x), n = e - t * 2;
-    for (const [s, i] of this.processedEvents)
-      i < n && this.processedEvents.delete(s);
+    const t = Math.max(this.dedupConfig.windowMs, A), s = e - t * 2;
+    for (const [n, r] of this.processedEvents)
+      r < s && 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.
-   *
-   * @param when - The When matcher (or undefined for "all events").
-   * @param event - The event to check.
-   * @returns `true` if the event matches, `false` otherwise.
+   * Reports a breached ceiling and refuses the emit.
    *
    * @remarks
-   * - `undefined` or missing `when` matches ALL events.
-   * - `{ any: true }` matches ALL events.
-   * - `{ keys: [...] }` matches if event's `[channel, type]` is in the array.
-   * - `{ channel: 'x' }` matches if event's channel equals 'x'.
-   * - `{ channels: ['x', 'y'] }` matches if event's channel is in the array.
+   * Console *and* hook, matching how reducer and effect errors are reported: a cascade is a
+   * wiring bug, and the console line is what a developer who has not registered a hook will
+   * actually see. Without one, refusing the emit would look exactly like the event never having
+   * been emitted at all — which is the invisibility this whole guard exists to end.
    *
    * @internal
    */
-  matchesWhen(e, t) {
-    return !e || "any" in e && e.any === !0 ? !0 : "keys" in e ? e.keys.some(
-      ([n, s]) => t.channel === n && t.type === s
-    ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
-  }
-  /**
-   * Extracts the middleware function from a MiddlewareInput.
-   * Handles both raw functions (legacy) and MiddlewareSpec objects.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The middleware function.
-   *
-   * @internal
-   */
-  getMiddlewareFunction(e) {
-    return typeof e == "function" ? e : e.middleware;
-  }
-  /**
-   * Gets the `when` matcher from a MiddlewareInput.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The `when` matcher, or `undefined` for raw functions (match all).
-   *
-   * @internal
-   */
-  getMiddlewareWhen(e) {
-    if (typeof e != "function")
-      return e.when;
+  reportCascade(e, t, s, n, r) {
+    console.error(
+      `[yoltra] Cascade stopped: "${s.channel}/${s.type}" would exceed ${e} (${t}). This event was refused and the chain ends here. A chain this long is almost always two consumers emitting into each other — check what reacts to "${s.channel}/${s.type}" and what that emits in turn.` + (r.length > 0 ? ` Recent causal chain: ${r.join(" → ")} → (refused).` : "")
+    );
+    try {
+      this.onCascade?.({ limit: e, limitValue: t, event: s, depth: n, chain: r });
+    } catch (c) {
+      console.error("onCascade handler error:", c);
+    }
   }
   /**
    * Invokes all registered **effects** for a given event.
@@ -1016,22 +1256,40 @@ class $ {
    * @internal
    */
   async notifyEffects(e) {
-    const t = `${String(e.channel)}::${String(e.type)}`, n = this.effects.get(t);
+    const t = this.scopedEmit(e), s = `${String(e.channel)}::${String(e.type)}`, n = this.effects.get(s);
     if (n && n.size > 0)
-      for (const s of [...n])
+      for (const r of [...n])
         try {
-          await s(e, this.getState, this.emit);
-        } catch (i) {
-          console.error("Effect error:", i), this.onEffectError?.(i, e);
+          await r(e, this.getState, t);
+        } catch (c) {
+          console.error("Effect error:", c), this.onEffectError?.(c, e);
         }
-    for (const { effect: s, when: i } of this.patternEffects)
-      if (this.matchesWhen(i, e))
+    for (const { effect: r, when: c } of this.patternEffects)
+      if (k(c, e))
         try {
-          await s(e, this.getState, this.emit);
-        } catch (d) {
-          console.error("Effect error:", d), this.onEffectError?.(d, e);
+          await r(e, this.getState, t);
+        } catch (l) {
+          console.error("Effect error:", l), this.onEffectError?.(l, e);
         }
   }
+  /**
+   * An `emit` that attributes whatever it sends to `cause`.
+   *
+   * @remarks
+   * Built per event rather than per effect: every effect reacting to one event shares a cause,
+   * and one closure is cheaper than one per handler on a path that runs for every committed
+   * event.
+   *
+   * @internal
+   */
+  scopedEmit(e) {
+    const t = {
+      id: e.id,
+      depth: e.depth ?? 0,
+      chain: [...this.currentEvent?.chain ?? [], e.id].slice(-z)
+    };
+    return ((s, n, r, c) => this.emitCaused(t, s, n, r, c));
+  }
   /**
    * Notifies event subscribers for a specific phase.
    *
@@ -1043,12 +1301,13 @@ class $ {
    * @internal
    */
   notifyEventSubscribers(e, t) {
-    const n = `${String(e.channel)}::${String(e.type)}`, i = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(n);
-    if (i?.size)
-      for (const a of [...i]) this.invokeEventSubscriber(a, e, t);
-    const d = this.allEventSubscribers.get(n);
-    if (d?.size)
-      for (const a of [...d]) this.invokeEventSubscriber(a, e, t);
+    const s = `${String(e.channel)}::${String(e.type)}`, r = (t === "committed" ? this.committedEventSubscribers : t === "written" ? this.writtenEventSubscribers : this.uncommittedEventSubscribers).get(s);
+    if (r?.size)
+      for (const l of [...r]) this.invokeEventSubscriber(l, e, t);
+    if (t === "written") return;
+    const c = this.allEventSubscribers.get(s);
+    if (c?.size)
+      for (const l of [...c]) this.invokeEventSubscriber(l, e, t);
   }
   /**
    * Invokes a single event-subscription handler **fire-and-forget**: synchronous
@@ -1057,12 +1316,12 @@ class $ {
    *
    * @internal
    */
-  invokeEventSubscriber(e, t, n) {
+  invokeEventSubscriber(e, t, s) {
     try {
-      const s = e(t, this.getState, this.emit, n);
-      s && typeof s.then == "function" && s.catch((i) => console.error("Event subscription error:", i));
-    } catch (s) {
-      console.error("Event subscription error:", s);
+      const n = e(t, this.getState, this.emit, s);
+      n && typeof n.then == "function" && n.catch((r) => console.error("Event subscription error:", r));
+    } catch (n) {
+      console.error("Event subscription error:", n);
     }
   }
   /**
@@ -1100,53 +1359,116 @@ class $ {
    * pattern reducer's throw aborted the commit and notified nobody, not even the uncommitted
    * subscribers a veto would have reached.
    *
-   * The semantics are now the same either way: **the failing slice is isolated.** Its state is
+   * The semantics are the same either way: **the failing slice is isolated.** Its state is
    * unchanged, every other slice still reduces, and the event still commits if anything else
-   * changed. Rolling the whole event back would be tidier in principle, but fine-grained
-   * subscribers are notified inside `forwardEvent` as each slice commits, so an event that
-   * reverted afterwards would have already told components about a value that no longer exists.
-   * Isolation keeps every notification truthful.
+   * changed.
+   *
+   * That is deliberately *not* what a {@link Rejected} refusal does, which discards the whole
+   * event. A crash and a refusal are different acts: a reducer that throws has a bug and should
+   * not be able to veto its neighbours' work, while a reducer that refuses has made a decision
+   * and must be able to.
+   *
+   * This once argued that rolling back was untenable, because subscribers were notified as each
+   * slice committed and a later revert would have told them about a value that no longer
+   * existed. Staging removed that obstacle — nothing is notified until every slice is written —
+   * which is what made refusal possible at all.
    *
    * @internal
    */
-  forwardEventGuarded(e, t) {
+  stageSliceGuarded(e, t, s) {
     try {
-      return this.forwardEvent(e, t);
+      return this.stageSlice(e, t, s);
     } catch (n) {
-      return console.error(`Reducer error in slice "${e}":`, n), this.onReducerError?.(n, t, e), !1;
+      return console.error(`Reducer error in slice "${e}":`, n), this.onReducerError?.(n, t, e), null;
     }
   }
-  forwardEvent(e, t) {
-    const n = this.state[e], s = this.reducers[e].reduce(n, t);
-    if (n === s) return !1;
-    const i = O(n, s);
-    if (i.length === 0) return !1;
-    const d = t.payload, a = process.env.NODE_ENV !== "production" && d !== null && typeof d == "object" ? {
-      watch: d,
+  /**
+   * Runs one slice's reducer and records what it *would* write. Writes nothing.
+   *
+   * @returns The reducer's {@link Rejection} if it refused, otherwise `null`.
+   *
+   * @remarks
+   * The staging half of the write path. Nothing here touches `this.state` or notifies anybody,
+   * which is what lets the event be refused after every reducer has had its say — a decision
+   * that has to see the whole diff cannot be made one slice at a time.
+   *
+   * Freezing happens here rather than at commit because it is where the new value is built, and
+   * the freeze is a no-op on anything already frozen; a staged slice that never commits is
+   * discarded frozen, which costs nothing and keeps the committed path free of a second walk.
+   *
+   * @internal
+   */
+  stageSlice(e, t, s) {
+    const n = this.state[e], r = this.reducers[e].reduce(n, t);
+    if (V(r)) return r;
+    if (n === r) return null;
+    const c = I(n, r);
+    if (c.length === 0) return null;
+    const l = t.payload, i = process.env.NODE_ENV !== "production" && l !== null && typeof l == "object" ? {
+      watch: l,
       onFound: () => {
-        const c = `${e}:${t.channel}:${t.type}`;
-        this.warnedPayloadAliases.has(c) || (this.warnedPayloadAliases.add(c), console.warn(
+        const a = `${e}:${t.channel}:${t.type}`;
+        this.warnedPayloadAliases.has(a) || (this.warnedPayloadAliases.add(a), console.warn(
           `[yoltra] Slice "${e}" stored the payload of "${t.channel}/${t.type}" by reference. It is now frozen along with the rest of the state, so the emitter mutating it later will throw in development and silently corrupt state in production. Copy the payload in the reducer instead.`
         ));
       }
-    } : void 0, r = P(s, a);
-    if (this.state = { ...this.state, [e]: r }, this.changedPathSink)
-      for (const c of i)
-        this.changedPathSink.push(c ? `${e}.${c}` : e);
-    const f = /* @__PURE__ */ new Set();
-    for (const c of i) {
-      if (c === "") {
-        f.add("");
-        continue;
+    } : void 0;
+    return s.push({
+      name: e,
+      prev: n,
+      frozen: R(r, i),
+      leafPaths: c
+    }), null;
+  }
+  /**
+   * Writes every staged slice, then tells the world — in that order.
+   *
+   * @remarks
+   * The commit half. Assigning all slices under a single new root before any notification goes
+   * out is what closes the window this used to leave open: notifications fired per slice as each
+   * committed, so a subscriber to slice A that read `getState()` could observe slice B of the
+   * *same event* not yet applied. In React that window is real, because the atomic hooks use a
+   * change as a bare signal and then re-read the whole store.
+   *
+   * It is also what makes refusal possible at all. The previous code documented rollback as
+   * untenable precisely because "an event that reverted afterwards would have already told
+   * components about a value that no longer exists" — true when notification and commit were the
+   * same step, and no longer true now that they are not.
+   *
+   * @returns `true` if anything was written.
+   *
+   * @internal
+   */
+  commitStaged(e, t) {
+    if (e.length === 0) return !1;
+    const s = { ...this.state };
+    for (const n of e) s[n.name] = n.frozen;
+    if (this.state = s, this.changedPathSink)
+      for (const n of e)
+        for (const r of n.leafPaths)
+          this.changedPathSink.push(r ? `${n.name}.${r}` : n.name);
+    for (const n of e) {
+      const r = /* @__PURE__ */ new Set();
+      for (const c of n.leafPaths) {
+        if (c === "") {
+          r.add("");
+          continue;
+        }
+        for (const l of x.buildAncestorPaths(c)) r.add(l);
       }
-      for (const u of $.buildAncestorPaths(c)) f.add(u);
+      for (const c of r)
+        this.connectorBus.emitWith(n.name, c, () => ({
+          oldValue: this.getAtPath(n.prev, c),
+          newValue: this.getAtPath(n.frozen, c),
+          path: c,
+          // Provenance, built inside the same lazy factory as the values: a subscriber that
+          // needs to know why a value moved no longer has to mirror the cause into state and
+          // keep it there twice.
+          eventId: t.id,
+          channel: t.channel,
+          type: t.type
+        }));
     }
-    for (const c of f)
-      this.connectorBus.emitWith(e, c, () => ({
-        oldValue: this.getAtPath(n, c),
-        newValue: this.getAtPath(r, c),
-        path: c
-      }));
     return !0;
   }
   /**
@@ -1160,65 +1482,65 @@ class $ {
    * @public
    */
   __devtoolsIntrospect() {
-    const e = Object.keys(this.reducers).map((a) => {
-      const r = this.patternReducers.get(a);
-      return { name: a, when: r };
+    const e = Object.keys(this.reducers).map((l) => {
+      const i = this.patternReducers.get(l);
+      return { name: l, when: i };
     }), t = [];
-    for (const [a, r] of this.effects) {
-      if (r.size === 0) continue;
-      const [f, c] = a.split("::");
-      for (const u of r) {
-        const l = this.effectMeta.get(u);
-        t.push({ channel: f, type: c, name: l?.name, description: l?.description });
+    for (const [l, i] of this.effects) {
+      if (i.size === 0) continue;
+      const [a, u] = l.split("::");
+      for (const d of i) {
+        const h = this.effectMeta.get(d);
+        t.push({ channel: a, type: u, name: h?.name, description: h?.description });
       }
     }
-    for (const a of this.patternEffects) {
-      const r = this.effectMeta.get(a.effect);
+    for (const l of this.patternEffects) {
+      const i = this.effectMeta.get(l.effect);
       t.push({
         channel: "*",
         type: "*",
-        name: r?.name,
-        description: r?.description
+        name: i?.name,
+        description: i?.description
       });
     }
-    const n = [];
-    for (const a of this.middleware)
-      typeof a == "function" ? n.push({ name: a.name || void 0 }) : n.push({
-        name: a.meta?.name,
-        description: a.meta?.description,
-        when: a.when
-      });
     const s = [];
-    for (const a of this.connectorBus.__introspect())
-      for (let r = 0; r < a.count; r++)
-        s.push({ reducer: a.channel, property: a.type });
-    const i = [];
-    for (const [a, r] of this.committedEventSubscribers) {
-      if (r.size === 0) continue;
-      const [f, c] = a.split("::");
-      for (let u = 0; u < r.size; u++)
-        i.push({ channel: f, type: c, phase: "committed" });
+    for (const l of this.middleware)
+      typeof l == "function" ? s.push({ name: l.name || void 0 }) : s.push({
+        name: l.meta?.name,
+        description: l.meta?.description,
+        when: l.when
+      });
+    const n = [];
+    for (const l of this.connectorBus.__introspect())
+      for (let i = 0; i < l.count; i++)
+        n.push({ reducer: l.channel, property: l.type });
+    const r = [];
+    for (const [l, i] of this.committedEventSubscribers) {
+      if (i.size === 0) continue;
+      const [a, u] = l.split("::");
+      for (let d = 0; d < i.size; d++)
+        r.push({ channel: a, type: u, phase: "committed" });
     }
-    for (const [a, r] of this.uncommittedEventSubscribers) {
-      if (r.size === 0) continue;
-      const [f, c] = a.split("::");
-      for (let u = 0; u < r.size; u++)
-        i.push({ channel: f, type: c, phase: "uncommitted" });
+    for (const [l, i] of this.uncommittedEventSubscribers) {
+      if (i.size === 0) continue;
+      const [a, u] = l.split("::");
+      for (let d = 0; d < i.size; d++)
+        r.push({ channel: a, type: u, phase: "uncommitted" });
     }
-    for (const [a, r] of this.allEventSubscribers) {
-      if (r.size === 0) continue;
-      const [f, c] = a.split("::");
-      for (let u = 0; u < r.size; u++)
-        i.push({ channel: f, type: c, phase: "all" });
+    for (const [l, i] of this.allEventSubscribers) {
+      if (i.size === 0) continue;
+      const [a, u] = l.split("::");
+      for (let d = 0; d < i.size; d++)
+        r.push({ channel: a, type: u, phase: "all" });
     }
-    const d = this.listeners.size;
+    const c = this.listeners.size;
     return {
       reducers: e,
       effects: t,
-      middleware: n,
-      atomic: s,
-      event: i,
-      coarse: d,
+      middleware: s,
+      atomic: n,
+      event: r,
+      coarse: c,
       dedupHits: this.dedupCount,
       queueDepth: this.reduceQueue.length + this.inFlightEffects
     };
@@ -1228,7 +1550,7 @@ class $ {
    * fine-grained path changes for each slice.
    *
    * **State Immutability**: If any slices change, a new state object is created via
-   * shallow spread. This ensures consistent immutability with {@link forwardEvent}.
+   * shallow spread. This ensures consistent immutability with {@link commitStaged}.
    *
    * **Missing slices**: the snapshot should contain every slice. A slice absent
    * from `nextPlain` is **retained at its current value** (not blanked to
@@ -1243,36 +1565,36 @@ class $ {
       throw new Error(
         "[yoltra] External state apply (time-travel) is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
-    const t = this.state, n = e, s = { ...this.state };
-    let i = !1;
-    Object.keys(this.reducers).forEach((d) => {
-      const a = t?.[d], r = n?.[d];
-      if (r === void 0) {
+    const t = this.state, s = e, n = { ...this.state };
+    let r = !1;
+    Object.keys(this.reducers).forEach((c) => {
+      const l = t?.[c], i = s?.[c];
+      if (i === void 0) {
         process.env.NODE_ENV !== "production" && console.warn(
           `[yoltra] External state is missing slice "${String(
-            d
+            c
           )}"; retaining its current value. Time-travel snapshots should contain all slices.`
         );
         return;
       }
-      if (a === r) return;
-      const f = P(r);
-      s[d] = f, i = !0;
-      const c = O(a, r);
-      if (c.length === 0) return;
-      const u = /* @__PURE__ */ new Set();
-      for (const l of c) {
-        if (l === "") {
-          u.add("");
+      if (l === i) return;
+      const a = R(i);
+      n[c] = a, r = !0;
+      const u = I(l, i);
+      if (u.length === 0) return;
+      const d = /* @__PURE__ */ new Set();
+      for (const h of u) {
+        if (h === "") {
+          d.add("");
           continue;
         }
-        for (const y of $.buildAncestorPaths(l)) u.add(y);
+        for (const p of x.buildAncestorPaths(h)) d.add(p);
       }
-      for (const l of u) {
-        const y = this.getAtPath(a, l), h = this.getAtPath(f, l);
-        this.connectorBus.emit(d, l, { oldValue: y, newValue: h, path: l });
+      for (const h of d) {
+        const p = this.getAtPath(l, h), f = this.getAtPath(a, h);
+        this.connectorBus.emit(c, h, { oldValue: p, newValue: f, path: h });
       }
-    }), i && (this.state = s), i && this.listeners.forEach((d) => d());
+    }), r && (this.state = n), r && this.listeners.forEach((c) => c());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -1292,13 +1614,24 @@ class $ {
         "[yoltra] Event replay is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
     this.__applyExternalState(e);
-    for (const n of t) {
-      const s = n, i = this.state;
-      this.reducerBus.emit(s.channel, s.type, s.payload, s);
-      for (const [r, f] of this.patternReducers)
-        this.matchesWhen(f, s) && this.forwardEventGuarded(r, s);
-      const d = this.state, a = i !== d;
-      this.notifyEventSubscribers(s, "committed"), a && this.listeners.forEach((r) => r());
+    for (const s of t) {
+      const n = s, r = [];
+      this.stagingSink = r;
+      let c = null;
+      try {
+        this.reducerBus.emit(n.channel, n.type, n.payload, n), c = this.stagedRejection;
+        for (const [i, a] of this.patternReducers) {
+          if (c !== null) break;
+          if (k(a, n)) {
+            const u = this.stageSliceGuarded(i, n, r);
+            u !== null && (c = u);
+          }
+        }
+      } finally {
+        this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
+      }
+      const l = c === null && this.commitStaged(r, n);
+      this.notifyEventSubscribers(n, "committed"), l && (this.notifyEventSubscribers(n, "written"), this.listeners.forEach((i) => i()));
     }
   }
   /**
@@ -1310,13 +1643,13 @@ class $ {
    * 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)
+   * 3. **Reducers** (sync) - every matching slice is *staged*; nothing is written yet, so a refusal from the last reducer still stops the first one's write
+   * 4. **Commit + subscribers** (sync) - all staged slices are assigned under one new root, then event subscribers (`committed`, then `written` when state actually changed), then coarse listeners
    * 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
-   * via shallow spread when any slice changes.
+   * if any slice changed. Works because the commit builds a new state reference via
+   * shallow spread when any slice changes.
    *
    * @typeParam C - Channel key in `EM`.
    * @typeParam T - Type key within channel `C`.
@@ -1344,26 +1677,60 @@ class $ {
    *
    * @public
    */
-  async emit(e, t, n, s) {
-    const i = s?.dedupKey, d = this.dedupConfig.windowMs;
-    if (s?.skipDedup !== !0 && (d > 0 || i !== void 0)) {
-      const c = i !== void 0 && d <= 0 ? x : d, u = i !== void 0 ? `${e}::${t}::#${i}` : this.fingerprint(e, t, n);
-      if (this.shouldDedupe(u, c))
-        return;
+  async emit(e, t, s, n) {
+    return this.emitCaused(null, e, t, s, n);
+  }
+  /**
+   * The real emit, with an explicitly supplied cause.
+   *
+   * @remarks
+   * Exists so the parent can be passed without a pseudo-private field on the public
+   * {@link EmitOptions}. Two callers supply one: the public {@link emit} passes `null` and lets
+   * `currentEvent` speak for the synchronous case, and the scoped `emit` handed to effects passes
+   * the event that triggered them — effects resume after the drain has ended, so nothing else
+   * could still know what caused them.
+   *
+   * @internal
+   */
+  async emitCaused(e, t, s, n, r) {
+    const c = r?.dedupKey, l = this.dedupConfig.windowMs;
+    if (r?.skipDedup !== !0 && (l > 0 || c !== void 0)) {
+      const p = c !== void 0 && l <= 0 ? A : l, f = c !== void 0 ? `${t}::${s}::#${c}` : this.fingerprint(t, s, n);
+      if (this.shouldDedupe(f, p))
+        return S;
     }
-    const a = s?.id ?? this.idFactory();
-    let r;
-    const f = new Promise((c) => {
-      r = c;
+    const i = r?.id ?? this.idFactory(), a = this.currentEvent ?? e, u = a === null ? 0 : a.depth + 1;
+    if (a !== null && u > this.maxReduceDepth)
+      return this.reportCascade(
+        "maxReduceDepth",
+        this.maxReduceDepth,
+        {
+          channel: t,
+          type: s,
+          payload: n,
+          id: i,
+          ...r?.meta !== void 0 ? { meta: r.meta } : {},
+          parentId: a.id,
+          depth: u
+        },
+        u,
+        a.chain
+      ), S;
+    let d;
+    const h = new Promise((p) => {
+      d = p;
     });
     return this.reduceQueue.push({
-      channel: e,
-      type: t,
+      channel: t,
+      type: s,
       payload: n,
-      id: a,
-      meta: s?.meta,
-      resolve: r
-    }), this.drainReduce(), f;
+      id: i,
+      meta: r?.meta,
+      resolve: d,
+      // Only carried for caused events, so a root event's object stays byte-identical to one
+      // built before causality existed — the same rule `meta` follows.
+      ...a !== null ? { parentId: a.id, depth: u, chain: a.chain } : {}
+    }), this.drainReduce(), h;
   }
   /**
    * Drains the reduce queue **synchronously**. For each event it runs middleware,
@@ -1377,33 +1744,50 @@ class $ {
    */
   drainReduce() {
     if (!this.isReducing) {
-      this.isReducing = !0;
+      this.isReducing = !0, this.transitionsThisDrain = 0;
       try {
         for (; this.reduceQueue.length > 0; ) {
-          const { channel: e, type: t, payload: n, id: s, meta: i, resolve: d } = this.reduceQueue.shift(), a = {
-            channel: e,
-            type: t,
+          const e = this.reduceQueue.shift(), { channel: t, type: s, payload: n, id: r, meta: c, resolve: l, parentId: i, depth: a, chain: u } = e, d = {
+            channel: t,
+            type: s,
             payload: n,
-            id: s,
-            ...i !== void 0 ? { meta: i } : {}
-          }, r = this.instrumentObservers.size > 0, f = r ? this.state : void 0, c = r ? [] : void 0;
-          c !== void 0 && (this.changedPathSink = c);
-          const u = r ? z() : 0;
-          let l = !1;
+            id: r,
+            ...c !== void 0 ? { meta: c } : {},
+            ...i !== void 0 ? { parentId: i, depth: a } : {}
+          };
+          if (i !== void 0 && ++this.transitionsThisDrain > this.maxTransitionsPerDrain) {
+            this.reportCascade(
+              "maxTransitionsPerDrain",
+              this.maxTransitionsPerDrain,
+              d,
+              a,
+              u
+            ), l(S);
+            continue;
+          }
+          this.currentEvent = {
+            id: r,
+            depth: a ?? 0,
+            chain: [...u ?? [], r].slice(-z)
+          };
+          const h = this.instrumentObservers.size > 0, p = h ? this.state : void 0, f = h ? [] : void 0;
+          f !== void 0 && (this.changedPathSink = f);
+          const m = h ? _() : 0;
+          let y = S;
           try {
-            l = this.applyEventSync(a);
-          } catch (y) {
-            console.error("Emit reduce error:", y);
+            y = this.applyEventSync(d);
+          } catch (g) {
+            console.error("Emit reduce error:", g);
           } finally {
-            r && (this.changedPathSink = null);
+            h && (this.changedPathSink = null), this.currentEvent = null;
           }
-          r && this.emitInstrumentation(
-            a,
-            l,
-            c ?? [],
-            f,
-            z() - u
-          ), this.runEventEffects(a, l, d);
+          h && this.emitInstrumentation(
+            d,
+            y,
+            f ?? [],
+            p,
+            _() - m
+          ), this.runEventEffects(d, y, l);
         }
       } finally {
         this.isReducing = !1;
@@ -1421,32 +1805,45 @@ class $ {
    * @internal
    */
   applyEventSync(e) {
-    for (const s of this.middleware) {
-      const i = this.getMiddlewareWhen(s);
-      if (!this.matchesWhen(i, e)) continue;
-      const d = this.getMiddlewareFunction(s);
+    for (const c of this.middleware) {
+      const l = se(c);
+      if (!k(l, e)) continue;
+      const i = ne(c);
       let a;
       try {
-        a = d(this.state, e, this.emit), process.env.NODE_ENV !== "production" && typeof a?.then == "function" && console.error(
+        a = i(this.state, e, this.emit), process.env.NODE_ENV !== "production" && typeof a?.then == "function" && console.error(
           `[yoltra] Middleware for "${e.channel}/${e.type}" returned a Promise. Middleware is synchronous: a Promise is truthy, so this event was allowed without waiting and a "return false" inside it can never veto. Do the check synchronously, and put anything that must await in an effect.`
         );
-      } catch (r) {
-        console.error("Middleware error:", r), a = !1;
+      } catch (u) {
+        console.error("Middleware error:", u), a = !1;
       }
       if (!a)
-        return this.notifyEventSubscribers(e, "uncommitted"), !1;
+        return this.notifyEventSubscribers(e, "uncommitted"), S;
     }
-    const t = this.state;
-    this.reducerBus.emit(
-      e.channel,
-      e.type,
-      e.payload,
-      e
-    );
-    for (const [s, i] of this.patternReducers)
-      this.matchesWhen(i, e) && this.forwardEventGuarded(s, e);
-    const n = t !== this.state;
-    return this.notifyEventSubscribers(e, "committed"), n && this.listeners.forEach((s) => s()), !0;
+    const t = [];
+    this.stagingSink = t;
+    let s = null, n = "";
+    try {
+      this.reducerBus.emit(
+        e.channel,
+        e.type,
+        e.payload,
+        e
+      ), s = this.stagedRejection, n = this.stagedRejectedBy;
+      for (const [c, l] of this.patternReducers) {
+        if (s !== null) break;
+        if (k(l, e)) {
+          const i = this.stageSliceGuarded(c, e, t);
+          i !== null && (s = i, n = c);
+        }
+      }
+    } finally {
+      this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
+    }
+    if (s !== null)
+      return this.onRejected?.(s, e, n), this.notifyEventSubscribers(e, "committed"), { committed: !0, written: !1, rejected: s };
+    const r = this.commitStaged(t, e);
+    return this.notifyEventSubscribers(e, "committed"), r && (this.notifyEventSubscribers(e, "written"), this.listeners.forEach((c) => c())), r ? ce : oe;
   }
   /**
    * Runs a single committed event's effects as an **independent async task**,
@@ -1456,14 +1853,14 @@ class $ {
    *
    * @internal
    */
-  async runEventEffects(e, t, n) {
+  async runEventEffects(e, t, s) {
     this.inFlightEffects++;
     try {
-      t && await this.notifyEffects(e);
-    } catch (s) {
-      console.error("Effect error:", s);
+      t.committed && await this.notifyEffects(e);
+    } catch (n) {
+      console.error("Effect error:", n);
     } finally {
-      this.inFlightEffects--, n();
+      this.inFlightEffects--, s(t);
     }
   }
   /**
@@ -1479,16 +1876,16 @@ class $ {
   /**
    * 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
+   * by {@link commitStaged} during this reduce, so DevTools patches need no
    * re-diff.
    *
    * @internal
    */
-  emitInstrumentation(e, t, n, s, i) {
-    const d = {}, a = {};
-    for (const f of n)
-      d[f] = this.getAtPath(s, f), a[f] = this.getAtPath(this.state, f);
-    const r = {
+  emitInstrumentation(e, t, s, n, r) {
+    const c = {}, l = {};
+    for (const a of s)
+      c[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
+    const i = {
       event: {
         id: e.id,
         channel: e.channel,
@@ -1498,17 +1895,20 @@ class $ {
         // byte-identical to the pre-`meta` shape.
         ...e.meta !== void 0 ? { meta: e.meta } : {}
       },
-      committed: t,
-      changedPaths: n,
-      prevValues: d,
-      nextValues: a,
-      reduceTimeMs: i
+      committed: t.committed,
+      changedPaths: s,
+      prevValues: c,
+      nextValues: l,
+      reduceTimeMs: r,
+      // Present only when a reducer refused, so an observer can tell a refusal from a veto —
+      // identical in state, entirely different in cause.
+      ...t.rejected !== void 0 ? { rejected: t.rejected } : {}
     };
-    for (const f of [...this.instrumentObservers])
+    for (const a of [...this.instrumentObservers])
       try {
-        f(r);
-      } catch (c) {
-        console.error("Instrumentation observer error:", c);
+        a(i);
+      } catch (u) {
+        console.error("Instrumentation observer error:", u);
       }
   }
   /**
@@ -1539,8 +1939,13 @@ class $ {
    *
    * @public
    */
-  connect(e, t) {
-    return this.connectorBus.on(e.reducer, e.property, t);
+  connect(e, t, s) {
+    const n = this.connectorBus.on(e.reducer, e.property, t);
+    if (s?.immediate === !0) {
+      const r = this.state[e.reducer], c = e.property.includes("*") ? "" : e.property;
+      t({ oldValue: void 0, newValue: this.getAtPath(r, c), path: c });
+    }
+    return n;
   }
   /**
    * Subscribe to events by channel and type.
@@ -1588,11 +1993,11 @@ class $ {
    *
    * @public
    */
-  onEvent(e, t, n, s = "committed") {
-    const i = `${e}::${String(t)}`, d = s === "committed" ? this.committedEventSubscribers : s === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
-    return d.has(i) || d.set(i, /* @__PURE__ */ new Set()), d.get(i).add(n), () => {
-      const a = d.get(i);
-      a && (a.delete(n), a.size === 0 && d.delete(i));
+  onEvent(e, t, s, n = "committed") {
+    const r = `${e}::${String(t)}`, c = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : n === "written" ? this.writtenEventSubscribers : this.allEventSubscribers;
+    return c.has(r) || c.set(r, /* @__PURE__ */ new Set()), c.get(r).add(s), () => {
+      const l = c.get(r);
+      l && (l.delete(s), l.size === 0 && c.delete(r));
     };
   }
   /**
@@ -1698,8 +2103,8 @@ class $ {
       throw new Error(`Reducer ${e} already exists`);
     return this.mountSlice(e, t, {
       preserveState: !1
-    }), this.listeners.forEach((n) => n()), () => {
-      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((n) => n());
+    }), this.listeners.forEach((s) => s()), () => {
+      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((s) => s());
     };
   }
   /**
@@ -1734,30 +2139,118 @@ class $ {
    *
    * @public
    */
+  /**
+   * Sends a request and waits for the reply, correlating the two automatically.
+   *
+   * @typeParam C  - Request channel.
+   * @typeParam T  - Request type within `C`.
+   * @param channel - Channel to send on.
+   * @param type - Event type to send.
+   * @param payload - The **request** payload. This is what you are sending; what comes back is
+   * described by {@link CallOptions.reply}, not by this.
+   * @param opts - Which replies end the call, and how long to wait. See {@link CallOptions}.
+   * @returns A {@link CallHandle}: `await` it for the terminal reply, or `for await` it for
+   * progress events as they arrive.
+   *
+   * @remarks
+   * Every consumer of an event bus eventually writes request/reply by hand — mint an id,
+   * subscribe, match, time out, unsubscribe — and every one of them writes the same eighty lines
+   * with the same two bugs: the subscription outlives the call, and a responder that forgets to
+   * echo the id produces a timeout with nothing to point at. This is that, once.
+   *
+   * **Correlation is causal.** The store stamps `parentId` on anything emitted while an event is
+   * being handled, so a responder that replies through the `emit` it was handed is already
+   * correlated. There is no id to mint, echo, or forget:
+   *
+   * ```ts
+   * store.registerEffect({
+   *   when: { keys: [["rpc", "ask"]] },
+   *   effect: async (event, _get, emit) => {
+   *     await emit("rpc", "answer", await lookup(event.payload.q));
+   *   },
+   * });
+   * ```
+   *
+   * **The reply carries its own discriminant.** A call resolves to the *event*, not the payload,
+   * because a caller often cannot know which kind of reply it will get:
+   *
+   * ```ts
+   * const res = await store.call("rpc", "ask", { q }, { reply: ["rpc", ["answer", "error"]] });
+   * switch (res.type) {
+   *   case "answer": return res.payload;
+   *   case "error":  throw new Error(res.payload.reason);
+   * }
+   * ```
+   *
+   * **Progress streams, with backpressure.** Any correlated event that is not terminal is
+   * progress, and iterating the call consumes it. The producer genuinely waits: `emit` resolves
+   * only once its effects have run, and the collector is an effect that does not return until the
+   * consumer has taken the item. A responder writing `await emit("rpc", "progress", chunk)` is
+   * therefore paced by the reader, with nothing buffering without bound.
+   *
+   * ```ts
+   * const call = store.call("job", "start", { id }, {
+   *   reply: ["job", "done"],
+   *   highWaterMark: 4,
+   * });
+   * for await (const step of call) await render(step.payload); // producer waits on this
+   * const { payload } = await call;
+   * ```
+   *
+   * Backpressure engages **once you begin iterating**. A call that is only awaited never pulls,
+   * so blocking its producer would deadlock the call itself — progress nobody reads would stop
+   * the terminal event from ever being sent. Un-iterated progress therefore buffers to
+   * `highWaterMark` and is then counted on {@link CallHandle.dropped} rather than blocking.
+   *
+   * **This is a local primitive.**
+   *
+   * @example Timeout is idle, not total
+   * ```ts
+   * // Survives a job that streams for minutes; fails a responder that goes quiet for 5s.
+   * await store.call("job", "start", { id }, { reply: ["job", "done"], timeoutMs: 5_000 });
+   * ```
+   *
+   * @example Cancelling
+   * ```ts
+   * const call = store.call("rpc", "ask", { q }, { reply: ["rpc", "answer"] });
+   * useEffect(() => () => call.cancel("unmounted"), [call]);
+   * ```
+   *
+   * @public
+   */
+  call(e, t, s, n) {
+    return Z(
+      { idFactory: this.idFactory, registerEffect: this.registerEffect, emit: this.emit },
+      e,
+      t,
+      s,
+      n
+    );
+  }
   registerEffect(e) {
-    const { effect: t, meta: n, when: s } = e, i = [];
-    if (n && this.effectMeta.set(t, n), s && ("any" in s && s.any === !0 || "channel" in s || "channels" in s)) {
-      const r = { effect: t, when: s };
-      return this.patternEffects.add(r), () => {
-        this.patternEffects.delete(r);
+    const { effect: t, meta: s, when: n } = e, r = [];
+    if (s && this.effectMeta.set(t, s), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
+      const i = { effect: t, when: n };
+      return this.patternEffects.add(i), () => {
+        this.patternEffects.delete(i);
       };
     }
-    const a = this.normalizeEventKeys(e);
-    if (a.length === 0 && !s) {
-      const r = { effect: t, when: { any: !0 } };
-      return this.patternEffects.add(r), () => {
-        this.patternEffects.delete(r);
+    const l = D(e);
+    if (l.length === 0 && !n) {
+      const i = { effect: t, when: { any: !0 } };
+      return this.patternEffects.add(i), () => {
+        this.patternEffects.delete(i);
       };
     }
-    for (const [r, f] of a) {
-      const c = `${String(r)}::${String(f)}`;
-      this.effects.has(c) || this.effects.set(c, /* @__PURE__ */ new Set()), this.effects.get(c).add(t), i.push(() => {
-        const u = this.effects.get(c);
-        u && (u.delete(t), u.size === 0 && this.effects.delete(c));
+    for (const [i, a] of l) {
+      const u = `${String(i)}::${String(a)}`;
+      this.effects.has(u) || this.effects.set(u, /* @__PURE__ */ new Set()), this.effects.get(u).add(t), r.push(() => {
+        const d = this.effects.get(u);
+        d && (d.delete(t), d.size === 0 && this.effects.delete(u));
       });
     }
     return () => {
-      for (const r of i) r();
+      for (const i of r) i();
     };
   }
   /**
@@ -1781,15 +2274,15 @@ class $ {
    *
    * @public
    */
-  onEffect(e, t, n) {
-    const s = async (i, d, a) => {
-      if (i.channel !== e || i.type !== t) return;
-      const r = i;
-      return n(r.payload, d, a, r);
+  onEffect(e, t, s) {
+    const n = async (r, c, l) => {
+      if (r.channel !== e || r.type !== t) return;
+      const i = r;
+      return s(i.payload, c, l, i);
     };
     return this.registerEffect({
       when: { keys: [[e, t]] },
-      effect: s
+      effect: n
     });
   }
   /**
@@ -1851,11 +2344,11 @@ class $ {
    * @public
    */
   replaceReducers(e, t = {}) {
-    const n = t.preserveState !== !1, s = new Set(Object.keys(this.reducers)), i = Object.entries(e), d = new Set(i.map(([a]) => a));
-    for (const a of s)
-      d.has(a) || this.unmountSlice(a, { deleteState: !0 });
-    for (const [a, r] of i)
-      s.has(a) ? (this.unmountSlice(a, { deleteState: !1 }), this.mountSlice(a, r, { preserveState: n })) : this.mountSlice(a, r, { preserveState: !1 });
+    const s = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), r = Object.entries(e), c = new Set(r.map(([l]) => l));
+    for (const l of n)
+      c.has(l) || this.unmountSlice(l, { deleteState: !0 });
+    for (const [l, i] of r)
+      n.has(l) ? (this.unmountSlice(l, { deleteState: !1 }), this.mountSlice(l, i, { preserveState: s })) : this.mountSlice(l, i, { preserveState: !1 });
   }
   /**
    * Convenience API to replace **any subset** of store parts (HMR patterns).
@@ -1887,34 +2380,36 @@ class $ {
    *
    * @internal
    */
-  mountSlice(e, t, n) {
-    const s = e, { reducer: i, state: d, when: a } = t;
-    if (this.reducers[e] = new K(i), (!n.preserveState || this.state[s] === void 0) && (this.state = {
+  mountSlice(e, t, s) {
+    const n = e, { reducer: r, state: c, when: l } = t;
+    if (this.reducers[e] = new L(r), (!s.preserveState || this.state[n] === void 0) && (this.state = {
       ...this.state,
-      [s]: P(W(s, d))
-    }), a && ("any" in a && a.any === !0 || "channel" in a || "channels" in a)) {
-      this.patternReducers.set(e, a), this.sliceUnsubs.set(s, []);
+      [n]: R(re(n, c))
+    }), l && ("any" in l && l.any === !0 || "channel" in l || "channels" in l)) {
+      this.patternReducers.set(e, l), this.sliceUnsubs.set(n, []);
       return;
     }
-    const f = this.normalizeEventKeys(t);
-    if (f.length === 0 && !a) {
-      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(s, []);
+    const a = D(t);
+    if (a.length === 0 && !l) {
+      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
       return;
     }
-    const c = [];
-    for (const [u, l] of f) {
-      const y = this.reducerBus.on(u, l, (h, m) => {
-        const g = m ?? {
-          channel: u,
-          type: l,
-          payload: h,
+    const u = [];
+    for (const [d, h] of a) {
+      const p = this.reducerBus.on(d, h, (f, m) => {
+        const y = m ?? {
+          channel: d,
+          type: h,
+          payload: f,
           id: this.idFactory()
         };
-        this.forwardEventGuarded(e, g);
+        if (this.stagingSink === null) return;
+        const g = this.stageSliceGuarded(e, y, this.stagingSink);
+        g !== null && this.stagedRejection === null && (this.stagedRejection = g, this.stagedRejectedBy = e);
       });
-      c.push(y);
+      u.push(p);
     }
-    this.sliceUnsubs.set(s, c);
+    this.sliceUnsubs.set(n, u);
   }
   /**
    * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
@@ -1926,38 +2421,22 @@ class $ {
    * @internal
    */
   unmountSlice(e, t) {
-    const n = e;
+    const s = e;
     this.patternReducers.delete(e);
-    const s = this.sliceUnsubs.get(n);
-    if (s) {
-      for (const i of s)
+    const n = this.sliceUnsubs.get(s);
+    if (n) {
+      for (const r of n)
         try {
-          i();
-        } catch (d) {
-          console.error(`[Store error]: ${d}`);
+          r();
+        } catch (c) {
+          console.error(`[Store error]: ${c}`);
         }
-      this.sliceUnsubs.delete(n);
+      this.sliceUnsubs.delete(s);
     }
     if (delete this.reducers[e], t.deleteState) {
-      const { [n]: i, ...d } = this.state;
-      this.state = d;
-    }
-  }
-  /**
-   * Normalizes event targeting from `when` to an array of EventKeys.
-   *
-   * @param spec - Object with an optional `when` matcher.
-   * @returns Array of `[channel, type]` pairs.
-   *
-   * @internal
-   */
-  normalizeEventKeys(e) {
-    if (e.when) {
-      const t = e.when;
-      if ("keys" in t)
-        return t.keys;
+      const { [s]: r, ...c } = this.state;
+      this.state = c;
     }
-    return [];
   }
   /**
    * Reads a dotted path from an object (supports numeric array indices via string keys).
@@ -1966,17 +2445,14 @@ class $ {
    * @param path - Dotted path; leading dot is ignored.
    * @returns The value at the path, or `undefined`.
    *
+   * @remarks
+   * A member rather than a bare import: a test replaces this on the instance to count how many
+   * walks describing a change costs, which only works while the callers go through `this`.
+   *
    * @internal
    */
   getAtPath(e, t) {
-    if (!t) return e;
-    const s = (t[0] === "." ? t.slice(1) : t).split(".");
-    let i = e;
-    for (const d of s) {
-      if (i == null) return;
-      i = i[d];
-    }
-    return i;
+    return ee(e, t);
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -1994,268 +2470,259 @@ class $ {
    * @public
    */
   static buildAncestorPaths(e) {
-    if (!e) return [];
-    const n = (e[0] === "." ? e.slice(1) : e).split("."), s = [];
-    for (let i = 0; i < n.length; i++)
-      s.push(n.slice(0, i + 1).join("."));
-    return s;
+    return te(e);
   }
 }
-function L(o) {
-  return new $({
-    name: o.name,
+function he(o) {
+  return new x({
+    ...o,
     reducer: o.reducer ?? {},
     middleware: o.middleware ?? [],
-    effects: o.effects ?? [],
-    dedupWindowMs: o.dedupWindowMs,
-    idFactory: o.idFactory,
-    devtools: o.devtools,
-    onEffectError: o.onEffectError,
-    onReducerError: o.onReducerError
+    effects: o.effects ?? []
   });
 }
-const G = (o) => (e, t) => t.map((n) => [e, n]), Q = () => (o) => o, I = /* @__PURE__ */ new Set();
-function j(o) {
+const pe = (o) => (e, t) => t.map((s) => [e, s]), me = () => (o) => o, j = /* @__PURE__ */ new Set();
+function ae(o) {
   const e = String(o);
-  I.has(e) || (I.add(e), console.warn(
+  j.has(e) || (j.add(e), console.warn(
     `[yoltra] Entity id "${e}" contains a dot. Paths are dotted, so a subscription to "entities.${e}" is indistinguishable from one to a nested object of the same name. Use ids without dots.`
   ));
 }
-function F(o, e) {
+function le(o, e) {
   if (o.length !== e.length) return e;
   for (let t = 0; t < o.length; t++)
     if (o[t] !== e[t]) return e;
   return o;
 }
-function J(o = {}) {
-  const e = o.selectId ?? ((r) => r.id), { sortComparer: t } = o, n = (r, f) => {
-    if (t === void 0) return f;
-    const c = [...f].sort((u, l) => {
-      const y = r.entities[u], h = r.entities[l];
-      return y === void 0 || h === void 0 ? 0 : t(y, h);
+function ye(o = {}) {
+  const e = o.selectId ?? ((i) => i.id), { sortComparer: t } = o, s = (i, a) => {
+    if (t === void 0) return a;
+    const u = [...a].sort((d, h) => {
+      const p = i.entities[d], f = i.entities[h];
+      return p === void 0 || f === void 0 ? 0 : t(p, f);
     });
-    return F(f, c);
-  }, s = (r, f, c) => {
-    const u = { ...r, entities: f, ids: c };
-    return { ...u, ids: n(u, c) };
-  }, i = (r, f, c) => {
-    let u = null, l = null;
-    for (const y of f) {
-      const h = e(y);
-      process.env.NODE_ENV !== "production" && String(h).includes(".") && j(h);
-      const m = (u ?? r.entities)[h];
-      if (m !== void 0 && c === "add") continue;
-      const g = m !== void 0 && c === "upsert" ? { ...m, ...y } : y;
-      u ?? (u = { ...r.entities }), u[h] = g, m === void 0 && (l ?? (l = [...r.ids]), l.push(h));
+    return le(a, u);
+  }, n = (i, a, u) => {
+    const d = { ...i, entities: a, ids: u };
+    return { ...d, ids: s(d, u) };
+  }, r = (i, a, u) => {
+    let d = null, h = null;
+    for (const p of a) {
+      const f = e(p);
+      process.env.NODE_ENV !== "production" && String(f).includes(".") && ae(f);
+      const m = (d ?? i.entities)[f];
+      if (m !== void 0 && u === "add") continue;
+      const y = m !== void 0 && u === "upsert" ? { ...m, ...p } : p;
+      d ??= { ...i.entities }, d[f] = y, m === void 0 && (h ??= [...i.ids], h.push(f));
     }
-    return u === null ? r : s(r, u, l ?? r.ids);
-  }, d = (r, f) => {
-    let c = null;
-    for (const { id: u, changes: l } of f) {
-      const y = (c ?? r.entities)[u];
-      y !== void 0 && (c ?? (c = { ...r.entities }), c[u] = { ...y, ...l });
+    return d === null ? i : n(i, d, h ?? i.ids);
+  }, c = (i, a) => {
+    let u = null;
+    for (const { id: d, changes: h } of a) {
+      const p = (u ?? i.entities)[d];
+      p !== void 0 && (u ??= { ...i.entities }, u[d] = { ...p, ...h });
     }
-    return c === null ? r : s(r, c, r.ids);
-  }, a = (r, f) => {
-    const c = new Set(f.filter((l) => r.entities[l] !== void 0));
-    if (c.size === 0) return r;
-    const u = { ...r.entities };
-    for (const l of c) delete u[l];
-    return s(
-      r,
-      u,
-      r.ids.filter((l) => !c.has(l))
+    return u === null ? i : n(i, u, i.ids);
+  }, l = (i, a) => {
+    const u = new Set(a.filter((h) => i.entities[h] !== void 0));
+    if (u.size === 0) return i;
+    const d = { ...i.entities };
+    for (const h of u) delete d[h];
+    return n(
+      i,
+      d,
+      i.ids.filter((h) => !u.has(h))
     );
   };
   return {
-    getInitialState(r) {
-      const f = { ids: [], entities: {} };
-      return r === void 0 ? f : { ...f, ...r };
+    getInitialState(i) {
+      const a = { ids: [], entities: {} };
+      return i === void 0 ? a : { ...a, ...i };
     },
-    addOne: (r, f) => i(r, [f], "add"),
-    addMany: (r, f) => i(r, f, "add"),
-    setOne: (r, f) => i(r, [f], "set"),
-    setMany: (r, f) => i(r, f, "set"),
-    setAll: (r, f) => {
-      const c = {}, u = [];
-      for (const l of f) {
-        const y = e(l);
-        c[y] === void 0 && u.push(y), c[y] = l;
+    addOne: (i, a) => r(i, [a], "add"),
+    addMany: (i, a) => r(i, a, "add"),
+    setOne: (i, a) => r(i, [a], "set"),
+    setMany: (i, a) => r(i, a, "set"),
+    setAll: (i, a) => {
+      const u = {}, d = [];
+      for (const h of a) {
+        const p = e(h);
+        u[p] === void 0 && d.push(p), u[p] = h;
       }
-      return s(r, c, u);
+      return n(i, u, d);
     },
-    updateOne: (r, f) => d(r, [f]),
-    updateMany: (r, f) => d(r, f),
-    upsertOne: (r, f) => i(r, [f], "upsert"),
-    upsertMany: (r, f) => i(r, f, "upsert"),
-    removeOne: (r, f) => a(r, [f]),
-    removeMany: (r, f) => a(r, f),
-    removeAll: (r) => r.ids.length === 0 ? r : s(r, {}, []),
-    selectIds: (r) => r.ids,
-    selectEntities: (r) => r.entities,
-    selectAll: (r) => r.ids.map((f) => r.entities[f]),
-    selectById: (r, f) => r.entities[f],
-    selectTotal: (r) => r.ids.length,
+    updateOne: (i, a) => c(i, [a]),
+    updateMany: (i, a) => c(i, a),
+    upsertOne: (i, a) => r(i, [a], "upsert"),
+    upsertMany: (i, a) => r(i, a, "upsert"),
+    removeOne: (i, a) => l(i, [a]),
+    removeMany: (i, a) => l(i, a),
+    removeAll: (i) => i.ids.length === 0 ? i : n(i, {}, []),
+    selectIds: (i) => i.ids,
+    selectEntities: (i) => i.entities,
+    selectAll: (i) => i.ids.map((a) => i.entities[a]),
+    selectById: (i, a) => i.entities[a],
+    selectTotal: (i) => i.ids.length,
     idsPath: "ids",
-    pathTo: (r, f) => f === void 0 ? `entities.${r}` : `entities.${r}.${f}`,
-    anyField: (r) => `entities.*.${r}`
+    pathTo: (i, a) => a === void 0 ? `entities.${i}` : `entities.${i}.${a}`,
+    anyField: (i) => `entities.*.${i}`
   };
 }
-const E = "$yoltra";
-function _(o, e = {}) {
-  const t = e.maxNodes ?? 1e5, n = e.sanitize, s = [], i = /* @__PURE__ */ new Map();
-  let d = 0, a = !1;
-  function r(c, u) {
-    if (n !== void 0 && (c = n(u, c)), d += 1, d > t)
-      return a = !0, { [E]: "unsupported", kind: "truncated" };
-    switch (typeof c) {
+const w = "$yoltra";
+function H(o, e = {}) {
+  const t = e.maxNodes ?? 1e5, s = e.sanitize, n = [], r = /* @__PURE__ */ new Map();
+  let c = 0, l = !1;
+  function i(u, d) {
+    if (s !== void 0 && (u = s(d, u)), c += 1, c > t)
+      return l = !0, { [w]: "unsupported", kind: "truncated" };
+    switch (typeof u) {
       case "undefined":
-        return { [E]: "undefined" };
+        return { [w]: "undefined" };
       case "bigint":
-        return { [E]: "bigint", value: c.toString() };
+        return { [w]: "bigint", value: u.toString() };
       case "number":
-        return Number.isNaN(c) ? { [E]: "nan" } : c === 1 / 0 ? { [E]: "infinity", sign: 1 } : c === -1 / 0 ? { [E]: "infinity", sign: -1 } : c;
+        return Number.isNaN(u) ? { [w]: "nan" } : u === 1 / 0 ? { [w]: "infinity", sign: 1 } : u === -1 / 0 ? { [w]: "infinity", sign: -1 } : u;
       case "function":
       case "symbol":
-        return s.push(u), { [E]: "unsupported", kind: typeof c };
+        return n.push(d), { [w]: "unsupported", kind: typeof u };
       case "string":
       case "boolean":
-        return c;
+        return u;
     }
-    if (c === null) return null;
-    const l = c, y = i.get(l);
-    if (y !== void 0) return { [E]: "ref", path: y };
-    if (i.set(l, u), c instanceof Date)
-      return { [E]: "date", iso: c.toISOString() };
-    if (c instanceof RegExp)
-      return { [E]: "regexp", source: c.source, flags: c.flags };
-    if (c instanceof Error)
-      return { [E]: "error", name: c.name, message: c.message };
-    if (c instanceof Map) {
+    if (u === null) return null;
+    const h = u, p = r.get(h);
+    if (p !== void 0) return { [w]: "ref", path: p };
+    if (r.set(h, d), u instanceof Date)
+      return { [w]: "date", iso: u.toISOString() };
+    if (u instanceof RegExp)
+      return { [w]: "regexp", source: u.source, flags: u.flags };
+    if (u instanceof Error)
+      return { [w]: "error", name: u.name, message: u.message };
+    if (u instanceof Map) {
       const m = [];
-      let g = 0;
-      for (const [w, D] of c)
-        m.push([r(w, `${u}/@k${g}`), r(D, `${u}/${g}`)]), g += 1;
-      return { [E]: "map", entries: m };
+      let y = 0;
+      for (const [g, $] of u)
+        m.push([i(g, `${d}/@k${y}`), i($, `${d}/${y}`)]), y += 1;
+      return { [w]: "map", entries: m };
     }
-    if (c instanceof Set) {
+    if (u instanceof Set) {
       const m = [];
-      let g = 0;
-      for (const w of c)
-        m.push(r(w, `${u}/${g}`)), g += 1;
-      return { [E]: "set", values: m };
+      let y = 0;
+      for (const g of u)
+        m.push(i(g, `${d}/${y}`)), y += 1;
+      return { [w]: "set", values: m };
     }
-    if (Array.isArray(c))
-      return c.map((m, g) => r(m, `${u}/${g}`));
-    const h = {};
-    for (const [m, g] of Object.entries(c))
-      h[m] = r(g, `${u}/${A(m)}`);
-    return E in h ? { [E]: "escaped", value: h } : h;
-  }
-  return { value: r(o, ""), report: { truncated: a, unsupported: s } };
+    if (Array.isArray(u))
+      return u.map((m, y) => i(m, `${d}/${y}`));
+    const f = {};
+    for (const [m, y] of Object.entries(u))
+      f[m] = i(y, `${d}/${F(m)}`);
+    return w in f ? { [w]: "escaped", value: f } : f;
+  }
+  return { value: i(o, ""), report: { truncated: l, unsupported: n } };
 }
-function V(o) {
+function ue(o) {
   const e = /* @__PURE__ */ new Map(), t = [];
-  function n(d, a) {
-    if (d === null || typeof d != "object") return d;
-    if (Array.isArray(d)) {
-      const f = [];
-      return e.set(a, f), d.forEach((c, u) => {
-        if (R(c)) {
-          t.push({ target: f, key: u, path: c.path }), f[u] = void 0;
+  function s(c, l) {
+    if (c === null || typeof c != "object") return c;
+    if (Array.isArray(c)) {
+      const a = [];
+      return e.set(l, a), c.forEach((u, d) => {
+        if (N(u)) {
+          t.push({ target: a, key: d, path: u.path }), a[d] = void 0;
           return;
         }
-        f[u] = n(c, `${a}/${u}`);
-      }), f;
+        a[d] = s(u, `${l}/${d}`);
+      }), a;
     }
-    if (typeof d[E] == "string") {
-      const f = d;
-      switch (f[E]) {
+    if (typeof c[w] == "string") {
+      const a = c;
+      switch (a[w]) {
         case "undefined":
           return;
         case "nan":
           return Number.NaN;
         case "infinity":
-          return f.sign === 1 ? 1 / 0 : -1 / 0;
+          return a.sign === 1 ? 1 / 0 : -1 / 0;
         case "bigint":
-          return BigInt(f.value);
+          return BigInt(a.value);
         case "date":
-          return new Date(f.iso);
+          return new Date(a.iso);
         case "regexp":
-          return new RegExp(f.source, f.flags);
+          return new RegExp(a.source, a.flags);
         case "error": {
-          const c = new Error(f.message);
-          return c.name = f.name, c;
+          const u = new Error(a.message);
+          return u.name = a.name, u;
         }
         case "unsupported":
           return;
         case "ref":
           return;
         case "map": {
-          const c = /* @__PURE__ */ new Map();
-          return e.set(a, c), f.entries.forEach(([u, l], y) => {
-            c.set(n(u, `${a}/@k${y}`), n(l, `${a}/${y}`));
-          }), c;
+          const u = /* @__PURE__ */ new Map();
+          return e.set(l, u), a.entries.forEach(([d, h], p) => {
+            u.set(s(d, `${l}/@k${p}`), s(h, `${l}/${p}`));
+          }), u;
         }
         case "set": {
-          const c = /* @__PURE__ */ new Set();
-          return e.set(a, c), f.values.forEach((u, l) => c.add(n(u, `${a}/${l}`))), c;
+          const u = /* @__PURE__ */ new Set();
+          return e.set(l, u), a.values.forEach((d, h) => u.add(s(d, `${l}/${h}`))), u;
         }
         case "escaped":
-          return s(f.value, a);
+          return n(a.value, l);
         default:
           return;
       }
     }
-    return s(d, a);
-  }
-  function s(d, a) {
-    const r = {};
-    e.set(a, r);
-    for (const [f, c] of Object.entries(d)) {
-      const u = `${a}/${A(f)}`;
-      if (R(c)) {
-        t.push({ target: r, key: f, path: c.path }), r[f] = void 0;
+    return n(c, l);
+  }
+  function n(c, l) {
+    const i = {};
+    e.set(l, i);
+    for (const [a, u] of Object.entries(c)) {
+      const d = `${l}/${F(a)}`;
+      if (N(u)) {
+        t.push({ target: i, key: a, path: u.path }), i[a] = void 0;
         continue;
       }
-      r[f] = n(c, u);
+      i[a] = s(u, d);
     }
-    return r;
+    return i;
   }
-  const i = n(o, "");
-  e.set("", i);
-  for (const { target: d, key: a, path: r } of t)
-    d[a] = e.get(r);
-  return i;
+  const r = s(o, "");
+  e.set("", r);
+  for (const { target: c, key: l, path: i } of t)
+    c[l] = e.get(i);
+  return r;
 }
-function R(o) {
-  return o !== null && typeof o == "object" && o[E] === "ref" && typeof o.path == "string";
+function N(o) {
+  return o !== null && typeof o == "object" && o[w] === "ref" && typeof o.path == "string";
 }
-function A(o) {
+function F(o) {
   return o.replace(/~/g, "~0").replace(/\//g, "~1");
 }
-function Y(o, e, t = {}) {
-  let n = t.maxNodes ?? 1e5;
-  for (let s = 0; s < 8; s += 1) {
-    const { value: i, report: d } = _(o, { ...t, maxNodes: n });
-    let a;
+function ge(o, e, t = {}) {
+  let s = t.maxNodes ?? 1e5;
+  for (let n = 0; n < 8; n += 1) {
+    const { value: r, report: c } = H(o, { ...t, maxNodes: s });
+    let l;
     try {
-      a = JSON.stringify(i)?.length ?? 0;
+      l = JSON.stringify(r)?.length ?? 0;
     } catch {
-      a = Number.POSITIVE_INFINITY;
+      l = Number.POSITIVE_INFINITY;
     }
-    if (a <= e)
-      return d.truncated ? {
-        value: i,
+    if (l <= e)
+      return c.truncated ? {
+        value: r,
         truncated: !0,
-        note: `State was too large to send in full; parts beyond ${n} nodes are omitted.`
-      } : { value: i, truncated: !1 };
-    const r = Math.floor(n * e * 0.8 / a);
-    if (n = Math.max(1, Math.min(r, n - 1)), n <= 1 && s > 0)
+        note: `State was too large to send in full; parts beyond ${s} nodes are omitted.`
+      } : { value: r, truncated: !1 };
+    const i = Math.floor(s * e * 0.8 / l);
+    if (s = Math.max(1, Math.min(i, s - 1)), s <= 1 && n > 0)
       break;
   }
   return {
-    value: { [E]: "unsupported", kind: "truncated" },
+    value: { [w]: "unsupported", kind: "truncated" },
     truncated: !0,
     note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
   };
@@ -2263,104 +2730,104 @@ function Y(o, e, t = {}) {
 function b(o, e, t) {
   o.onError?.(e, t);
 }
-async function q(o) {
+async function we(o) {
   const e = { slices: {}, restored: !1 };
   let t;
   try {
     t = o.source ?? await o.adapter.read(o.key);
-  } catch (s) {
-    return b(o, s, "read"), e;
+  } catch (n) {
+    return b(o, n, "read"), e;
   }
   if (t == null || t === "") return e;
-  let n;
+  let s;
   try {
-    n = V(JSON.parse(t));
-  } catch (s) {
-    return b(o, s, "decode"), e;
+    s = ue(JSON.parse(t));
+  } catch (n) {
+    return b(o, n, "decode"), e;
   }
-  if (n === null || typeof n != "object" || typeof n.version != "number")
+  if (s === null || typeof s != "object" || typeof s.version != "number")
     return b(o, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
-  if (n.version !== o.version) {
+  if (s.version !== o.version) {
     if (o.migrate === void 0)
       return b(
         o,
         new Error(
-          `persisted state is version ${n.version}, this build expects ${o.version}, and no migrate was supplied`
+          `persisted state is version ${s.version}, this build expects ${o.version}, and no migrate was supplied`
         ),
         "migrate"
       ), e;
     try {
-      const s = o.migrate(n.slices, n.version);
-      return s === null ? e : { slices: s, restored: !0 };
-    } catch (s) {
-      return b(o, s, "migrate"), e;
+      const n = o.migrate(s.slices, s.version);
+      return n === null ? e : { slices: n, restored: !0 };
+    } catch (n) {
+      return b(o, n, "migrate"), e;
     }
   }
-  return { slices: n.slices ?? {}, restored: !0 };
+  return { slices: s.slices ?? {}, restored: !0 };
 }
-function X(o, e) {
+function Ee(o, e) {
   if (!e.restored) return o;
   const t = {};
-  for (const [n, s] of Object.entries(o)) {
-    const i = e.slices[n];
-    t[n] = i === void 0 ? s : { ...s, state: i };
+  for (const [s, n] of Object.entries(o)) {
+    const r = e.slices[s];
+    t[s] = r === void 0 ? n : { ...n, state: r };
   }
   return t;
 }
-function N(o, e) {
-  const t = o ?? {}, n = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((s) => s in t).map((s) => [s, t[s]]));
-  return JSON.stringify(_({ version: e.version, slices: n }).value);
+function K(o, e) {
+  const t = o ?? {}, s = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((n) => n in t).map((n) => [n, t[n]]));
+  return JSON.stringify(H({ version: e.version, slices: s }).value);
 }
-function Z(o, e) {
-  const t = e.throttleMs ?? 250, n = e.slices;
-  let s = null, i = !1;
-  const d = () => {
-    if (i) {
-      i = !1;
+function be(o, e) {
+  const t = e.throttleMs ?? 250, s = e.slices;
+  let n = null, r = !1;
+  const c = () => {
+    if (r) {
+      r = !1;
       try {
-        const f = e.adapter.write(e.key, N(o.getState(), e));
-        f instanceof Promise && f.catch((c) => b(e, c, "write"));
-      } catch (f) {
-        b(e, f, "write");
+        const a = e.adapter.write(e.key, K(o.getState(), e));
+        a instanceof Promise && a.catch((u) => b(e, u, "write"));
+      } catch (a) {
+        b(e, a, "write");
       }
     }
-  }, a = () => {
-    if (i = !0, t <= 0) {
-      d();
+  }, l = () => {
+    if (r = !0, t <= 0) {
+      c();
       return;
     }
-    s === null && (s = setTimeout(() => {
-      s = null, d();
-    }, t), s.unref?.());
-  }, r = o.instrument((f) => {
-    if (n === void 0) {
-      a();
+    n === null && (n = setTimeout(() => {
+      n = null, c();
+    }, t), n.unref?.());
+  }, i = o.instrument((a) => {
+    if (s === void 0) {
+      l();
       return;
     }
-    (f.changedPaths ?? []).some(
-      (u) => n.some((l) => u === l || u.startsWith(`${l}.`))
-    ) && a();
+    (a.changedPaths ?? []).some(
+      (d) => s.some((h) => d === h || d.startsWith(`${h}.`))
+    ) && l();
   });
   return () => {
-    r(), s !== null && (clearTimeout(s), s = null), d();
+    i(), n !== null && (clearTimeout(n), n = null), c();
   };
 }
-function ee(o, e) {
-  return N(o.getState(), e);
+function ve(o, e) {
+  return K(o.getState(), e);
 }
-function te(o) {
+function Se(o) {
   return {
     read: (e) => o.getItem(e),
     write: (e, t) => o.setItem(e, t),
     remove: (e) => o.removeItem(e)
   };
 }
-function se(o) {
+function $e(o) {
   const e = new Map(Object.entries(o ?? {}));
   return {
     read: (t) => e.get(t) ?? null,
-    write: (t, n) => {
-      e.set(t, n);
+    write: (t, s) => {
+      e.set(t, s);
     },
     remove: (t) => {
       e.delete(t);
@@ -2368,24 +2835,28 @@ function se(o) {
   };
 }
 export {
-  B as EventBus,
-  H as LooseEventBus,
-  K as Reducer,
-  $ as Store,
-  J as createEntityAdapter,
-  se as createMemoryAdapter,
-  L as createStore,
-  te as createWebStorageAdapter,
-  V as decodeState,
-  ee as dehydrate,
-  O as detectChangedProps,
-  _ as encodeState,
-  Y as encodeStateBounded,
-  Q as eventKeys,
-  S as freezeState,
-  q as hydrate,
-  Z as persist,
-  G as typedEvents,
-  X as withHydration
+  C as CallAbortedError,
+  Q as CallTimeoutError,
+  W as EventBus,
+  U as LooseEventBus,
+  L as Reducer,
+  fe as Rejected,
+  x as Store,
+  ye as createEntityAdapter,
+  $e as createMemoryAdapter,
+  he as createStore,
+  Se as createWebStorageAdapter,
+  ue as decodeState,
+  ve as dehydrate,
+  I as detectChangedProps,
+  H as encodeState,
+  ge as encodeStateBounded,
+  me as eventKeys,
+  M as freezeState,
+  we as hydrate,
+  V as isRejected,
+  be as persist,
+  pe as typedEvents,
+  Ee as withHydration
 };
 //# sourceMappingURL=yoltra.mjs.map