@yoltra/core 0.6.0 → 0.7.0

package/dist/yoltra.mjs

@@ -1,23 +1,13 @@
 /*!
- * @yoltra/core v0.6.0
+ * @yoltra/core v0.7.0
  * (c) 2026 Manu Ramirez <@pixerael>
- * License: MIT
- * Homepage: https://yoltra.dev
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree
- */
-var 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>`.
-     * @internal
-     */
-    p(this, "handlers", /* @__PURE__ */ new Map());
-  }
+ * License: MIT */
+class W {
+  /**
+   * Internal registry: `channel → type → Set<handler>`.
+   * @internal
+   */
+  handlers = /* @__PURE__ */ new Map();
   /**
    * Subscribes a handler to an exact `(channel, type)`.
    *
@@ -107,9 +97,9 @@ class U {
   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])
+    const c = r.get(t);
+    if (!(!c || c.size === 0))
+      for (const l of [...c])
         try {
           l(s, n);
         } catch (i) {
@@ -133,37 +123,35 @@ class U {
     this.handlers.clear();
   }
 }
-class L {
-  constructor() {
-    /**
-     * Exact handlers: `channel → type → [handlers]`.
-     * @internal
-     */
-    p(this, "handlers", /* @__PURE__ */ new Map());
-    /**
-     * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
-     * @internal
-     */
-    p(this, "patternHandlers", /* @__PURE__ */ new Map());
-    /**
-     * Patterns bucketed by their first segment, so an emit tests only what could match.
-     *
-     * @remarks
-     * Delivery used to walk every pattern registered on the channel and run the full segment
-     * matcher against each. That is linear in the number of patterns rather than in the number
-     * that match, and it re-split both the pattern and the subject on every test — for a thousand
-     * patterns, two thousand string splits to deliver one event.
-     *
-     * A subject's first segment can only be matched by a pattern whose first segment is that same
-     * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
-     * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
-     * the handful that begin with a wildcard.
-     *
-     * It buys nothing for a channel where every pattern starts with `**`, since all of those must
-     * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
-     */
-    p(this, "patternIndex", /* @__PURE__ */ new Map());
-  }
+class U {
+  /**
+   * Exact handlers: `channel → type → [handlers]`.
+   * @internal
+   */
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
+   * @internal
+   */
+  patternHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Patterns bucketed by their first segment, so an emit tests only what could match.
+   *
+   * @remarks
+   * Delivery used to walk every pattern registered on the channel and run the full segment
+   * matcher against each. That is linear in the number of patterns rather than in the number
+   * that match, and it re-split both the pattern and the subject on every test — for a thousand
+   * patterns, two thousand string splits to deliver one event.
+   *
+   * A subject's first segment can only be matched by a pattern whose first segment is that same
+   * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
+   * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
+   * the handful that begin with a wildcard.
+   *
+   * It buys nothing for a channel where every pattern starts with `**`, since all of those must
+   * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
+   */
+  patternIndex = /* @__PURE__ */ new Map();
   /**
    * Subscribes a handler to either an **exact** type or a **pattern**.
    *
@@ -201,13 +189,13 @@ class L {
     if (this.isPattern(n)) {
       const r = n;
       this.patternHandlers.has(e) || this.patternHandlers.set(e, /* @__PURE__ */ new Map());
-      const o = this.patternHandlers.get(e);
-      return o.has(r) || (o.set(r, []), this.indexPattern(e, r)), o.get(r).push(s), () => this.offPattern(e, r, s);
+      const c = this.patternHandlers.get(e);
+      return c.has(r) || (c.set(r, []), this.indexPattern(e, r)), c.get(r).push(s), () => this.offPattern(e, r, s);
     } else {
       const r = this.normalizeTypeKey(n);
       this.handlers.has(e) || this.handlers.set(e, /* @__PURE__ */ new Map());
-      const o = this.handlers.get(e);
-      return o.has(r) || o.set(r, []), o.get(r).push(s), () => this.offExactNormalized(e, r, s);
+      const c = this.handlers.get(e);
+      return c.has(r) || c.set(r, []), c.get(r).push(s), () => this.offExactNormalized(e, r, s);
     }
   }
   /**
@@ -245,8 +233,8 @@ class L {
     if (!n) return;
     const r = n.get(t);
     if (!r) return;
-    const o = r.indexOf(s);
-    o !== -1 && r.splice(o, 1), r.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
+    const c = r.indexOf(s);
+    c !== -1 && r.splice(c, 1), r.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
   }
   /**
    * Internal removal for a **pattern** subscription. No-ops if missing.
@@ -261,8 +249,8 @@ class L {
     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));
+    const c = r.indexOf(s);
+    c !== -1 && r.splice(c, 1), r.length === 0 && (n.delete(t), this.unindexPattern(e, t)), n.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
   }
   /**
    * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
@@ -285,20 +273,20 @@ class L {
    * @public
    */
   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);
+    const n = String(t), r = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n), i = /* @__PURE__ */ new Set(), a = (u) => {
+      for (const d of [...u])
+        if (!i.has(d)) {
+          i.add(d);
           try {
-            u(s);
-          } catch (f) {
-            console.error(f);
+            d(s);
+          } catch (h) {
+            console.error(h);
             continue;
           }
         }
     };
-    a(o);
-    for (const d of l) a(d);
+    a(c);
+    for (const u of l) a(u);
   }
   /**
    * Emits a payload that is only built if somebody is listening.
@@ -317,22 +305,22 @@ class L {
    * @public
    */
   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);
+    const n = String(t), r = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n);
+    if (c.length === 0 && l.length === 0) return;
+    const i = s(), a = /* @__PURE__ */ new Set(), u = (d) => {
+      for (const h of [...d])
+        if (!a.has(h)) {
+          a.add(h);
           try {
-            f(i);
-          } catch (m) {
-            console.error(m);
+            h(i);
+          } catch (p) {
+            console.error(p);
             continue;
           }
         }
     };
-    d(o);
-    for (const u of l) d(u);
+    u(c);
+    for (const d of l) u(d);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -373,13 +361,13 @@ class L {
   indexPattern(e, t) {
     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 === "**") {
+    const n = this.splitPath(t), r = { pattern: t, segments: n }, c = n[0];
+    if (c === void 0 || c === "*" || c === "**") {
       s.anyHead.push(r);
       return;
     }
-    const l = s.byHead.get(o);
-    l === void 0 ? s.byHead.set(o, [r]) : l.push(r);
+    const l = s.byHead.get(c);
+    l === void 0 ? s.byHead.set(c, [r]) : l.push(r);
   }
   /**
    * Removes a pattern from the index. Paired with {@link LooseEventBus.offPattern}.
@@ -390,8 +378,8 @@ class L {
     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);
+    const c = r.findIndex((l) => l.pattern === t);
+    c !== -1 && r.splice(c, 1), r.length === 0 && r !== s.anyHead && n !== void 0 && s.byHead.delete(n);
   }
   /**
    * The handler lists of every pattern matching this subject.
@@ -407,18 +395,18 @@ class L {
   matchingPatternHandlers(e, t) {
     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);
+    const r = this.splitPath(t), c = [], l = (a) => {
+      for (const u of a) {
+        if (!this.matchSegments(u.segments, r)) continue;
+        const d = s.get(u.pattern);
+        d !== void 0 && c.push(d);
       }
     }, i = r[0];
     if (i !== void 0) {
       const a = n.byHead.get(i);
       a !== void 0 && l(a);
     }
-    return l(n.anyHead), o;
+    return l(n.anyHead), c;
   }
   /**
    * Pattern matcher over dot-separated segments, which arrive already split.
@@ -449,14 +437,14 @@ class L {
    * @internal
    */
   matchSegments(e, t) {
-    let s = 0, n = 0, r = -1, o = 0;
+    let s = 0, n = 0, r = -1, c = 0;
     for (; n < t.length; )
       if (s < e.length && (e[s] === "*" || e[s] === t[n]))
         s++, n++;
       else if (s < e.length && e[s] === "**")
-        r = s, o = n, s++;
+        r = s, c = n, s++;
       else if (r !== -1)
-        s = r + 1, n = ++o;
+        s = r + 1, n = ++c;
       else
         return !1;
     for (; s < e.length && e[s] === "**"; ) s++;
@@ -494,7 +482,12 @@ class L {
     return e;
   }
 }
-class V {
+class L {
+  /**
+   * The underlying pure reducer function.
+   * @internal
+   */
+  _reduce;
   /**
    * Creates a new {@link Reducer} from a pure reducer function.
    *
@@ -511,11 +504,6 @@ class V {
    * @public
    */
   constructor(e) {
-    /**
-     * The underlying pure reducer function.
-     * @internal
-     */
-    p(this, "_reduce");
     this._reduce = e;
   }
   /**
@@ -537,137 +525,162 @@ class V {
   }
 }
 const T = /* @__PURE__ */ new Set();
-function O(c, e) {
-  const t = c ? `${c}.${e}` : e;
+function O(o, e) {
+  const t = o ? `${o}.${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.`
+    `[yoltra] State key "${e}"${o ? ` under "${o}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
   ));
 }
-function I(c, e, t = "", s = /* @__PURE__ */ new Map()) {
+function I(o, e, t = "", s = /* @__PURE__ */ new Map()) {
   const n = [];
-  return P(c, e, t, s, n), n;
+  return P(o, e, t, s, n), n;
 }
-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))
+function P(o, e, t, s, n) {
+  if (o === e) return;
+  if (typeof o != "object" || typeof e != "object" || o === null || e === null) {
+    if (typeof o == "number" && Number.isNaN(o) && Number.isNaN(e))
       return;
     n.push(t);
     return;
   }
-  if (c instanceof Date && e instanceof Date) {
-    c.getTime() !== e.getTime() && n.push(t);
+  if (o instanceof Date && e instanceof Date) {
+    o.getTime() !== e.getTime() && n.push(t);
     return;
   }
-  if (c instanceof RegExp && e instanceof RegExp) {
-    (c.source !== e.source || e.flags !== c.flags) && n.push(t);
+  if (o instanceof RegExp && e instanceof RegExp) {
+    (o.source !== e.source || e.flags !== o.flags) && n.push(t);
     return;
   }
-  if (c instanceof Map || e instanceof Map) {
+  if (o instanceof Map || e instanceof Map) {
     n.push(t);
     return;
   }
-  if (c instanceof Set || e instanceof Set) {
+  if (o instanceof Set || e instanceof Set) {
     n.push(t);
     return;
   }
-  const r = c, o = e, l = s.get(r);
-  if (l?.has(o)) return;
+  const r = o, c = e, l = s.get(r);
+  if (l?.has(c)) return;
   const i = l ?? /* @__PURE__ */ new Set();
-  i.add(o), l || s.set(r, i);
+  i.add(c), l || s.set(r, i);
   try {
-    const a = Array.isArray(c), d = Array.isArray(e);
-    if (a !== d) {
+    const a = Array.isArray(o), u = Array.isArray(e);
+    if (a !== u) {
       n.push(t);
       return;
     }
     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] !== 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}`);
+      const f = o, m = e;
+      f.length !== m.length && t && n.push(t);
+      const y = Math.min(f.length, m.length);
+      for (let g = 0; g < y; g++)
+        f[g] !== m[g] && P(f[g], m[g], t ? `${t}.${g}` : `${g}`, s, n);
+      for (let g = y; g < Math.max(f.length, m.length); g++)
+        n.push(t ? `${t}.${g}` : `${g}`);
       return;
     }
