@yoltra/core 0.5.0 → 0.6.0

package/dist/yoltra.mjs

@@ -1,5 +1,5 @@
 /*!
- * @yoltra/core v0.5.0
+ * @yoltra/core v0.6.0
  * (c) 2026 Manu Ramirez <@pixerael>
  * License: MIT
  * Homepage: https://yoltra.dev
@@ -7,10 +7,10 @@
  * 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 {
+var K = Object.defineProperty;
+var F = (c, e, t) => e in c ? K(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var p = (c, e, t) => F(c, typeof e != "symbol" ? e + "" : e, t);
+class U {
   constructor() {
     /**
      * Internal registry: `channel → type → Set<handler>`.
@@ -50,11 +50,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 +76,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 +104,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 o = r.get(t);
+    if (!(!o || o.size === 0))
+      for (const l of [...o])
         try {
-          a(n, s);
-        } catch (r) {
-          console.error("EventBus handler error:", r);
+          l(s, n);
+        } catch (i) {
+          console.error("EventBus handler error:", i);
         }
   }
   /**
@@ -133,7 +133,7 @@ class B {
     this.handlers.clear();
   }
 }
-class H {
+class L {
   constructor() {
     /**
      * Exact handlers: `channel → type → [handlers]`.
@@ -196,18 +196,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 o = this.patternHandlers.get(e);
+      return o.has(r) || (o.set(r, []), this.indexPattern(e, r)), o.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 o = this.handlers.get(e);
+      return o.has(r) || o.set(r, []), o.get(r).push(s), () => this.offExactNormalized(e, r, s);
     }
   }
   /**
@@ -228,9 +228,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 +240,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 o = r.indexOf(s);
+    o !== -1 && r.splice(o, 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 +256,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 o = r.indexOf(s);
+    o !== -1 && r.splice(o, 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 +284,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), o = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n), i = /* @__PURE__ */ new Set(), a = (d) => {
+      for (const u of [...d])
+        if (!i.has(u)) {
+          i.add(u);
           try {
-            u(n);
-          } catch (l) {
-            console.error(l);
+            u(s);
+          } catch (f) {
+            console.error(f);
             continue;
           }
         }
     };
-    f(d);
-    for (const c of a) f(c);
+    a(o);
+    for (const d of l) a(d);
   }
   /**
    * Emits a payload that is only built if somebody is listening.
@@ -316,23 +316,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), o = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n);
+    if (o.length === 0 && l.length === 0) return;
+    const i = s(), a = /* @__PURE__ */ new Set(), d = (u) => {
+      for (const f of [...u])
+        if (!a.has(f)) {
+          a.add(f);
           try {
-            l(r);
-          } catch (y) {
-            console.error(y);
+            f(i);
+          } catch (m) {
+            console.error(m);
             continue;
           }
         }
     };
-    c(d);
-    for (const u of a) c(u);
+    d(o);
+    for (const u of l) d(u);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -371,27 +371,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 }, o = n[0];
+    if (o === void 0 || o === "*" || o === "**") {
+      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(o);
+    l === void 0 ? s.byHead.set(o, [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 o = r.findIndex((l) => l.pattern === t);
+    o !== -1 && r.splice(o, 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 +405,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), o = [], l = (a) => {
+      for (const d of a) {
+        if (!this.matchSegments(d.segments, r)) continue;
+        const u = s.get(d.pattern);
+        u !== void 0 && o.push(u);
       }
-    }, 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), o;
   }
   /**
    * Pattern matcher over dot-separated segments, which arrive already split.
@@ -449,18 +449,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, o = 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, o = n, s++;
+      else if (r !== -1)
+        s = r + 1, n = ++o;
       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 +485,16 @@ 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 V {
   /**
    * Creates a new {@link Reducer} from a pure reducer function.
    *
@@ -523,7 +523,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,128 +536,258 @@ class K {
     return this._reduce(e, t);
   }
 }
-const k = /* @__PURE__ */ new Set();
-function M(o, e) {
-  const t = o ? `${o}.${e}` : e;
-  k.has(t) || (k.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.`
+const T = /* @__PURE__ */ new Set();
+function O(c, e) {
+  const t = c ? `${c}.${e}` : e;
+  T.has(t) || (T.add(t), console.warn(
+    `[yoltra] State key "${e}"${c ? ` under "${c}"` : ""} 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(c, e, t = "", s = /* @__PURE__ */ new Map()) {
+  const n = [];
+  return P(c, e, t, s, n), n;
 }
-function v(o, e, t, n, s) {
-  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))
+function P(c, e, t, s, n) {
+  if (c === e) return;
+  if (typeof c != "object" || typeof e != "object" || c === null || e === null) {
+    if (typeof c == "number" && Number.isNaN(c) && 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);
+  if (c instanceof Date && e instanceof Date) {
+    c.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);
+  if (c instanceof RegExp && e instanceof RegExp) {
+    (c.source !== e.source || e.flags !== c.flags) && n.push(t);
     return;
   }
-  if (o instanceof Map || e instanceof Map) {
-    s.push(t);
+  if (c instanceof Map || e instanceof Map) {
+    n.push(t);
     return;
   }
-  if (o instanceof Set || e instanceof Set) {
-    s.push(t);
+  if (c instanceof Set || e instanceof Set) {
+    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 = c, o = e, l = s.get(r);
+  if (l?.has(o)) return;
+  const i = l ?? /* @__PURE__ */ new Set();
+  i.add(o), 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(c), d = Array.isArray(e);
+    if (a !== d) {
+      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);
+    if (a) {
+      const h = c, y = e;
+      h.length !== y.length && t && n.push(t);
+      const g = Math.min(h.length, y.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}`);
+        h[w] !== y[w] && P(h[w], y[w], t ? `${t}.${w}` : `${w}`, s, n);
+      for (let w = g; w < Math.max(h.length, y.length); w++)
+        n.push(t ? `${t}.${w}` : `${w}`);
       return;
     }
-    const u = Object.keys(o), l = Object.keys(e);
-    if (u.length === 0 && l.length === 0) {
-      s.push(t);
+    const u = Object.keys(c), f = Object.keys(e);
+    if (u.length === 0 && f.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 m = u.length === f.length;
+    if (m) {
+      for (let h = 0; h < f.length; h++)
+        if (!Object.prototype.hasOwnProperty.call(c, f[h])) {
+          m = !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 (m) {
+      for (const h of f)
+        c[h] !== e[h] && (process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h), P(c[h], e[h], t ? `${t}.${h}` : h, 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);
+    for (const h of f) {
+      const y = Object.prototype.hasOwnProperty.call(c, h);
+      if (y && c[h] === e[h]) continue;
+      process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h);
       const g = t ? `${t}.${h}` : h;
-      if (!m) {
-        s.push(g);
+      if (!y) {
+        n.push(g);
         continue;
       }
-      v(o[h], e[h], g, n, s);
+      P(c[h], e[h], g, 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));
+      Object.prototype.hasOwnProperty.call(e, h) || (process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h), n.push(t ? `${t}.${h}` : h));
   } finally {
-    r.delete(d), r.size === 0 && n.delete(i);
+    i.delete(o), i.size === 0 && s.delete(r);
   }
 }
-function S(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);
-  }
-  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 n of Object.getOwnPropertySymbols(o)) {
-    const s = Object.getOwnPropertyDescriptor(o, n);
-    !s || !("value" in s) || (o[n] = S(o[n], e, t));
-  }
-  return Object.freeze(o);
+function M(c, e = /* @__PURE__ */ new WeakSet(), t) {
+  if (c === null || typeof c != "object" || e.has(c) || (t !== void 0 && c === t.watch && t.onFound(), Object.isFrozen(c))) return c;
+  if (e.add(c), Array.isArray(c)) {
+    const s = c;
+    for (let n = 0; n < s.length; n++)
+      s[n] = M(s[n], e, t);
+    return Object.freeze(s);
+  }
+  for (const s of Object.getOwnPropertyNames(c)) {
+    const n = Object.getOwnPropertyDescriptor(c, s);
+    !n || !("value" in n) || (c[s] = M(c[s], e, t));
+  }
+  for (const s of Object.getOwnPropertySymbols(c)) {
+    const n = Object.getOwnPropertyDescriptor(c, s);
+    !n || !("value" in n) || (c[s] = M(c[s], e, t));
+  }
+  return Object.freeze(c);
+}
+const N = /* @__PURE__ */ Symbol.for("yoltra.rejected");
+function le(c) {
+  return { [N]: !0, reason: c };
+}
+function Q(c) {
+  return typeof c == "object" && c !== null && c[N] === !0;
 }
-function W(o, e) {
+class G {
+  constructor(e) {
+    p(this, "highWaterMark");
+    p(this, "buffer", []);
+    /** Consumers parked in `take`, oldest first. */
+    p(this, "takers", []);
+    /** Producers parked in `put`, each with the item they are waiting to hand over. */
+    p(this, "putters", []);
+    p(this, "consuming", !1);
+    /** No more items will be accepted, but what is already here is still owed to the consumer. */
+    p(this, "ended", !1);
+    /** Abandoned: nothing further is owed to anybody. */
+    p(this, "closed", !1);
+    /** Items discarded because nobody was iterating and the buffer was full. */
+    p(this, "dropped", 0);
+    this.highWaterMark = e;
+  }
+  /** 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();
+  }
+}
+class J extends Error {
+  constructor(t, s, n) {
+    super(
+      `[yoltra] call to "${t}/${s}" saw no correlated reply for ${n}ms. The timeout is idle rather than total, so this means the responder went quiet, not that it was slow. Check that something handles "${t}/${s}" 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.`
+    );
+    p(this, "channel");
+    p(this, "type");
+    p(this, "idleMs");
+    this.name = "CallTimeoutError", this.channel = t, this.type = s, this.idleMs = n;
+  }
+}
+class C extends Error {
+  constructor(e) {
+    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
+  }
+}
+function q(c) {
+  const [e, t] = c;
+  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 Y(c, e, t) {
+  return c.parentId === e ? !0 : t === void 0 ? !1 : c.meta?.correlationId === t;
+}
+function X(c, e) {
   try {
     return structuredClone(e);
   } catch (t) {
     throw new Error(
-      `[yoltra] Initial state for slice "${String(o)}" could not be copied: ${t instanceof Error ? t.message : String(t)}. State must be structured-cloneable — functions, class instances and DOM nodes are not. Keep behaviour out of state and store plain data.`
+      `[yoltra] Initial state for slice "${String(c)}" could not be copied: ${t instanceof Error ? t.message : String(t)}. State must be structured-cloneable — functions, class instances and DOM nodes are not. Keep behaviour out of state and store plain data.`
     );
   }
 }
-function P(o, e) {
-  return process.env.NODE_ENV === "production" ? o : S(o, /* @__PURE__ */ new WeakSet(), e);
+function R(c, e) {
+  return process.env.NODE_ENV === "production" ? c : M(c, /* @__PURE__ */ new WeakSet(), e);
 }
-const x = 100, z = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
-class $ {
+const D = 100, Z = 64, z = 16, ee = 3e4, te = 16, $ = Object.freeze({ committed: !1, written: !1 }), ne = Object.freeze({ committed: !0, written: !1 }), se = Object.freeze({ committed: !0, written: !0 }), A = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+class x {
   /**
    * Creates a store from a {@link StoreSpec}.
    *
@@ -746,6 +876,18 @@ class $ {
      *
      * @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
+     */
+    p(this, "writtenEventSubscribers", /* @__PURE__ */ new Map());
     p(this, "allEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * Track reducerBus unsubs per slice for HMR/register/unregister.
@@ -808,6 +950,36 @@ class $ {
      * @internal
      */
     p(this, "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
+     */
+    p(this, "currentEvent", null);
+    /**
+     * Events processed by the drain currently in progress. Compared against
+     * `maxTransitionsPerDrain`, which is off unless configured.
+     *
+     * @internal
+     */
+    p(this, "transitionsThisDrain", 0);
+    /**
+     * Ceilings that stop a cascade from becoming a hung process. See {@link StoreSpec.maxReduceDepth}.
+     *
+     * @internal
+     */
+    p(this, "maxReduceDepth");
+    p(this, "maxTransitionsPerDrain");
+    p(this, "onCascade");
+    p(this, "onRejected");
     /**
      * Registered instrumentation observers (DevTools seam). See {@link instrument}.
      *
@@ -817,11 +989,24 @@ class $ {
     /**
      * 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.
+     * appended to by {@link commitStaged}. `null` when not instrumenting.
      *
      * @internal
      */
     p(this, "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
+     */
+    p(this, "stagingSink", null);
+    p(this, "stagedRejection", null);
+    p(this, "stagedRejectedBy", "");
     /**
      * Count of effect tasks currently in flight; surfaced as queue depth by
      * {@link __devtoolsIntrospect}.
@@ -874,15 +1059,15 @@ class $ {
      * @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 U(), this.connectorBus = new L(), 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 ?? Z, 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 +1083,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 +1096,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 +1119,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,11 +1142,32 @@ 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, D), 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);
   }
+  /**
+   * Reports a breached ceiling and refuses the emit.
+   *
+   * @remarks
+   * 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
+   */
+  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 (o) {
+      console.error("onCascade handler error:", o);
+    }
+  }
   /**
    * Checks if an event matches a `When` matcher.
    *
@@ -980,7 +1186,7 @@ class $ {
    */
   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
+      ([s, n]) => t.channel === s && t.type === n
     ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
   }
   /**
@@ -1016,22 +1222,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 (o) {
+          console.error("Effect error:", o), this.onEffectError?.(o, e);
         }
-    for (const { effect: s, when: i } of this.patternEffects)
-      if (this.matchesWhen(i, e))
+    for (const { effect: r, when: o } of this.patternEffects)
+      if (this.matchesWhen(o, 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, o) => this.emitCaused(t, s, n, r, o));
+  }
   /**
    * Notifies event subscribers for a specific phase.
    *
@@ -1043,12 +1267,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 o = this.allEventSubscribers.get(s);
+    if (o?.size)
+      for (const l of [...o]) this.invokeEventSubscriber(l, e, t);
   }
   /**
    * Invokes a single event-subscription handler **fire-and-forget**: synchronous
@@ -1057,12 +1282,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 +1325,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 (Q(r)) return r;
+    if (n === r) return null;
+    const o = I(n, r);
+    if (o.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: o
+    }), 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 o of n.leafPaths) {
+        if (o === "") {
+          r.add("");
+          continue;
+        }
+        for (const l of x.buildAncestorPaths(o)) r.add(l);
       }
-      for (const u of $.buildAncestorPaths(c)) f.add(u);
+      for (const o of r)
+        this.connectorBus.emitWith(n.name, o, () => ({
+          oldValue: this.getAtPath(n.prev, o),
+          newValue: this.getAtPath(n.frozen, o),
+          path: o,
+          // 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 +1448,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, d] = l.split("::");
+      for (const u of i) {
+        const f = this.effectMeta.get(u);
+        t.push({ channel: a, type: d, name: f?.name, description: f?.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, d] = l.split("::");
+      for (let u = 0; u < i.size; u++)
+        r.push({ channel: a, type: d, 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, d] = l.split("::");
+      for (let u = 0; u < i.size; u++)
+        r.push({ channel: a, type: d, 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, d] = l.split("::");
+      for (let u = 0; u < i.size; u++)
+        r.push({ channel: a, type: d, phase: "all" });
     }
-    const d = this.listeners.size;
+    const o = this.listeners.size;
     return {
       reducers: e,
       effects: t,
-      middleware: n,
-      atomic: s,
-      event: i,
-      coarse: d,
+      middleware: s,
+      atomic: n,
+      event: r,
+      coarse: o,
       dedupHits: this.dedupCount,
       queueDepth: this.reduceQueue.length + this.inFlightEffects
     };
@@ -1228,7 +1516,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 +1531,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((o) => {
+      const l = t?.[o], i = s?.[o];
+      if (i === void 0) {
         process.env.NODE_ENV !== "production" && console.warn(
           `[yoltra] External state is missing slice "${String(
-            d
+            o
           )}"; 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;
+      if (l === i) return;
+      const a = R(i);
+      n[o] = a, r = !0;
+      const d = I(l, i);
+      if (d.length === 0) return;
       const u = /* @__PURE__ */ new Set();
-      for (const l of c) {
-        if (l === "") {
+      for (const f of d) {
+        if (f === "") {
           u.add("");
           continue;
         }
-        for (const y of $.buildAncestorPaths(l)) u.add(y);
+        for (const m of x.buildAncestorPaths(f)) u.add(m);
       }
-      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 f of u) {
+        const m = this.getAtPath(l, f), h = this.getAtPath(a, f);
+        this.connectorBus.emit(o, f, { oldValue: m, newValue: h, path: f });
       }
-    }), i && (this.state = s), i && this.listeners.forEach((d) => d());
+    }), r && (this.state = n), r && this.listeners.forEach((o) => o());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -1292,13 +1580,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 o = null;
+      try {
+        this.reducerBus.emit(n.channel, n.type, n.payload, n), o = this.stagedRejection;
+        for (const [i, a] of this.patternReducers) {
+          if (o !== null) break;
+          if (this.matchesWhen(a, n)) {
+            const d = this.stageSliceGuarded(i, n, r);
+            d !== null && (o = d);
+          }
+        }
+      } finally {
+        this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
+      }
+      const l = o === null && this.commitStaged(r, n);
+      this.notifyEventSubscribers(n, "committed"), l && (this.notifyEventSubscribers(n, "written"), this.listeners.forEach((i) => i()));
     }
   }
   /**
@@ -1310,13 +1609,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,25 +1643,59 @@ 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 o = r?.dedupKey, l = this.dedupConfig.windowMs;
+    if (r?.skipDedup !== !0 && (l > 0 || o !== void 0)) {
+      const m = o !== void 0 && l <= 0 ? D : l, h = o !== void 0 ? `${t}::${s}::#${o}` : this.fingerprint(t, s, n);
+      if (this.shouldDedupe(h, m))
+        return $;
     }
-    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, d = a === null ? 0 : a.depth + 1;
+    if (a !== null && d > 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: d
+        },
+        d,
+        a.chain
+      ), $;
+    let u;
+    const f = new Promise((m) => {
+      u = m;
     });
     return this.reduceQueue.push({
-      channel: e,
-      type: t,
+      channel: t,
+      type: s,
       payload: n,
-      id: a,
-      meta: s?.meta,
-      resolve: r
+      id: i,
+      meta: r?.meta,
+      resolve: u,
+      // 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: d, chain: a.chain } : {}
     }), this.drainReduce(), f;
   }
   /**
@@ -1377,33 +1710,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: o, resolve: l, parentId: i, depth: a, chain: d } = e, u = {
+            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,
+            ...o !== void 0 ? { meta: o } : {},
+            ...i !== void 0 ? { parentId: i, depth: a } : {}
+          };
+          if (i !== void 0 && ++this.transitionsThisDrain > this.maxTransitionsPerDrain) {
+            this.reportCascade(
+              "maxTransitionsPerDrain",
+              this.maxTransitionsPerDrain,
+              u,
+              a,
+              d
+            ), l($);
+            continue;
+          }
+          this.currentEvent = {
+            id: r,
+            depth: a ?? 0,
+            chain: [...d ?? [], r].slice(-z)
+          };
+          const f = this.instrumentObservers.size > 0, m = f ? this.state : void 0, h = f ? [] : void 0;
+          h !== void 0 && (this.changedPathSink = h);
+          const y = f ? A() : 0;
+          let g = $;
           try {
-            l = this.applyEventSync(a);
-          } catch (y) {
-            console.error("Emit reduce error:", y);
+            g = this.applyEventSync(u);
+          } catch (w) {
+            console.error("Emit reduce error:", w);
           } finally {
-            r && (this.changedPathSink = null);
+            f && (this.changedPathSink = null), this.currentEvent = null;
           }
-          r && this.emitInstrumentation(
-            a,
-            l,
-            c ?? [],
-            f,
-            z() - u
-          ), this.runEventEffects(a, l, d);
+          f && this.emitInstrumentation(
+            u,
+            g,
+            h ?? [],
+            m,
+            A() - y
+          ), this.runEventEffects(u, g, l);
         }
       } finally {
         this.isReducing = !1;
@@ -1421,32 +1771,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 o of this.middleware) {
+      const l = this.getMiddlewareWhen(o);
+      if (!this.matchesWhen(l, e)) continue;
+      const i = this.getMiddlewareFunction(o);
       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 (d) {
+        console.error("Middleware error:", d), a = !1;
       }
       if (!a)
-        return this.notifyEventSubscribers(e, "uncommitted"), !1;
+        return this.notifyEventSubscribers(e, "uncommitted"), $;
     }
-    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 [o, l] of this.patternReducers) {
+        if (s !== null) break;
+        if (this.matchesWhen(l, e)) {
+          const i = this.stageSliceGuarded(o, e, t);
+          i !== null && (s = i, n = o);
+        }
+      }
+    } 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((o) => o())), r ? se : ne;
   }
   /**
    * Runs a single committed event's effects as an **independent async task**,
@@ -1456,14 +1819,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 +1842,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 o = {}, l = {};
+    for (const a of s)
+      o[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
+    const i = {
       event: {
         id: e.id,
         channel: e.channel,
@@ -1498,17 +1861,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: o,
+      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 (d) {
+        console.error("Instrumentation observer error:", d);
       }
   }
   /**
@@ -1539,8 +1905,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], o = e.property.includes("*") ? "" : e.property;
+      t({ oldValue: void 0, newValue: this.getAtPath(r, o), path: o });
+    }
+    return n;
   }
   /**
    * Subscribe to events by channel and type.
@@ -1588,11 +1959,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)}`, o = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : n === "written" ? this.writtenEventSubscribers : this.allEventSubscribers;
+    return o.has(r) || o.set(r, /* @__PURE__ */ new Set()), o.get(r).add(s), () => {
+      const l = o.get(r);
+      l && (l.delete(s), l.size === 0 && o.delete(r));
     };
   }
   /**
@@ -1698,8 +2069,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 +2105,169 @@ 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.** A reply cannot reach it from a federated peer: the federation
+   * envelope carries neither `meta` nor `parentId`, and ingress namespaces the channel, so
+   * neither correlation nor the reply route survives the hop. That is not an oversight to route
+   * around — federation answers cross-node request/reply with typed peer *queries*, which are
+   * gated by a responder policy that may concede or deny. A call that federated silently would
+   * turn that access decision into an accident of which channel someone named. Ask a peer with a
+   * query; use `call` within a process.
+   *
+   * @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) {
+    const { channel: r, isTerminal: o } = q(n.reply), l = n.timeoutMs ?? ee, i = new G(n.highWaterMark ?? te), a = this.idFactory();
+    let d, u, f = !1;
+    const m = new Promise((b, S) => {
+      d = b, u = S;
+    });
+    m.catch(() => {
+    });
+    let h = null, y = null;
+    const g = (b, S = !1) => {
+      f || (f = !0, h !== null && clearTimeout(h), h = null, y?.(), y = null, S ? i.end() : i.close(), n.signal?.removeEventListener("abort", w), b());
+    };
+    function w() {
+      g(() => u(new C(String(n.signal?.reason ?? "signal aborted"))));
+    }
+    const k = () => {
+      h !== null && clearTimeout(h), h = setTimeout(() => {
+        g(() => u(new J(e, t, l)));
+      }, l), h.unref?.();
+    };
+    return y = this.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 (b) => {
+        if (!f && Y(b, a, n.correlationId)) {
+          if (k(), o(String(b.type))) {
+            g(() => d(b), !0);
+            return;
+          }
+          await i.put(b);
+        }
+      }
+    }), n.signal !== void 0 && (n.signal.aborted ? w() : n.signal.addEventListener("abort", w, { once: !0 })), k(), this.emit(e, t, s, {
+      id: a,
+      ...n.correlationId !== void 0 ? { meta: { correlationId: n.correlationId } } : {}
+    }), {
+      then: (b, S) => m.then(b, S),
+      catch: (b) => m.catch(b),
+      finally: (b) => m.finally(b),
+      get dropped() {
+        return i.droppedCount;
+      },
+      cancel: (b = "cancelled") => {
+        g(() => u(new C(b)));
+      },
+      [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 })
+      })
+    };
+  }
   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 = this.normalizeEventKeys(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 d = `${String(i)}::${String(a)}`;
+      this.effects.has(d) || this.effects.set(d, /* @__PURE__ */ new Set()), this.effects.get(d).add(t), r.push(() => {
+        const u = this.effects.get(d);
+        u && (u.delete(t), u.size === 0 && this.effects.delete(d));
       });
     }
     return () => {
-      for (const r of i) r();
+      for (const i of r) i();
     };
   }
   /**
@@ -1781,15 +2291,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, o, l) => {
+      if (r.channel !== e || r.type !== t) return;
+      const i = r;
+      return s(i.payload, o, l, i);
     };
     return this.registerEffect({
       when: { keys: [[e, t]] },
-      effect: s
+      effect: n
     });
   }
   /**
@@ -1851,11 +2361,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), o = new Set(r.map(([l]) => l));
+    for (const l of n)
+      o.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 +2397,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: o, when: l } = t;
+    if (this.reducers[e] = new V(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(X(n, o))
+    }), 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 = this.normalizeEventKeys(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 ?? {
+    const d = [];
+    for (const [u, f] of a) {
+      const m = this.reducerBus.on(u, f, (h, y) => {
+        const g = y ?? {
           channel: u,
-          type: l,
+          type: f,
           payload: h,
           id: this.idFactory()
         };
-        this.forwardEventGuarded(e, g);
+        if (this.stagingSink === null) return;
+        const w = this.stageSliceGuarded(e, g, this.stagingSink);
+        w !== null && this.stagedRejection === null && (this.stagedRejection = w, this.stagedRejectedBy = e);
       });
-      c.push(y);
+      d.push(m);
     }
-    this.sliceUnsubs.set(s, c);
+    this.sliceUnsubs.set(n, d);
   }
   /**
    * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
@@ -1926,21 +2438,21 @@ 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 (o) {
+          console.error(`[Store error]: ${o}`);
         }
-      this.sliceUnsubs.delete(n);
+      this.sliceUnsubs.delete(s);
     }
     if (delete this.reducers[e], t.deleteState) {
-      const { [n]: i, ...d } = this.state;
-      this.state = d;
+      const { [s]: r, ...o } = this.state;
+      this.state = o;
     }
   }
   /**
@@ -1970,13 +2482,13 @@ class $ {
    */
   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];