-    const u = Object.keys(c), f = Object.keys(e);
-    if (u.length === 0 && f.length === 0) {
+    const d = Object.keys(o), h = Object.keys(e);
+    if (d.length === 0 && h.length === 0) {
       n.push(t);
       return;
     }
-    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;
+    let p = d.length === h.length;
+    if (p) {
+      for (let f = 0; f < h.length; f++)
+        if (!Object.prototype.hasOwnProperty.call(o, h[f])) {
+          p = !1;
           break;
         }
     }
-    if (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));
+    if (p) {
+      for (const f of h)
+        o[f] !== e[f] && (process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f), P(o[f], e[f], t ? `${t}.${f}` : f, s, n));
       return;
     }
-    for (const h of 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 (!y) {
-        n.push(g);
+    for (const f of h) {
+      const m = Object.prototype.hasOwnProperty.call(o, f);
+      if (m && o[f] === e[f]) continue;
+      process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f);
+      const y = t ? `${t}.${f}` : f;
+      if (!m) {
+        n.push(y);
         continue;
       }
-      P(c[h], e[h], g, s, n);
+      P(o[f], e[f], y, s, n);
     }
-    for (const h of u)
-      Object.prototype.hasOwnProperty.call(e, h) || (process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h), n.push(t ? `${t}.${h}` : h));
+    for (const f of d)
+      Object.prototype.hasOwnProperty.call(e, f) || (process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f), n.push(t ? `${t}.${f}` : f));
   } finally {
-    i.delete(o), i.size === 0 && s.delete(r);
+    i.delete(c), i.size === 0 && s.delete(r);
   }
 }
-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;
+function M(o, e = /* @__PURE__ */ new WeakSet(), t) {
+  if (o === null || typeof o != "object" || e.has(o) || (t !== void 0 && o === t.watch && t.onFound(), Object.isFrozen(o))) return o;
+  if (e.add(o), Array.isArray(o)) {
+    const s = o;
     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.getOwnPropertyNames(o)) {
+    const n = Object.getOwnPropertyDescriptor(o, s);
+    !n || !("value" in n) || (o[s] = M(o[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));
+  for (const s of Object.getOwnPropertySymbols(o)) {
+    const n = Object.getOwnPropertyDescriptor(o, s);
+    !n || !("value" in n) || (o[s] = M(o[s], e, t));
+  }
+  return Object.freeze(o);
+}
+const B = /* @__PURE__ */ Symbol.for("yoltra.rejected");
+function fe(o) {
+  return { [B]: !0, reason: o };
+}
+function V(o) {
+  return typeof o == "object" && o !== null && o[B] === !0;
+}
+class Q extends Error {
+  channel;
+  type;
+  idleMs;
+  constructor(e, t, s) {
+    super(
+      `[yoltra] call to "${e}/${t}" saw no correlated reply for ${s}ms. The timeout is idle rather than total, so this means the responder went quiet, not that it was slow. Check that something handles "${e}/${t}" and that its reply is emitted through the \`emit\` it was handed — a reply emitted from an unrelated context carries no causal link, and needs an explicit correlationId instead.`
+    ), this.name = "CallTimeoutError", this.channel = e, this.type = t, this.idleMs = s;
+  }
+}
+class C extends Error {
+  constructor(e) {
+    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
   }
-  return Object.freeze(c);
 }
-const N = /* @__PURE__ */ Symbol.for("yoltra.rejected");
-function le(c) {
-  return { [N]: !0, reason: c };
+function G(o) {
+  const [e, t] = o;
+  if (t === void 0) return { channel: e, isTerminal: () => !0 };
+  if (typeof t == "string") return { channel: e, isTerminal: (n) => n === t };
+  const s = new Set(t);
+  return { channel: e, isTerminal: (n) => s.has(n) };
 }
-function Q(c) {
-  return typeof c == "object" && c !== null && c[N] === !0;
+function J(o, e, t) {
+  return o.parentId === e ? !0 : t === void 0 ? !1 : o.meta?.correlationId === t;
 }
-class G {
+class q {
   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;
   }
+  highWaterMark;
+  buffer = [];
+  /** Consumers parked in `take`, oldest first. */
+  takers = [];
+  /** Producers parked in `put`, each with the item they are waiting to hand over. */
+  putters = [];
+  consuming = !1;
+  /** No more items will be accepted, but what is already here is still owed to the consumer. */
+  ended = !1;
+  /** Abandoned: nothing further is owed to anybody. */
+  closed = !1;
+  /** Items discarded because nobody was iterating and the buffer was full. */
+  dropped = 0;
   /** How many items were discarded for want of a consumer. */
   get droppedCount() {
     return this.dropped;
@@ -748,46 +761,375 @@ class G {
       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;
+const Y = 3e4, X = 16;
+function Z(o, e, t, s, n) {
+  const { channel: r, isTerminal: c } = G(n.reply), l = n.timeoutMs ?? Y, i = new q(n.highWaterMark ?? X), a = o.idFactory();
+  let u, d, h = !1;
+  const p = new Promise((E, v) => {
+    u = E, d = v;
+  });
+  p.catch(() => {
+  });
+  let f = null, m = null;
+  const y = (E, v = !1) => {
+    h || (h = !0, f !== null && clearTimeout(f), f = null, m?.(), m = null, v ? i.end() : i.close(), n.signal?.removeEventListener("abort", g), E());
+  };
+  function g() {
+    y(() => d(new C(String(n.signal?.reason ?? "signal aborted"))));
   }
+  const $ = () => {
+    f !== null && clearTimeout(f), f = setTimeout(() => {
+      y(() => d(new Q(e, t, l)));
+    }, l), f.unref?.();
+  };
+  return m = o.registerEffect({
+    // A pattern effect on the reply channel: which types are terminal is known, which are
+    // progress is not, so the filter cannot be a key list.
+    when: { channel: r },
+    effect: async (E) => {
+      if (!h && J(E, a, n.correlationId)) {
+        if ($(), c(String(E.type))) {
+          y(() => u(E), !0);
+          return;
+        }
+        await i.put(E);
+      }
+    }
+  }), n.signal !== void 0 && (n.signal.aborted ? g() : n.signal.addEventListener("abort", g, { once: !0 })), $(), o.emit(e, t, s, {
+    id: a,
+    ...n.correlationId !== void 0 ? { meta: { correlationId: n.correlationId } } : {}
+  }), {
+    then: (E, v) => p.then(E, v),
+    catch: (E) => p.catch(E),
+    finally: (E) => p.finally(E),
+    get dropped() {
+      return i.droppedCount;
+    },
+    cancel: (E = "cancelled") => {
+      y(() => d(new C(E)));
+    },
+    [Symbol.asyncIterator]: () => (i.beginConsuming(), {
+      next: () => i.take(),
+      // Called by `for await` on `break`, `return` or a throw. Without it, abandoning the
+      // loop would leave the effect registered and the producer parked for good.
+      return: async () => (i.close(), { value: void 0, done: !0 })
+    })
+  };
 }
-class C extends Error {
-  constructor(e) {
-    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
-  }
+function ee(o, e) {
+  if (!e) return o;
+  const s = (e[0] === "." ? e.slice(1) : e).split(".");
+  let n = o;
+  for (const r of s) {
+    if (n == null) return;
+    n = n[r];
+  }
+  return n;
 }
-function 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 te(o) {
+  if (!o) return [];
+  const t = (o[0] === "." ? o.slice(1) : o).split("."), s = [];
+  for (let n = 0; n < t.length; n++)
+    s.push(t.slice(0, n + 1).join("."));
+  return s;
 }
-function Y(c, e, t) {
-  return c.parentId === e ? !0 : t === void 0 ? !1 : c.meta?.correlationId === t;
+function k(o, e) {
+  return !o || "any" in o && o.any === !0 ? !0 : "keys" in o ? o.keys.some(
+    ([t, s]) => e.channel === t && e.type === s
+  ) : "channel" in o ? e.channel === o.channel : "channels" in o ? o.channels.includes(e.channel) : !1;
 }
-function X(c, e) {
+function ne(o) {
+  return typeof o == "function" ? o : o.middleware;
+}
+function se(o) {
+  if (typeof o != "function")
+    return o.when;
+}
+function D(o) {
+  if (o.when) {
+    const e = o.when;
+    if ("keys" in e)
+      return e.keys;
+  }
+  return [];
+}
+function re(o, e) {
   try {
     return structuredClone(e);
   } catch (t) {
     throw new Error(
-      `[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.`
+      `[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.`
     );
   }
 }
-function R(c, e) {
-  return process.env.NODE_ENV === "production" ? c : M(c, /* @__PURE__ */ new WeakSet(), e);
+function R(o, e) {
+  return process.env.NODE_ENV === "production" ? o : M(o, /* @__PURE__ */ new WeakSet(), e);
 }
-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();
+const A = 100, ie = 64, z = 16, S = Object.freeze({ committed: !1, written: !1 }), oe = Object.freeze({ committed: !0, written: !1 }), ce = Object.freeze({ committed: !0, written: !0 }), _ = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
 class x {
+  /**
+   * Store name (used by DevTools & diagnostics).
+   *
+   * @public
+   */
+  name;
+  /**
+   * Registered middleware pipeline (run **before** reducers).
+   * Stores either raw functions (legacy) or MiddlewareSpec objects.
+   * Return `false` from the middleware function to stop propagation.
+   *
+   * @internal
+   */
+  middleware;
+  /**
+   * Installed slice reducers keyed by slice name.
+   *
+   * @internal
+   */
+  reducers;
+  /**
+   * Current immutable snapshot of the store state.
+   * This reference changes whenever any slice changes (shallow immutability).
+   *
+   * @internal
+   */
+  state;
+  /**
+   * Bus for reducer wiring (emit by `(channel, type)`).
+   *
+   * @internal
+   */
+  reducerBus;
+  /**
+   * Bus for **granular** connector events (emit by **dotted path** inside a slice).
+   *
+   * @internal
+   */
+  connectorBus;
+  /**
+   * Coarse-grained listeners (called once per committed event, only if state changed).
+   *
+   * @internal
+   */
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
+   * Used for effects with explicit `keys` targeting.
+   *
+   * @internal
+   */
+  effects = /* @__PURE__ */ new Map();
+  /**
+   * Pattern-based effects that need runtime matching.
+   * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
+   * Stores tuples of [effect function, when matcher].
+   *
+   * @internal
+   */
+  patternEffects = /* @__PURE__ */ new Set();
+  /**
+   * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified after reducers, before effects, for events that passed middleware.
+   *
+   * @internal
+   */
+  committedEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified when middleware rejects an event.
+   *
+   * @internal
+   */
+  uncommittedEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified for both committed and uncommitted events with phase parameter.
+   *
+   * @internal
+   */
+  /**
+   * Subscribers to events that actually changed state, notified after the commit.
+   *
+   * @remarks
+   * Separate from `committedEventSubscribers` rather than a filter over it, because the two
+   * answer different questions and one of them is load bearing: `committed` means "not vetoed"
+   * and fires for every event a store accepts, including every event in a store with no
+   * reducers. Narrowing it would have silently stopped toasts and analytics firing.
+   *
+   * @internal
+   */
+  writtenEventSubscribers = /* @__PURE__ */ new Map();
+  allEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * Track reducerBus unsubs per slice for HMR/register/unregister.
+   *
+   * @internal
+   */
+  sliceUnsubs = /* @__PURE__ */ new Map();
+  /**
+   * Pattern-based reducers that need runtime matching.
+   * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
+   * Maps slice name to the `when` matcher.
+   *
+   * @internal
+   */
+  patternReducers = /* @__PURE__ */ new Map();
+  /**
+   * Whether `__replayEvents()` is allowed.
+   * Set from `spec.devtools.allowReplay`.
+   *
+   * @internal
+   */
+  replayEnabled;
+  /**
+   * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
+   * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
+   *
+   * @internal
+   */
+  idFactory;
+  /**
+   * Optional hook invoked when an effect throws/rejects. See
+   * {@link StoreSpec.onEffectError}. `await emit()` never rejects on effect
+   * failure — this is how callers observe effect errors.
+   */
+  onEffectError;
+  /**
+   * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
+   * failing slice is isolated rather than the event being rolled back, so this is the only
+   * signal that a reducer misbehaved.
+   */
+  onReducerError;
+  /**
+   * `slice:channel:type` combinations already warned about for payload aliasing.
+   *
+   * @remarks
+   * Development-only diagnostics have to stay quiet enough to be read. One warning names the
+   * pattern; repeating it once per event would bury it.
+   */
+  warnedPayloadAliases = /* @__PURE__ */ new Set();
+  /**
+   * Pending events awaiting the **synchronous** reduce phase (middleware +
+   * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
+   *
+   * @internal
+   */
+  reduceQueue = [];
+  /**
+   * Re-entrancy guard for the synchronous reduce phase.
+   *
+   * @internal
+   */
+  isReducing = !1;
+  /**
+   * The event currently being reduced, or `null` outside the drain.
+   *
+   * @remarks
+   * This is what makes causality exact rather than best-effort. The drain is synchronous — no
+   * `await` can interleave — so any `emit` that arrives while it is set is, without ambiguity, a
+   * consequence of this event. That catches the case a scoped `emit` closure cannot: a
+   * middleware or subscriber that captured the store and calls `store.emit` directly instead of
+   * using the injected one. Attribution should not depend on which reference a consumer reached
+   * for.
+   *
+   * @internal
+   */
+  currentEvent = null;
+  /**
+   * Events processed by the drain currently in progress. Compared against
+   * `maxTransitionsPerDrain`, which is off unless configured.
+   *
+   * @internal
+   */
+  transitionsThisDrain = 0;
+  /**
+   * Ceilings that stop a cascade from becoming a hung process. See {@link StoreSpec.maxReduceDepth}.
+   *
+   * @internal
+   */
+  maxReduceDepth;
+  maxTransitionsPerDrain;
+  onCascade;
+  onRejected;
+  /**
+   * Registered instrumentation observers (DevTools seam). See {@link instrument}.
+   *
+   * @internal
+   */
+  instrumentObservers = /* @__PURE__ */ new Set();
+  /**
+   * Scratch array collecting slice-prefixed changed leaf paths during an
+   * instrumented reduce. Set by {@link drainReduce} while observers are active;
+   * appended to by {@link commitStaged}. `null` when not instrumenting.
+   *
+   * @internal
+   */
+  changedPathSink = null;
+  /**
+   * Where keyed reducers put their pending writes during a reduce, and the refusal one of them
+   * returned.
+   *
+   * @remarks
+   * Keyed reducers are invoked through `reducerBus`, which delivers to handlers and has no way
+   * to hand a value back — the same reason `changedPathSink` exists. `null` outside a reduce.
+   *
+   * @internal
+   */
+  stagingSink = null;
+  stagedRejection = null;
+  stagedRejectedBy = "";
+  /**
+   * Count of effect tasks currently in flight; surfaced as queue depth by
+   * {@link __devtoolsIntrospect}.
+   *
+   * @internal
+   */
+  inFlightEffects = 0;
+  /**
+   * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
+   *
+   * **Deduplication Behavior:**
+   * - Events are fingerprinted using `channel::type::JSON(payload)`
+   * - If an identical fingerprint is seen within the dedup window, it's skipped
+   * - The window is 50ms in development, 100ms in production
+   *
+   * **Limitations:**
+   * - Non-serializable payloads (functions, symbols, circular refs) get unique
+   *   fingerprints and won't be deduplicated
+   * - Legitimate rapid-fire identical events may be incorrectly deduplicated
+   * - The cache is bounded to 1000 entries with lazy pruning
+   *
+   * @internal
+   */
+  processedEvents = /* @__PURE__ */ new Map();
+  /**
+   * Lifetime count of events suppressed by the deduplication cache.
+   * Exposed via {@link __devtoolsIntrospect} so the DevTools agent can
+   * surface it in the STORE_METRICS response without further core changes.
+   *
+   * @internal
+   */
+  dedupCount = 0;
+  /**
+   * Store-owned metadata for registered effects, keyed by the effect function.
+   * Kept **off** the caller's function object: mutating a user-owned function
+   * (the old `fn.__quoMeta`) bled metadata across stores that share a handler
+   * and left it attached after unregister. Cleared on {@link dispose}.
+   *
+   * @internal
+   */
+  effectMeta = /* @__PURE__ */ new WeakMap();
+  /**
+   * Configuration for event deduplication.
+   * @internal
+   */
+  dedupConfig;
+  /**
+   * Timer for periodic cleanup of processed events.
+   *
+   * @internal
+   */
+  eventCleanupTimer = null;
   /**
    * Creates a store from a {@link StoreSpec}.
    *
@@ -796,270 +1138,7 @@ class x {
    * @public
    */
   constructor(e) {
-    /**
-     * Store name (used by DevTools & diagnostics).
-     *
-     * @public
-     */
-    p(this, "name");
-    /**
-     * Registered middleware pipeline (run **before** reducers).
-     * Stores either raw functions (legacy) or MiddlewareSpec objects.
-     * Return `false` from the middleware function to stop propagation.
-     *
-     * @internal
-     */
-    p(this, "middleware");
-    /**
-     * Installed slice reducers keyed by slice name.
-     *
-     * @internal
-     */
-    p(this, "reducers");
-    /**
-     * Current immutable snapshot of the store state.
-     * This reference changes whenever any slice changes (shallow immutability).
-     *
-     * @internal
-     */
-    p(this, "state");
-    /**
-     * Bus for reducer wiring (emit by `(channel, type)`).
-     *
-     * @internal
-     */
-    p(this, "reducerBus");
-    /**
-     * Bus for **granular** connector events (emit by **dotted path** inside a slice).
-     *
-     * @internal
-     */
-    p(this, "connectorBus");
-    /**
-     * Coarse-grained listeners (called once per committed event, only if state changed).
-     *
-     * @internal
-     */
-    p(this, "listeners", /* @__PURE__ */ new Set());
-    /**
-     * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
-     * Used for effects with explicit `keys` targeting.
-     *
-     * @internal
-     */
-    p(this, "effects", /* @__PURE__ */ new Map());
-    /**
-     * Pattern-based effects that need runtime matching.
-     * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
-     * Stores tuples of [effect function, when matcher].
-     *
-     * @internal
-     */
-    p(this, "patternEffects", /* @__PURE__ */ new Set());
-    /**
-     * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
-     * Notified after reducers, before effects, for events that passed middleware.
-     *
-     * @internal
-     */
-    p(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
-    /**
-     * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
-     * Notified when middleware rejects an event.
-     *
-     * @internal
-     */
-    p(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
-    /**
-     * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
-     * Notified for both committed and uncommitted events with phase parameter.
-     *
-     * @internal
-     */
-    /**
-     * 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.
-     *
-     * @internal
-     */
-    p(this, "sliceUnsubs", /* @__PURE__ */ new Map());
-    /**
-     * Pattern-based reducers that need runtime matching.
-     * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
-     * Maps slice name to the `when` matcher.
-     *
-     * @internal
-     */
-    p(this, "patternReducers", /* @__PURE__ */ new Map());
-    /**
-     * Whether `__replayEvents()` is allowed.
-     * Set from `spec.devtools.allowReplay`.
-     *
-     * @internal
-     */
-    p(this, "replayEnabled");
-    /**
-     * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
-     * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
-     *
-     * @internal
-     */
-    p(this, "idFactory");
-    /**
-     * Optional hook invoked when an effect throws/rejects. See
-     * {@link StoreSpec.onEffectError}. `await emit()` never rejects on effect
-     * failure — this is how callers observe effect errors.
-     */
-    p(this, "onEffectError");
-    /**
-     * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
-     * failing slice is isolated rather than the event being rolled back, so this is the only
-     * signal that a reducer misbehaved.
-     */
-    p(this, "onReducerError");
-    /**
-     * `slice:channel:type` combinations already warned about for payload aliasing.
-     *
-     * @remarks
-     * Development-only diagnostics have to stay quiet enough to be read. One warning names the
-     * pattern; repeating it once per event would bury it.
-     */
-    p(this, "warnedPayloadAliases", /* @__PURE__ */ new Set());
-    /**
-     * Pending events awaiting the **synchronous** reduce phase (middleware +
-     * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
-     *
-     * @internal
-     */
-    p(this, "reduceQueue", []);
-    /**
-     * Re-entrancy guard for the synchronous reduce phase.
-     *
-     * @internal
-     */
-    p(this, "isReducing", !1);
-    /**
-     * 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}.
-     *
-     * @internal
-     */
-    p(this, "instrumentObservers", /* @__PURE__ */ new Set());
-    /**
-     * Scratch array collecting slice-prefixed changed leaf paths during an
-     * instrumented reduce. Set by {@link drainReduce} while observers are active;
-     * appended to by {@link 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}.
-     *
-     * @internal
-     */
-    p(this, "inFlightEffects", 0);
-    /**
-     * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
-     *
-     * **Deduplication Behavior:**
-     * - Events are fingerprinted using `channel::type::JSON(payload)`
-     * - If an identical fingerprint is seen within the dedup window, it's skipped
-     * - The window is 50ms in development, 100ms in production
-     *
-     * **Limitations:**
-     * - Non-serializable payloads (functions, symbols, circular refs) get unique
-     *   fingerprints and won't be deduplicated
-     * - Legitimate rapid-fire identical events may be incorrectly deduplicated
-     * - The cache is bounded to 1000 entries with lazy pruning
-     *
-     * @internal
-     */
-    p(this, "processedEvents", /* @__PURE__ */ new Map());
-    /**
-     * Lifetime count of events suppressed by the deduplication cache.
-     * Exposed via {@link __devtoolsIntrospect} so the DevTools agent can
-     * surface it in the STORE_METRICS response without further core changes.
-     *
-     * @internal
-     */
-    p(this, "dedupCount", 0);
-    /**
-     * Store-owned metadata for registered effects, keyed by the effect function.
-     * Kept **off** the caller's function object: mutating a user-owned function
-     * (the old `fn.__quoMeta`) bled metadata across stores that share a handler
-     * and left it attached after unregister. Cleared on {@link dispose}.
-     *
-     * @internal
-     */
-    p(this, "effectMeta", /* @__PURE__ */ new WeakMap());
-    /**
-     * Configuration for event deduplication.
-     * @internal
-     */
-    p(this, "dedupConfig");
-    /**
-     * Timer for periodic cleanup of processed events.
-     *
-     * @internal
-     */
-    p(this, "eventCleanupTimer", null);
-    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new 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 = {
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new W(), this.connectorBus = new U(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.idFactory = e.idFactory ?? (() => crypto.randomUUID()), this.onEffectError = e.onEffectError, this.onReducerError = e.onReducerError, this.maxReduceDepth = e.maxReduceDepth ?? ie, this.maxTransitionsPerDrain = e.maxTransitionsPerDrain ?? 1 / 0, this.onCascade = e.onCascade, this.onRejected = e.onRejected, this.dedupConfig = {
       windowMs: e.dedupWindowMs ?? 0,
       maxCacheSize: 1e3
     }, Object.entries(e.reducer).forEach(([t, s]) => {
@@ -1142,7 +1221,7 @@ class x {
    * @internal
    */
   pruneProcessedEvents(e) {
-    const t = Math.max(this.dedupConfig.windowMs, D), s = e - t * 2;
+    const t = Math.max(this.dedupConfig.windowMs, A), s = e - t * 2;
     for (const [n, r] of this.processedEvents)
       r < s && this.processedEvents.delete(n);
     this.processedEvents.size === 0 && this.eventCleanupTimer !== null && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null);
@@ -1164,55 +1243,10 @@ class x {
     );
     try {
       this.onCascade?.({ limit: e, limitValue: t, event: s, depth: n, chain: r });
-    } catch (o) {
-      console.error("onCascade handler error:", o);
+    } catch (c) {
+      console.error("onCascade handler error:", c);
     }
   }
-  /**
-   * Checks if an event matches a `When` matcher.
-   *
-   * @param when - The When matcher (or undefined for "all events").
-   * @param event - The event to check.
-   * @returns `true` if the event matches, `false` otherwise.
-   *
-   * @remarks
-   * - `undefined` or missing `when` matches ALL events.
-   * - `{ any: true }` matches ALL events.
-   * - `{ keys: [...] }` matches if event's `[channel, type]` is in the array.
-   * - `{ channel: 'x' }` matches if event's channel equals 'x'.
-   * - `{ channels: ['x', 'y'] }` matches if event's channel is in the array.
-   *
-   * @internal
-   */
-  matchesWhen(e, t) {
-    return !e || "any" in e && e.any === !0 ? !0 : "keys" in e ? e.keys.some(
-      ([s, n]) => t.channel === s && t.type === n
-    ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
-  }
-  /**
-   * Extracts the middleware function from a MiddlewareInput.
-   * Handles both raw functions (legacy) and MiddlewareSpec objects.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The middleware function.
-   *
-   * @internal
-   */
-  getMiddlewareFunction(e) {
-    return typeof e == "function" ? e : e.middleware;
-  }
-  /**
-   * Gets the `when` matcher from a MiddlewareInput.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The `when` matcher, or `undefined` for raw functions (match all).
-   *
-   * @internal
-   */
-  getMiddlewareWhen(e) {
-    if (typeof e != "function")
-      return e.when;
-  }
   /**
    * Invokes all registered **effects** for a given event.
    * Handles both key-based effects (O(1) lookup) and pattern-based effects (runtime matching).
@@ -1227,11 +1261,11 @@ class x {
       for (const r of [...n])
         try {
           await r(e, this.getState, t);
-        } catch (o) {
-          console.error("Effect error:", o), this.onEffectError?.(o, e);
+        } catch (c) {
+          console.error("Effect error:", c), this.onEffectError?.(c, e);
         }
-    for (const { effect: r, when: o } of this.patternEffects)
-      if (this.matchesWhen(o, e))
+    for (const { effect: r, when: c } of this.patternEffects)
+      if (k(c, e))
         try {
           await r(e, this.getState, t);
         } catch (l) {
@@ -1254,7 +1288,7 @@ class x {
       depth: e.depth ?? 0,
       chain: [...this.currentEvent?.chain ?? [], e.id].slice(-z)
     };
-    return ((s, n, r, o) => this.emitCaused(t, s, n, r, o));
+    return ((s, n, r, c) => this.emitCaused(t, s, n, r, c));
   }
   /**
    * Notifies event subscribers for a specific phase.
@@ -1271,9 +1305,9 @@ class x {
     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);
+    const c = this.allEventSubscribers.get(s);
+    if (c?.size)
+      for (const l of [...c]) this.invokeEventSubscriber(l, e, t);
   }
   /**
    * Invokes a single event-subscription handler **fire-and-forget**: synchronous
@@ -1366,10 +1400,10 @@ class x {
    */
   stageSlice(e, t, s) {
     const n = this.state[e], r = this.reducers[e].reduce(n, t);
-    if (Q(r)) return r;
+    if (V(r)) return r;
     if (n === r) return null;
-    const o = I(n, r);
-    if (o.length === 0) return null;
+    const c = I(n, r);
+    if (c.length === 0) return null;
     const l = t.payload, i = process.env.NODE_ENV !== "production" && l !== null && typeof l == "object" ? {
       watch: l,
       onFound: () => {
@@ -1383,7 +1417,7 @@ class x {
       name: e,
       prev: n,
       frozen: R(r, i),
-      leafPaths: o
+      leafPaths: c
     }), null;
   }
   /**
@@ -1415,18 +1449,18 @@ class x {
           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 === "") {
+      for (const c of n.leafPaths) {
+        if (c === "") {
           r.add("");
           continue;
         }
-        for (const l of x.buildAncestorPaths(o)) r.add(l);
+        for (const l of x.buildAncestorPaths(c)) r.add(l);
       }
-      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,
+      for (const c of r)
+        this.connectorBus.emitWith(n.name, c, () => ({
+          oldValue: this.getAtPath(n.prev, c),
+          newValue: this.getAtPath(n.frozen, c),
+          path: c,
           // Provenance, built inside the same lazy factory as the values: a subscriber that
           // needs to know why a value moved no longer has to mirror the cause into state and
           // keep it there twice.
@@ -1454,10 +1488,10 @@ class x {
     }), t = [];
     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 });
+      const [a, u] = l.split("::");
+      for (const d of i) {
+        const h = this.effectMeta.get(d);
+        t.push({ channel: a, type: u, name: h?.name, description: h?.description });
       }
     }
     for (const l of this.patternEffects) {
@@ -1483,30 +1517,30 @@ class x {
     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" });
+      const [a, u] = l.split("::");
+      for (let d = 0; d < i.size; d++)
+        r.push({ channel: a, type: u, phase: "committed" });
     }
     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" });
+      const [a, u] = l.split("::");
+      for (let d = 0; d < i.size; d++)
+        r.push({ channel: a, type: u, phase: "uncommitted" });
     }
     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 [a, u] = l.split("::");
+      for (let d = 0; d < i.size; d++)
+        r.push({ channel: a, type: u, phase: "all" });
     }
-    const o = this.listeners.size;
+    const c = this.listeners.size;
     return {
       reducers: e,
       effects: t,
       middleware: s,
       atomic: n,
       event: r,
-      coarse: o,
+      coarse: c,
       dedupHits: this.dedupCount,
       queueDepth: this.reduceQueue.length + this.inFlightEffects
     };
@@ -1533,34 +1567,34 @@ class x {
       );
     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];
+    Object.keys(this.reducers).forEach((c) => {
+      const l = t?.[c], i = s?.[c];
       if (i === void 0) {
         process.env.NODE_ENV !== "production" && console.warn(
           `[yoltra] External state is missing slice "${String(
-            o
+            c
           )}"; retaining its current value. Time-travel snapshots should contain all slices.`
         );
         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 f of d) {
-        if (f === "") {
-          u.add("");
+      n[c] = a, r = !0;
+      const u = I(l, i);
+      if (u.length === 0) return;
+      const d = /* @__PURE__ */ new Set();
+      for (const h of u) {
+        if (h === "") {
+          d.add("");
           continue;
         }
-        for (const m of x.buildAncestorPaths(f)) u.add(m);
+        for (const p of x.buildAncestorPaths(h)) d.add(p);
       }
-      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 });
+      for (const h of d) {
+        const p = this.getAtPath(l, h), f = this.getAtPath(a, h);
+        this.connectorBus.emit(c, h, { oldValue: p, newValue: f, path: h });
       }
-    }), r && (this.state = n), r && this.listeners.forEach((o) => o());
+    }), r && (this.state = n), r && this.listeners.forEach((c) => c());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -1583,20 +1617,20 @@ class x {
     for (const s of t) {
       const n = s, r = [];
       this.stagingSink = r;
-      let o = null;
+      let c = null;
       try {
-        this.reducerBus.emit(n.channel, n.type, n.payload, n), o = this.stagedRejection;
+        this.reducerBus.emit(n.channel, n.type, n.payload, n), c = 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);
+          if (c !== null) break;
+          if (k(a, n)) {
+            const u = this.stageSliceGuarded(i, n, r);
+            u !== null && (c = u);
           }
         }
       } finally {
         this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
       }
-      const l = o === null && this.commitStaged(r, n);
+      const l = c === null && this.commitStaged(r, n);
       this.notifyEventSubscribers(n, "committed"), l && (this.notifyEventSubscribers(n, "written"), this.listeners.forEach((i) => i()));
     }
   }
@@ -1659,14 +1693,14 @@ class x {
    * @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 c = r?.dedupKey, l = this.dedupConfig.windowMs;
+    if (r?.skipDedup !== !0 && (l > 0 || c !== void 0)) {
+      const p = c !== void 0 && l <= 0 ? A : l, f = c !== void 0 ? `${t}::${s}::#${c}` : this.fingerprint(t, s, n);
+      if (this.shouldDedupe(f, p))
+        return S;
     }
-    const i = r?.id ?? this.idFactory(), a = this.currentEvent ?? e, d = a === null ? 0 : a.depth + 1;
-    if (a !== null && d > this.maxReduceDepth)
+    const i = r?.id ?? this.idFactory(), a = this.currentEvent ?? e, u = a === null ? 0 : a.depth + 1;
+    if (a !== null && u > this.maxReduceDepth)
       return this.reportCascade(
         "maxReduceDepth",
         this.maxReduceDepth,
@@ -1677,14 +1711,14 @@ class x {
           id: i,
           ...r?.meta !== void 0 ? { meta: r.meta } : {},
           parentId: a.id,
-          depth: d
+          depth: u
         },
-        d,
+        u,
         a.chain
-      ), $;
-    let u;
-    const f = new Promise((m) => {
-      u = m;
+      ), S;
+    let d;
+    const h = new Promise((p) => {
+      d = p;
     });
     return this.reduceQueue.push({
       channel: t,
@@ -1692,11 +1726,11 @@ class x {
       payload: n,
       id: i,
       meta: r?.meta,
-      resolve: u,
+      resolve: d,
       // Only carried for caused events, so a root event's object stays byte-identical to one
       // built before causality existed — the same rule `meta` follows.
-      ...a !== null ? { parentId: a.id, depth: d, chain: a.chain } : {}
-    }), this.drainReduce(), f;
+      ...a !== null ? { parentId: a.id, depth: u, chain: a.chain } : {}
+    }), this.drainReduce(), h;
   }
   /**
    * Drains the reduce queue **synchronously**. For each event it runs middleware,
@@ -1713,47 +1747,47 @@ class x {
       this.isReducing = !0, this.transitionsThisDrain = 0;
       try {
         for (; this.reduceQueue.length > 0; ) {
-          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 = {
+          const e = this.reduceQueue.shift(), { channel: t, type: s, payload: n, id: r, meta: c, resolve: l, parentId: i, depth: a, chain: u } = e, d = {
             channel: t,
             type: s,
             payload: n,
             id: r,
-            ...o !== void 0 ? { meta: o } : {},
+            ...c !== void 0 ? { meta: c } : {},
             ...i !== void 0 ? { parentId: i, depth: a } : {}
           };
           if (i !== void 0 && ++this.transitionsThisDrain > this.maxTransitionsPerDrain) {
             this.reportCascade(
               "maxTransitionsPerDrain",
               this.maxTransitionsPerDrain,
-              u,
+              d,
               a,
-              d
-            ), l($);
+              u
+            ), l(S);
             continue;
           }
           this.currentEvent = {
             id: r,
             depth: a ?? 0,
-            chain: [...d ?? [], r].slice(-z)
+            chain: [...u ?? [], 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 = $;
+          const h = this.instrumentObservers.size > 0, p = h ? this.state : void 0, f = h ? [] : void 0;
+          f !== void 0 && (this.changedPathSink = f);
+          const m = h ? _() : 0;
+          let y = S;
           try {
-            g = this.applyEventSync(u);
-          } catch (w) {
-            console.error("Emit reduce error:", w);
+            y = this.applyEventSync(d);
+          } catch (g) {
+            console.error("Emit reduce error:", g);
           } finally {
-            f && (this.changedPathSink = null), this.currentEvent = null;
+            h && (this.changedPathSink = null), this.currentEvent = null;
           }
-          f && this.emitInstrumentation(
-            u,
-            g,
-            h ?? [],
-            m,
-            A() - y
-          ), this.runEventEffects(u, g, l);
+          h && this.emitInstrumentation(
+            d,
+            y,
+            f ?? [],
+            p,
+            _() - m
+          ), this.runEventEffects(d, y, l);
         }
       } finally {
         this.isReducing = !1;
@@ -1771,20 +1805,20 @@ class x {
    * @internal
    */
   applyEventSync(e) {
-    for (const o of this.middleware) {
-      const l = this.getMiddlewareWhen(o);
-      if (!this.matchesWhen(l, e)) continue;
-      const i = this.getMiddlewareFunction(o);
+    for (const c of this.middleware) {
+      const l = se(c);
+      if (!k(l, e)) continue;
+      const i = ne(c);
       let a;
       try {
         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 (d) {
-        console.error("Middleware error:", d), a = !1;
+      } catch (u) {
+        console.error("Middleware error:", u), a = !1;
       }
       if (!a)
-        return this.notifyEventSubscribers(e, "uncommitted"), $;
+        return this.notifyEventSubscribers(e, "uncommitted"), S;
     }
     const t = [];
     this.stagingSink = t;
@@ -1796,11 +1830,11 @@ class x {
         e.payload,
         e
       ), s = this.stagedRejection, n = this.stagedRejectedBy;
-      for (const [o, l] of this.patternReducers) {
+      for (const [c, 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);
+        if (k(l, e)) {
+          const i = this.stageSliceGuarded(c, e, t);
+          i !== null && (s = i, n = c);
         }
       }
     } finally {
@@ -1809,7 +1843,7 @@ class x {
     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;
+    return this.notifyEventSubscribers(e, "committed"), r && (this.notifyEventSubscribers(e, "written"), this.listeners.forEach((c) => c())), r ? ce : oe;
   }
   /**
    * Runs a single committed event's effects as an **independent async task**,
@@ -1848,9 +1882,9 @@ class x {
    * @internal
    */
   emitInstrumentation(e, t, s, n, r) {
-    const o = {}, l = {};
+    const c = {}, l = {};
     for (const a of s)
-      o[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
+      c[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
     const i = {
       event: {
         id: e.id,
@@ -1863,7 +1897,7 @@ class x {
       },
       committed: t.committed,
       changedPaths: s,
-      prevValues: o,
+      prevValues: c,
       nextValues: l,
       reduceTimeMs: r,
       // Present only when a reducer refused, so an observer can tell a refusal from a veto —
@@ -1873,8 +1907,8 @@ class x {
     for (const a of [...this.instrumentObservers])
       try {
         a(i);
-      } catch (d) {
-        console.error("Instrumentation observer error:", d);
+      } catch (u) {
+        console.error("Instrumentation observer error:", u);
       }
   }
   /**
@@ -1908,8 +1942,8 @@ class x {
   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 });
+      const r = this.state[e.reducer], c = e.property.includes("*") ? "" : e.property;
+      t({ oldValue: void 0, newValue: this.getAtPath(r, c), path: c });
     }
     return n;
   }
@@ -1960,10 +1994,10 @@ class x {
    * @public
    */
   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));
+    const r = `${e}::${String(t)}`, c = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : n === "written" ? this.writtenEventSubscribers : this.allEventSubscribers;
+    return c.has(r) || c.set(r, /* @__PURE__ */ new Set()), c.get(r).add(s), () => {
+      const l = c.get(r);
+      l && (l.delete(s), l.size === 0 && c.delete(r));
     };
   }
   /**
@@ -2168,13 +2202,7 @@ class x {
    * 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.
+   * **This is a local primitive.**
    *
    * @example Timeout is idle, not total
    * ```ts
@@ -2191,58 +2219,13 @@ class x {
    * @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 })
-      })
-    };
+    return Z(
+      { idFactory: this.idFactory, registerEffect: this.registerEffect, emit: this.emit },
+      e,
+      t,
+      s,
+      n
+    );
   }
   registerEffect(e) {
     const { effect: t, meta: s, when: n } = e, r = [];
@@ -2252,7 +2235,7 @@ class x {
         this.patternEffects.delete(i);
       };
     }
-    const l = this.normalizeEventKeys(e);
+    const l = D(e);
     if (l.length === 0 && !n) {
       const i = { effect: t, when: { any: !0 } };
       return this.patternEffects.add(i), () => {
@@ -2260,10 +2243,10 @@ class x {
       };
     }
     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));
+      const u = `${String(i)}::${String(a)}`;
+      this.effects.has(u) || this.effects.set(u, /* @__PURE__ */ new Set()), this.effects.get(u).add(t), r.push(() => {
+        const d = this.effects.get(u);
+        d && (d.delete(t), d.size === 0 && this.effects.delete(u));
       });
     }
     return () => {
@@ -2292,10 +2275,10 @@ class x {
    * @public
    */
   onEffect(e, t, s) {
-    const n = async (r, o, l) => {
+    const n = async (r, c, l) => {
       if (r.channel !== e || r.type !== t) return;
       const i = r;
-      return s(i.payload, o, l, i);
+      return s(i.payload, c, l, i);
     };
     return this.registerEffect({
       when: { keys: [[e, t]] },
@@ -2361,9 +2344,9 @@ class x {
    * @public
    */
   replaceReducers(e, t = {}) {
-    const s = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), r = Object.entries(e), o = new Set(r.map(([l]) => l));
+    const s = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), r = Object.entries(e), c = new Set(r.map(([l]) => l));
     for (const l of n)
-      o.has(l) || this.unmountSlice(l, { deleteState: !0 });
+      c.has(l) || this.unmountSlice(l, { deleteState: !0 });
     for (const [l, i] of r)
       n.has(l) ? (this.unmountSlice(l, { deleteState: !1 }), this.mountSlice(l, i, { preserveState: s })) : this.mountSlice(l, i, { preserveState: !1 });
   }
@@ -2398,35 +2381,35 @@ class x {
    * @internal
    */
   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 = {
+    const n = e, { reducer: r, state: c, when: l } = t;
+    if (this.reducers[e] = new L(r), (!s.preserveState || this.state[n] === void 0) && (this.state = {
       ...this.state,
-      [n]: R(X(n, o))
+      [n]: R(re(n, c))
     }), l && ("any" in l && l.any === !0 || "channel" in l || "channels" in l)) {
       this.patternReducers.set(e, l), this.sliceUnsubs.set(n, []);
       return;
     }
-    const a = this.normalizeEventKeys(t);
+    const a = D(t);
     if (a.length === 0 && !l) {
       this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
       return;
     }
-    const d = [];
-    for (const [u, f] of a) {
-      const m = this.reducerBus.on(u, f, (h, y) => {
-        const g = y ?? {
-          channel: u,
-          type: f,
-          payload: h,
+    const u = [];
+    for (const [d, h] of a) {
+      const p = this.reducerBus.on(d, h, (f, m) => {
+        const y = m ?? {
+          channel: d,
+          type: h,
+          payload: f,
           id: this.idFactory()
         };
         if (this.stagingSink === null) return;
-        const w = this.stageSliceGuarded(e, g, this.stagingSink);
-        w !== null && this.stagedRejection === null && (this.stagedRejection = w, this.stagedRejectedBy = e);
+        const g = this.stageSliceGuarded(e, y, this.stagingSink);
+        g !== null && this.stagedRejection === null && (this.stagedRejection = g, this.stagedRejectedBy = e);
       });
-      d.push(m);
+      u.push(p);
     }
-    this.sliceUnsubs.set(n, d);
+    this.sliceUnsubs.set(n, u);
   }
   /**
    * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
@@ -2445,32 +2428,16 @@ class x {
       for (const r of n)
         try {
           r();
-        } catch (o) {
-          console.error(`[Store error]: ${o}`);
+        } catch (c) {
+          console.error(`[Store error]: ${c}`);
         }
       this.sliceUnsubs.delete(s);
     }
     if (delete this.reducers[e], t.deleteState) {
-      const { [s]: r, ...o } = this.state;
-      this.state = o;
+      const { [s]: r, ...c } = this.state;
+      this.state = c;
     }
   }
-  /**
-   * Normalizes event targeting from `when` to an array of EventKeys.
-   *
-   * @param spec - Object with an optional `when` matcher.
-   * @returns Array of `[channel, type]` pairs.
-   *
-   * @internal
-   */
-  normalizeEventKeys(e) {
-    if (e.when) {
-      const t = e.when;
-      if ("keys" in t)
-        return t.keys;
-    }
-    return [];
-  }
   /**
    * Reads a dotted path from an object (supports numeric array indices via string keys).
    *
@@ -2478,17 +2445,14 @@ class x {
    * @param path - Dotted path; leading dot is ignored.
    * @returns The value at the path, or `undefined`.
    *
+   * @remarks
+   * A member rather than a bare import: a test replaces this on the instance to count how many
+   * walks describing a change costs, which only works while the callers go through `this`.
+   *
    * @internal
    */
   getAtPath(e, t) {
-    if (!t) return e;
-    const n = (t[0] === "." ? t.slice(1) : t).split(".");
-    let r = e;
-    for (const o of n) {
-      if (r == null) return;
-      r = r[o];
-    }
-    return r;
+    return ee(e, t);
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -2506,72 +2470,68 @@ class x {
    * @public
    */
   static buildAncestorPaths(e) {
-    if (!e) return [];
-    const s = (e[0] === "." ? e.slice(1) : e).split("."), n = [];
-    for (let r = 0; r < s.length; r++)
-      n.push(s.slice(0, r + 1).join("."));
-    return n;
+    return te(e);
   }
 }
-function de(c) {
+function he(o) {
   return new x({
-    ...c,
-    reducer: c.reducer ?? {},
-    middleware: c.middleware ?? [],
-    effects: c.effects ?? []
+    ...o,
+    reducer: o.reducer ?? {},
+    middleware: o.middleware ?? [],
+    effects: o.effects ?? []
   });
 }
-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(
+const pe = (o) => (e, t) => t.map((s) => [e, s]), me = () => (o) => o, j = /* @__PURE__ */ new Set();
+function ae(o) {
+  const e = String(o);
+  j.has(e) || (j.add(e), console.warn(
     `[yoltra] Entity id "${e}" contains a dot. Paths are dotted, so a subscription to "entities.${e}" is indistinguishable from one to a nested object of the same name. Use ids without dots.`
   ));
 }
-function 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 le(o, e) {
+  if (o.length !== e.length) return e;
+  for (let t = 0; t < o.length; t++)
+    if (o[t] !== e[t]) return e;
+  return o;
 }
-function he(c = {}) {
-  const e = c.selectId ?? ((i) => i.id), { sortComparer: t } = c, s = (i, a) => {
+function ye(o = {}) {
+  const e = o.selectId ?? ((i) => i.id), { sortComparer: t } = o, 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);
+    const u = [...a].sort((d, h) => {
+      const p = i.entities[d], f = i.entities[h];
+      return p === void 0 || f === void 0 ? 0 : t(p, f);
     });
-    return 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 le(a, u);
+  }, n = (i, a, u) => {
+    const d = { ...i, entities: a, ids: u };
+    return { ...d, ids: s(d, u) };
+  }, r = (i, a, u) => {
+    let d = null, h = null;
+    for (const p of a) {
+      const f = e(p);
+      process.env.NODE_ENV !== "production" && String(f).includes(".") && ae(f);
+      const m = (d ?? i.entities)[f];
+      if (m !== void 0 && u === "add") continue;
+      const y = m !== void 0 && u === "upsert" ? { ...m, ...p } : p;
+      d ??= { ...i.entities }, d[f] = y, m === void 0 && (h ??= [...i.ids], h.push(f));
     }
-    return u === null ? 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 d === null ? i : n(i, d, h ?? i.ids);
+  }, c = (i, a) => {
+    let u = null;
+    for (const { id: d, changes: h } of a) {
+      const p = (u ?? i.entities)[d];
+      p !== void 0 && (u ??= { ...i.entities }, u[d] = { ...p, ...h });
     }
-    return d === null ? i : n(i, d, i.ids);
+    return u === null ? i : n(i, u, 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];
+    const u = new Set(a.filter((h) => i.entities[h] !== void 0));
+    if (u.size === 0) return i;
+    const d = { ...i.entities };
+    for (const h of u) delete d[h];
     return n(
       i,
-      u,
-      i.ids.filter((f) => !d.has(f))
+      d,
+      i.ids.filter((h) => !u.has(h))
     );
   };
   return {
@@ -2584,15 +2544,15 @@ function he(c = {}) {
     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;
+      const u = {}, d = [];
+      for (const h of a) {
+        const p = e(h);
+        u[p] === void 0 && d.push(p), u[p] = h;
       }
-      return n(i, d, u);
+      return n(i, u, d);
     },
-    updateOne: (i, a) => o(i, [a]),
-    updateMany: (i, a) => o(i, a),
+    updateOne: (i, a) => c(i, [a]),
+    updateMany: (i, a) => c(i, a),
     upsertOne: (i, a) => r(i, [a], "upsert"),
     upsertMany: (i, a) => r(i, a, "upsert"),
     removeOne: (i, a) => l(i, [a]),
@@ -2608,76 +2568,76 @@ function he(c = {}) {
     anyField: (i) => `entities.*.${i}`
   };
 }
-const E = "$yoltra";
-function B(c, e = {}) {
+const w = "$yoltra";
+function H(o, 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) {
+  let c = 0, l = !1;
+  function i(u, d) {
+    if (s !== void 0 && (u = s(d, u)), c += 1, c > t)
+      return l = !0, { [w]: "unsupported", kind: "truncated" };
+    switch (typeof u) {
       case "undefined":
-        return { [E]: "undefined" };
+        return { [w]: "undefined" };
       case "bigint":
-        return { [E]: "bigint", value: d.toString() };
+        return { [w]: "bigint", value: u.toString() };
       case "number":
-        return Number.isNaN(d) ? { [E]: "nan" } : d === 1 / 0 ? { [E]: "infinity", sign: 1 } : d === -1 / 0 ? { [E]: "infinity", sign: -1 } : d;
+        return Number.isNaN(u) ? { [w]: "nan" } : u === 1 / 0 ? { [w]: "infinity", sign: 1 } : u === -1 / 0 ? { [w]: "infinity", sign: -1 } : u;
       case "function":
       case "symbol":
-        return n.push(u), { [E]: "unsupported", kind: typeof d };
+        return n.push(d), { [w]: "unsupported", kind: typeof u };
       case "string":
       case "boolean":
-        return d;
+        return u;
     }
-    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, k] of d)
-        y.push([i(w, `${u}/@k${g}`), i(k, `${u}/${g}`)]), g += 1;
-      return { [E]: "map", entries: y };
+    if (u === null) return null;
+    const h = u, p = r.get(h);
+    if (p !== void 0) return { [w]: "ref", path: p };
+    if (r.set(h, d), u instanceof Date)
+      return { [w]: "date", iso: u.toISOString() };
+    if (u instanceof RegExp)
+      return { [w]: "regexp", source: u.source, flags: u.flags };
+    if (u instanceof Error)
+      return { [w]: "error", name: u.name, message: u.message };
+    if (u instanceof Map) {
+      const m = [];
+      let y = 0;
+      for (const [g, $] of u)
+        m.push([i(g, `${d}/@k${y}`), i($, `${d}/${y}`)]), y += 1;
+      return { [w]: "map", entries: m };
     }
-    if (d instanceof Set) {
-      const y = [];
-      let g = 0;
-      for (const w of d)
-        y.push(i(w, `${u}/${g}`)), g += 1;
-      return { [E]: "set", values: y };
+    if (u instanceof Set) {
+      const m = [];
+      let y = 0;
+      for (const g of u)
+        m.push(i(g, `${d}/${y}`)), y += 1;
+      return { [w]: "set", values: m };
     }
-    if (Array.isArray(d))
-      return d.map((y, g) => i(y, `${u}/${g}`));
-    const h = {};
-    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: i(c, ""), report: { truncated: l, unsupported: n } };
+    if (Array.isArray(u))
+      return u.map((m, y) => i(m, `${d}/${y}`));
+    const f = {};
+    for (const [m, y] of Object.entries(u))
+      f[m] = i(y, `${d}/${F(m)}`);
+    return w in f ? { [w]: "escaped", value: f } : f;
+  }
+  return { value: i(o, ""), report: { truncated: l, unsupported: n } };
 }
-function oe(c) {
+function ue(o) {
   const e = /* @__PURE__ */ new Map(), t = [];
-  function s(o, l) {
-    if (o === null || typeof o != "object") return o;
-    if (Array.isArray(o)) {
+  function s(c, l) {
+    if (c === null || typeof c != "object") return c;
+    if (Array.isArray(c)) {
       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 e.set(l, a), c.forEach((u, d) => {
+        if (N(u)) {
+          t.push({ target: a, key: d, path: u.path }), a[d] = void 0;
           return;
         }
-        a[u] = s(d, `${l}/${u}`);
+        a[d] = s(u, `${l}/${d}`);
       }), a;
     }
-    if (typeof o[E] == "string") {
-      const a = o;
-      switch (a[E]) {
+    if (typeof c[w] == "string") {
+      const a = c;
+      switch (a[w]) {
         case "undefined":
           return;
         case "nan":
@@ -2691,22 +2651,22 @@ function oe(c) {
         case "regexp":
           return new RegExp(a.source, a.flags);
         case "error": {
-          const d = new Error(a.message);
-          return d.name = a.name, d;
+          const u = new Error(a.message);
+          return u.name = a.name, u;
         }
         case "unsupported":
           return;
         case "ref":
           return;
         case "map": {
-          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;
+          const u = /* @__PURE__ */ new Map();
+          return e.set(l, u), a.entries.forEach(([d, h], p) => {
+            u.set(s(d, `${l}/@k${p}`), s(h, `${l}/${p}`));
+          }), u;
         }
         case "set": {
-          const d = /* @__PURE__ */ new Set();
-          return e.set(l, d), a.values.forEach((u, f) => d.add(s(u, `${l}/${f}`))), d;
+          const u = /* @__PURE__ */ new Set();
+          return e.set(l, u), a.values.forEach((d, h) => u.add(s(d, `${l}/${h}`))), u;
         }
         case "escaped":
           return n(a.value, l);
@@ -2714,37 +2674,37 @@ function oe(c) {
           return;
       }
     }
-    return n(o, l);
+    return n(c, l);
   }
-  function n(o, l) {
+  function n(c, 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;
+    for (const [a, u] of Object.entries(c)) {
+      const d = `${l}/${F(a)}`;
+      if (N(u)) {
+        t.push({ target: i, key: a, path: u.path }), i[a] = void 0;
         continue;
       }
-      i[a] = s(d, u);
+      i[a] = s(u, d);
     }
     return i;
   }
-  const r = s(c, "");
+  const r = s(o, "");
   e.set("", r);
-  for (const { target: o, key: l, path: i } of t)
-    o[l] = e.get(i);
+  for (const { target: c, key: l, path: i } of t)
+    c[l] = e.get(i);
   return r;
 }
-function j(c) {
-  return c !== null && typeof c == "object" && c[E] === "ref" && typeof c.path == "string";
+function N(o) {
+  return o !== null && typeof o == "object" && o[w] === "ref" && typeof o.path == "string";
 }
-function H(c) {
-  return c.replace(/~/g, "~0").replace(/\//g, "~1");
+function F(o) {
+  return o.replace(/~/g, "~0").replace(/\//g, "~1");
 }
-function pe(c, e, t = {}) {
+function ge(o, 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 });
+    const { value: r, report: c } = H(o, { ...t, maxNodes: s });
     let l;
     try {
       l = JSON.stringify(r)?.length ?? 0;
@@ -2752,7 +2712,7 @@ function pe(c, e, t = {}) {
       l = Number.POSITIVE_INFINITY;
     }
     if (l <= e)
-      return o.truncated ? {
+      return c.truncated ? {
         value: r,
         truncated: !0,
         note: `State was too large to send in full; parts beyond ${s} nodes are omitted.`
@@ -2762,108 +2722,108 @@ function pe(c, e, t = {}) {
       break;
   }
   return {
-    value: { [E]: "unsupported", kind: "truncated" },
+    value: { [w]: "unsupported", kind: "truncated" },
     truncated: !0,
     note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
   };
 }
-function v(c, e, t) {
-  c.onError?.(e, t);
+function b(o, e, t) {
+  o.onError?.(e, t);
 }
-async function me(c) {
+async function we(o) {
   const e = { slices: {}, restored: !1 };
   let t;
   try {
-    t = c.source ?? await c.adapter.read(c.key);
+    t = o.source ?? await o.adapter.read(o.key);
   } catch (n) {
-    return v(c, n, "read"), e;
+    return b(o, n, "read"), e;
   }
   if (t == null || t === "") return e;
   let s;
   try {
-    s = oe(JSON.parse(t));
+    s = ue(JSON.parse(t));
   } catch (n) {
-    return v(c, n, "decode"), e;
+    return b(o, 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,
+    return b(o, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
+  if (s.version !== o.version) {
+    if (o.migrate === void 0)
+      return b(
+        o,
         new Error(
-          `persisted state is version ${s.version}, this build expects ${c.version}, and no migrate was supplied`
+          `persisted state is version ${s.version}, this build expects ${o.version}, and no migrate was supplied`
         ),
         "migrate"
       ), e;
     try {
-      const n = c.migrate(s.slices, s.version);
+      const n = o.migrate(s.slices, s.version);
       return n === null ? e : { slices: n, restored: !0 };
     } catch (n) {
-      return v(c, n, "migrate"), e;
+      return b(o, n, "migrate"), e;
     }
   }
   return { slices: s.slices ?? {}, restored: !0 };
 }
-function ye(c, e) {
-  if (!e.restored) return c;
+function Ee(o, e) {
+  if (!e.restored) return o;
   const t = {};
-  for (const [s, n] of Object.entries(c)) {
+  for (const [s, n] of Object.entries(o)) {
     const r = e.slices[s];
     t[s] = r === void 0 ? n : { ...n, state: r };
   }
   return t;
 }
-function 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 K(o, e) {
+  const t = o ?? {}, s = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((n) => n in t).map((n) => [n, t[n]]));
+  return JSON.stringify(H({ version: e.version, slices: s }).value);
 }
-function ge(c, e) {
+function be(o, e) {
   const t = e.throttleMs ?? 250, s = e.slices;
   let n = null, r = !1;
-  const o = () => {
+  const c = () => {
     if (r) {
       r = !1;
       try {
-        const a = e.adapter.write(e.key, W(c.getState(), e));
-        a instanceof Promise && a.catch((d) => v(e, d, "write"));
+        const a = e.adapter.write(e.key, K(o.getState(), e));
+        a instanceof Promise && a.catch((u) => b(e, u, "write"));
       } catch (a) {
-        v(e, a, "write");
+        b(e, a, "write");
       }
     }
   }, l = () => {
     if (r = !0, t <= 0) {
-      o();
+      c();
       return;
     }
     n === null && (n = setTimeout(() => {
-      n = null, o();
+      n = null, c();
     }, t), n.unref?.());
-  }, i = c.instrument((a) => {
+  }, i = o.instrument((a) => {
     if (s === void 0) {
       l();
       return;
     }
     (a.changedPaths ?? []).some(
-      (u) => s.some((f) => u === f || u.startsWith(`${f}.`))
+      (d) => s.some((h) => d === h || d.startsWith(`${h}.`))
     ) && l();
   });
   return () => {
-    i(), n !== null && (clearTimeout(n), n = null), o();
+    i(), n !== null && (clearTimeout(n), n = null), c();
   };
 }
-function we(c, e) {
-  return W(c.getState(), e);
+function ve(o, e) {
+  return K(o.getState(), e);
 }
-function Ee(c) {
+function Se(o) {
   return {
-    read: (e) => c.getItem(e),
-    write: (e, t) => c.setItem(e, t),
-    remove: (e) => c.removeItem(e)
+    read: (e) => o.getItem(e),
+    write: (e, t) => o.setItem(e, t),
+    remove: (e) => o.removeItem(e)
   };
 }
-function be(c) {
-  const e = new Map(Object.entries(c ?? {}));
+function $e(o) {
+  const e = new Map(Object.entries(o ?? {}));
   return {
     read: (t) => e.get(t) ?? null,
     write: (t, s) => {
@@ -2876,27 +2836,27 @@ function be(c) {
 }
 export {
   C as CallAbortedError,
-  J as CallTimeoutError,
-  U as EventBus,
-  L as LooseEventBus,
-  V as Reducer,
-  le as Rejected,
+  Q as CallTimeoutError,
+  W as EventBus,
+  U as LooseEventBus,
+  L as Reducer,
+  fe as Rejected,
   x as Store,
-  he as createEntityAdapter,
-  be as createMemoryAdapter,
-  de as createStore,
-  Ee as createWebStorageAdapter,
-  oe as decodeState,
-  we as dehydrate,
+  ye as createEntityAdapter,
+  $e as createMemoryAdapter,
+  he as createStore,
+  Se as createWebStorageAdapter,
+  ue as decodeState,
+  ve as dehydrate,
   I as detectChangedProps,
-  B as encodeState,
-  pe as encodeStateBounded,
-  fe as eventKeys,
+  H as encodeState,
+  ge as encodeStateBounded,
+  me as eventKeys,
   M as freezeState,
-  me as hydrate,
-  Q as isRejected,
-  ge as persist,
-  ue as typedEvents,
-  ye as withHydration
+  we as hydrate,
+  V as isRejected,
+  be as persist,
+  pe as typedEvents,
+  Ee as withHydration
 };
 //# sourceMappingURL=yoltra.mjs.map