+    const n = (t[0] === "." ? t.slice(1) : t).split(".");
+    let r = e;
+    for (const o of n) {
+      if (r == null) return;
+      r = r[o];
     }
-    return i;
+    return r;
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -1995,263 +2507,258 @@ class $ {
    */
   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;
+    const s = (e[0] === "." ? e.slice(1) : e).split("."), n = [];
+    for (let r = 0; r < s.length; r++)
+      n.push(s.slice(0, r + 1).join("."));
+    return n;
   }
 }
-function L(o) {
-  return new $({
-    name: o.name,
-    reducer: o.reducer ?? {},
-    middleware: o.middleware ?? [],
-    effects: o.effects ?? [],
-    dedupWindowMs: o.dedupWindowMs,
-    idFactory: o.idFactory,
-    devtools: o.devtools,
-    onEffectError: o.onEffectError,
-    onReducerError: o.onReducerError
+function de(c) {
+  return new x({
+    ...c,
+    reducer: c.reducer ?? {},
+    middleware: c.middleware ?? [],
+    effects: c.effects ?? []
   });
 }
-const G = (o) => (e, t) => t.map((n) => [e, n]), Q = () => (o) => o, I = /* @__PURE__ */ new Set();
-function j(o) {
-  const e = String(o);
-  I.has(e) || (I.add(e), console.warn(
+const ue = (c) => (e, t) => t.map((s) => [e, s]), fe = () => (c) => c, _ = /* @__PURE__ */ new Set();
+function re(c) {
+  const e = String(c);
+  _.has(e) || (_.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) {
-  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 ie(c, e) {
+  if (c.length !== e.length) return e;
+  for (let t = 0; t < c.length; t++)
+    if (c[t] !== e[t]) return e;
+  return c;
 }
-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 he(c = {}) {
+  const e = c.selectId ?? ((i) => i.id), { sortComparer: t } = c, s = (i, a) => {
+    if (t === void 0) return a;
+    const d = [...a].sort((u, f) => {
+      const m = i.entities[u], h = i.entities[f];
+      return m === void 0 || h === void 0 ? 0 : t(m, h);
     });
-    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 ie(a, d);
+  }, n = (i, a, d) => {
+    const u = { ...i, entities: a, ids: d };
+    return { ...u, ids: s(u, d) };
+  }, r = (i, a, d) => {
+    let u = null, f = null;
+    for (const m of a) {
+      const h = e(m);
+      process.env.NODE_ENV !== "production" && String(h).includes(".") && re(h);
+      const y = (u ?? i.entities)[h];
+      if (y !== void 0 && d === "add") continue;
+      const g = y !== void 0 && d === "upsert" ? { ...y, ...m } : m;
+      u ?? (u = { ...i.entities }), u[h] = g, y === void 0 && (f ?? (f = [...i.ids]), f.push(h));
     }
-    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 u === null ? i : n(i, u, f ?? i.ids);
+  }, o = (i, a) => {
+    let d = null;
+    for (const { id: u, changes: f } of a) {
+      const m = (d ?? i.entities)[u];
+      m !== void 0 && (d ?? (d = { ...i.entities }), d[u] = { ...m, ...f });
     }
-    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,
+    return d === null ? i : n(i, d, i.ids);
+  }, l = (i, a) => {
+    const d = new Set(a.filter((f) => i.entities[f] !== void 0));
+    if (d.size === 0) return i;
+    const u = { ...i.entities };
+    for (const f of d) delete u[f];
+    return n(
+      i,
       u,
-      r.ids.filter((l) => !c.has(l))
+      i.ids.filter((f) => !d.has(f))
     );
   };
   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 d = {}, u = [];
+      for (const f of a) {
+        const m = e(f);
+        d[m] === void 0 && u.push(m), d[m] = f;
       }
-      return s(r, c, u);
+      return n(i, d, u);
     },
-    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) => o(i, [a]),
+    updateMany: (i, a) => o(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) {
+function B(c, e = {}) {
+  const t = e.maxNodes ?? 1e5, s = e.sanitize, n = [], r = /* @__PURE__ */ new Map();
+  let o = 0, l = !1;
+  function i(d, u) {
+    if (s !== void 0 && (d = s(u, d)), o += 1, o > t)
+      return l = !0, { [E]: "unsupported", kind: "truncated" };
+    switch (typeof d) {
       case "undefined":
         return { [E]: "undefined" };
       case "bigint":
-        return { [E]: "bigint", value: c.toString() };
+        return { [E]: "bigint", value: d.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(d) ? { [E]: "nan" } : d === 1 / 0 ? { [E]: "infinity", sign: 1 } : d === -1 / 0 ? { [E]: "infinity", sign: -1 } : d;
       case "function":
       case "symbol":
-        return s.push(u), { [E]: "unsupported", kind: typeof c };
+        return n.push(u), { [E]: "unsupported", kind: typeof d };
       case "string":
       case "boolean":
-        return c;
+        return d;
     }
-    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) {
-      const m = [];
+    if (d === null) return null;
+    const f = d, m = r.get(f);
+    if (m !== void 0) return { [E]: "ref", path: m };
+    if (r.set(f, u), d instanceof Date)
+      return { [E]: "date", iso: d.toISOString() };
+    if (d instanceof RegExp)
+      return { [E]: "regexp", source: d.source, flags: d.flags };
+    if (d instanceof Error)
+      return { [E]: "error", name: d.name, message: d.message };
+    if (d instanceof Map) {
+      const y = [];
       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 };
+      for (const [w, k] of d)
+        y.push([i(w, `${u}/@k${g}`), i(k, `${u}/${g}`)]), g += 1;
+      return { [E]: "map", entries: y };
     }
-    if (c instanceof Set) {
-      const m = [];
+    if (d instanceof Set) {
+      const y = [];
       let g = 0;
-      for (const w of c)
-        m.push(r(w, `${u}/${g}`)), g += 1;
-      return { [E]: "set", values: m };
+      for (const w of d)
+        y.push(i(w, `${u}/${g}`)), g += 1;
+      return { [E]: "set", values: y };
     }
-    if (Array.isArray(c))
-      return c.map((m, g) => r(m, `${u}/${g}`));
+    if (Array.isArray(d))
+      return d.map((y, g) => i(y, `${u}/${g}`));
     const h = {};
-    for (const [m, g] of Object.entries(c))
-      h[m] = r(g, `${u}/${A(m)}`);
+    for (const [y, g] of Object.entries(d))
+      h[y] = i(g, `${u}/${H(y)}`);
     return E in h ? { [E]: "escaped", value: h } : h;
   }
-  return { value: r(o, ""), report: { truncated: a, unsupported: s } };
+  return { value: i(c, ""), report: { truncated: l, unsupported: n } };
 }
-function V(o) {
+function oe(c) {
   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(o, l) {
+    if (o === null || typeof o != "object") return o;
+    if (Array.isArray(o)) {
+      const a = [];
+      return e.set(l, a), o.forEach((d, u) => {
+        if (j(d)) {
+          t.push({ target: a, key: u, path: d.path }), a[u] = void 0;
           return;
         }
-        f[u] = n(c, `${a}/${u}`);
-      }), f;
+        a[u] = s(d, `${l}/${u}`);
+      }), a;
     }
-    if (typeof d[E] == "string") {
-      const f = d;
-      switch (f[E]) {
+    if (typeof o[E] == "string") {
+      const a = o;
+      switch (a[E]) {
         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 d = new Error(a.message);
+          return d.name = a.name, d;
         }
         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 d = /* @__PURE__ */ new Map();
+          return e.set(l, d), a.entries.forEach(([u, f], m) => {
+            d.set(s(u, `${l}/@k${m}`), s(f, `${l}/${m}`));
+          }), d;
         }
         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 d = /* @__PURE__ */ new Set();
+          return e.set(l, d), a.values.forEach((u, f) => d.add(s(u, `${l}/${f}`))), d;
         }
         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(o, l);
+  }
+  function n(o, l) {
+    const i = {};
+    e.set(l, i);
+    for (const [a, d] of Object.entries(o)) {
+      const u = `${l}/${H(a)}`;
+      if (j(d)) {
+        t.push({ target: i, key: a, path: d.path }), i[a] = void 0;
         continue;
       }
-      r[f] = n(c, u);
+      i[a] = s(d, u);
     }
-    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(c, "");
+  e.set("", r);
+  for (const { target: o, key: l, path: i } of t)
+    o[l] = e.get(i);
+  return r;
 }
-function R(o) {
-  return o !== null && typeof o == "object" && o[E] === "ref" && typeof o.path == "string";
+function j(c) {
+  return c !== null && typeof c == "object" && c[E] === "ref" && typeof c.path == "string";
 }
-function A(o) {
-  return o.replace(/~/g, "~0").replace(/\//g, "~1");
+function H(c) {
+  return c.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 pe(c, e, t = {}) {
+  let s = t.maxNodes ?? 1e5;
+  for (let n = 0; n < 8; n += 1) {
+    const { value: r, report: o } = B(c, { ...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 o.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 {
@@ -2260,107 +2767,107 @@ function Y(o, e, t = {}) {
     note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
   };
 }
-function b(o, e, t) {
-  o.onError?.(e, t);
+function v(c, e, t) {
+  c.onError?.(e, t);
 }
-async function q(o) {
+async function me(c) {
   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;
+    t = c.source ?? await c.adapter.read(c.key);
+  } catch (n) {
+    return v(c, 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;
-  }
-  if (n === null || typeof n != "object" || typeof n.version != "number")
-    return b(o, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
-  if (n.version !== o.version) {
-    if (o.migrate === void 0)
-      return b(
-        o,
+    s = oe(JSON.parse(t));
+  } catch (n) {
+    return v(c, n, "decode"), e;
+  }
+  if (s === null || typeof s != "object" || typeof s.version != "number")
+    return v(c, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
+  if (s.version !== c.version) {
+    if (c.migrate === void 0)
+      return v(
+        c,
         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 ${c.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 = c.migrate(s.slices, s.version);
+      return n === null ? e : { slices: n, restored: !0 };
+    } catch (n) {
+      return v(c, n, "migrate"), e;
     }
   }
-  return { slices: n.slices ?? {}, restored: !0 };
+  return { slices: s.slices ?? {}, restored: !0 };
 }
-function X(o, e) {
-  if (!e.restored) return o;
+function ye(c, e) {
+  if (!e.restored) return c;
   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(c)) {
+    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 W(c, e) {
+  const t = c ?? {}, s = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((n) => n in t).map((n) => [n, t[n]]));
+  return JSON.stringify(B({ 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 ge(c, e) {
+  const t = e.throttleMs ?? 250, s = e.slices;
+  let n = null, r = !1;
+  const o = () => {
+    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, W(c.getState(), e));
+        a instanceof Promise && a.catch((d) => v(e, d, "write"));
+      } catch (a) {
+        v(e, a, "write");
       }
     }
-  }, a = () => {
-    if (i = !0, t <= 0) {
-      d();
+  }, l = () => {
+    if (r = !0, t <= 0) {
+      o();
       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, o();
+    }, t), n.unref?.());
+  }, i = c.instrument((a) => {
+    if (s === void 0) {
+      l();
       return;
     }
-    (f.changedPaths ?? []).some(
-      (u) => n.some((l) => u === l || u.startsWith(`${l}.`))
-    ) && a();
+    (a.changedPaths ?? []).some(
+      (u) => s.some((f) => u === f || u.startsWith(`${f}.`))
+    ) && l();
   });
   return () => {
-    r(), s !== null && (clearTimeout(s), s = null), d();
+    i(), n !== null && (clearTimeout(n), n = null), o();
   };
 }
-function ee(o, e) {
-  return N(o.getState(), e);
+function we(c, e) {
+  return W(c.getState(), e);
 }
-function te(o) {
+function Ee(c) {
   return {
-    read: (e) => o.getItem(e),
-    write: (e, t) => o.setItem(e, t),
-    remove: (e) => o.removeItem(e)
+    read: (e) => c.getItem(e),
+    write: (e, t) => c.setItem(e, t),
+    remove: (e) => c.removeItem(e)
   };
 }
-function se(o) {
-  const e = new Map(Object.entries(o ?? {}));
+function be(c) {
+  const e = new Map(Object.entries(c ?? {}));
   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 +2875,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,
+  J as CallTimeoutError,
+  U as EventBus,
+  L as LooseEventBus,
+  V as Reducer,
+  le as Rejected,
+  x as Store,
+  he as createEntityAdapter,
+  be as createMemoryAdapter,
+  de as createStore,
+  Ee as createWebStorageAdapter,
+  oe as decodeState,
+  we as dehydrate,
+  I as detectChangedProps,
+  B as encodeState,
+  pe as encodeStateBounded,
+  fe as eventKeys,
+  M as freezeState,
+  me as hydrate,
+  Q as isRejected,
+  ge as persist,
+  ue as typedEvents,
+  ye as withHydration
 };
 //# sourceMappingURL=yoltra.mjs.map