@yoltra/core 0.6.0 → 0.8.0

package/dist/yoltra.mjs

@@ -1,23 +1,13 @@
 /*!
- * @yoltra/core v0.6.0
+ * @yoltra/core v0.8.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 G {
+  /**
+   * Internal registry: `channel → type → Set<handler>`.
+   * @internal
+   */
+  handlers = /* @__PURE__ */ new Map();
   /**
    * Subscribes a handler to an exact `(channel, type)`.
    *
@@ -50,11 +40,11 @@ class U {
    *
    * @public
    */
-  on(e, t, s) {
-    let n = this.handlers.get(e);
-    n || (n = /* @__PURE__ */ new Map(), this.handlers.set(e, n));
-    let r = n.get(t);
-    return r || (r = /* @__PURE__ */ new Set(), n.set(t, r)), r.add(s), () => this.off(e, t, s);
+  on(e, t, n) {
+    let r = this.handlers.get(e);
+    r || (r = /* @__PURE__ */ new Map(), this.handlers.set(e, r));
+    let i = r.get(t);
+    return i || (i = /* @__PURE__ */ new Set(), r.set(t, i)), i.add(n), () => this.off(e, t, n);
   }
   /**
    * Removes a specific handler previously added with {@link EventBus.on | `on`}.
@@ -76,11 +66,11 @@ class U {
    *
    * @public
    */
-  off(e, t, s) {
-    const n = this.handlers.get(e);
-    if (!n) return;
-    const r = n.get(t);
-    r && (r.delete(s), r.size === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e));
+  off(e, t, n) {
+    const r = this.handlers.get(e);
+    if (!r) return;
+    const i = r.get(t);
+    i && (i.delete(n), i.size === 0 && r.delete(t), r.size === 0 && this.handlers.delete(e));
   }
   /**
    * Emits an event to all subscribers of the exact `(channel, type)`.
@@ -104,16 +94,16 @@ class U {
    *
    * @public
    */
-  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])
+  emit(e, t, n, r) {
+    const i = this.handlers.get(e);
+    if (!i) return;
+    const s = i.get(t);
+    if (!(!s || s.size === 0))
+      for (const l of [...s])
         try {
-          l(s, n);
-        } catch (i) {
-          console.error("EventBus handler error:", i);
+          l(n, r);
+        } catch (c) {
+          console.error("EventBus handler error:", c);
         }
   }
   /**
@@ -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 J {
+  /**
+   * Exact handlers: `channel → type → [handlers]`.
+   * @internal
+   */
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
+   * @internal
+   */
+  patternHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Patterns bucketed by their first segment, so an emit tests only what could match.
+   *
+   * @remarks
+   * Delivery used to walk every pattern registered on the channel and run the full segment
+   * matcher against each. That is linear in the number of patterns rather than in the number
+   * that match, and it re-split both the pattern and the subject on every test — for a thousand
+   * patterns, two thousand string splits to deliver one event.
+   *
+   * A subject's first segment can only be matched by a pattern whose first segment is that same
+   * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
+   * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
+   * the handful that begin with a wildcard.
+   *
+   * It buys nothing for a channel where every pattern starts with `**`, since all of those must
+   * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
+   */
+  patternIndex = /* @__PURE__ */ new Map();
   /**
    * Subscribes a handler to either an **exact** type or a **pattern**.
    *
@@ -196,18 +184,18 @@ class L {
    *
    * @public
    */
-  on(e, t, s) {
-    const n = String(t);
-    if (this.isPattern(n)) {
-      const r = n;
+  on(e, t, n) {
+    const r = String(t);
+    if (this.isPattern(r)) {
+      const i = r;
       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 s = this.patternHandlers.get(e);
+      return s.has(i) || (s.set(i, []), this.indexPattern(e, i)), s.get(i).push(n), () => this.offPattern(e, i, n);
     } else {
-      const r = this.normalizeTypeKey(n);
+      const i = this.normalizeTypeKey(r);
       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 s = this.handlers.get(e);
+      return s.has(i) || s.set(i, []), s.get(i).push(n), () => this.offExactNormalized(e, i, n);
     }
   }
   /**
@@ -228,9 +216,9 @@ class L {
    *
    * @public
    */
-  off(e, t, s) {
-    const n = this.normalizeTypeKey(String(t));
-    this.offExactNormalized(e, n, s);
+  off(e, t, n) {
+    const r = this.normalizeTypeKey(String(t));
+    this.offExactNormalized(e, r, n);
   }
   /**
    * Internal exact unsubscription using an already **normalized** type key.
@@ -240,13 +228,13 @@ class L {
    * @param handler - Handler to remove.
    * @internal
    */
-  offExactNormalized(e, t, s) {
-    const n = this.handlers.get(e);
-    if (!n) return;
-    const r = n.get(t);
+  offExactNormalized(e, t, n) {
+    const r = this.handlers.get(e);
     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 i = r.get(t);
+    if (!i) return;
+    const s = i.indexOf(n);
+    s !== -1 && i.splice(s, 1), i.length === 0 && r.delete(t), r.size === 0 && this.handlers.delete(e);
   }
   /**
    * Internal removal for a **pattern** subscription. No-ops if missing.
@@ -256,13 +244,13 @@ class L {
    * @param handler - Handler to remove.
    * @internal
    */
-  offPattern(e, t, s) {
-    const n = this.patternHandlers.get(e);
-    if (!n) return;
-    const r = n.get(t);
+  offPattern(e, t, n) {
+    const r = this.patternHandlers.get(e);
     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 i = r.get(t);
+    if (!i) return;
+    const s = i.indexOf(n);
+    s !== -1 && i.splice(s, 1), i.length === 0 && (r.delete(t), this.unindexPattern(e, t)), r.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
   }
   /**
    * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
@@ -284,20 +272,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);
+  emit(e, t, n) {
+    const r = String(t), i = this.normalizeTypeKey(r), s = this.handlers.get(e)?.get(i) ?? [], l = this.matchingPatternHandlers(e, r), c = /* @__PURE__ */ new Set(), a = (d) => {
+      for (const f of [...d])
+        if (!c.has(f)) {
+          c.add(f);
           try {
-            u(s);
-          } catch (f) {
-            console.error(f);
+            f(n);
+          } catch (u) {
+            console.error(u);
             continue;
           }
         }
     };
-    a(o);
+    a(s);
     for (const d of l) a(d);
   }
   /**
@@ -316,23 +304,23 @@ 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);
+  emitWith(e, t, n) {
+    const r = String(t), i = this.normalizeTypeKey(r), s = this.handlers.get(e)?.get(i) ?? [], l = this.matchingPatternHandlers(e, r);
+    if (s.length === 0 && l.length === 0) return;
+    const c = n(), a = /* @__PURE__ */ new Set(), d = (f) => {
+      for (const u of [...f])
+        if (!a.has(u)) {
+          a.add(u);
           try {
-            f(i);
-          } catch (m) {
-            console.error(m);
+            u(c);
+          } catch (p) {
+            console.error(p);
             continue;
           }
         }
     };
-    d(o);
-    for (const u of l) d(u);
+    d(s);
+    for (const f of l) d(f);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -371,27 +359,27 @@ class L {
    * @internal
    */
   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 === "**") {
-      s.anyHead.push(r);
+    let n = this.patternIndex.get(e);
+    n === void 0 && (n = { byHead: /* @__PURE__ */ new Map(), anyHead: [] }, this.patternIndex.set(e, n));
+    const r = this.splitPath(t), i = { pattern: t, segments: r }, s = r[0];
+    if (s === void 0 || s === "*" || s === "**") {
+      n.anyHead.push(i);
       return;
     }
-    const l = s.byHead.get(o);
-    l === void 0 ? s.byHead.set(o, [r]) : l.push(r);
+    const l = n.byHead.get(s);
+    l === void 0 ? n.byHead.set(s, [i]) : l.push(i);
   }
   /**
    * Removes a pattern from the index. Paired with {@link LooseEventBus.offPattern}.
    * @internal
    */
   unindexPattern(e, t) {
-    const s = this.patternIndex.get(e);
-    if (s === void 0) return;
-    const n = this.splitPath(t)[0], r = n === void 0 || n === "*" || n === "**" ? s.anyHead : s.byHead.get(n);
-    if (r === void 0) return;
-    const o = r.findIndex((l) => l.pattern === t);
-    o !== -1 && r.splice(o, 1), r.length === 0 && r !== s.anyHead && n !== void 0 && s.byHead.delete(n);
+    const n = this.patternIndex.get(e);
+    if (n === void 0) return;
+    const r = this.splitPath(t)[0], i = r === void 0 || r === "*" || r === "**" ? n.anyHead : n.byHead.get(r);
+    if (i === void 0) return;
+    const s = i.findIndex((l) => l.pattern === t);
+    s !== -1 && i.splice(s, 1), i.length === 0 && i !== n.anyHead && r !== void 0 && n.byHead.delete(r);
   }
   /**
    * The handler lists of every pattern matching this subject.
@@ -405,20 +393,20 @@ class L {
    * @internal
    */
   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) => {
+    const n = this.patternHandlers.get(e), r = this.patternIndex.get(e);
+    if (n === void 0 || n.size === 0 || r === void 0) return [];
+    const i = this.splitPath(t), s = [], 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);
+        if (!this.matchSegments(d.segments, i)) continue;
+        const f = n.get(d.pattern);
+        f !== void 0 && s.push(f);
       }
-    }, i = r[0];
-    if (i !== void 0) {
-      const a = n.byHead.get(i);
+    }, c = i[0];
+    if (c !== void 0) {
+      const a = r.byHead.get(c);
       a !== void 0 && l(a);
     }
-    return l(n.anyHead), o;
+    return l(r.anyHead), s;
   }
   /**
    * Pattern matcher over dot-separated segments, which arrive already split.
@@ -449,18 +437,18 @@ class L {
    * @internal
    */
   matchSegments(e, t) {
-    let s = 0, n = 0, r = -1, o = 0;
-    for (; n < t.length; )
-      if (s < e.length && (e[s] === "*" || e[s] === t[n]))
-        s++, n++;
-      else if (s < e.length && e[s] === "**")
-        r = s, o = n, s++;
-      else if (r !== -1)
-        s = r + 1, n = ++o;
+    let n = 0, r = 0, i = -1, s = 0;
+    for (; r < t.length; )
+      if (n < e.length && (e[n] === "*" || e[n] === t[r]))
+        n++, r++;
+      else if (n < e.length && e[n] === "**")
+        i = n, s = r, n++;
+      else if (i !== -1)
+        n = i + 1, r = ++s;
       else
         return !1;
-    for (; s < e.length && e[s] === "**"; ) s++;
-    return s === e.length;
+    for (; n < e.length && e[n] === "**"; ) n++;
+    return n === e.length;
   }
   /**
    * Removes **all** listeners (exact and pattern). Useful for tests/HMR teardown.
@@ -485,16 +473,21 @@ class L {
    */
   __introspect() {
     const e = [];
-    for (const [t, s] of this.handlers)
-      for (const [n, r] of s)
-        r.length > 0 && e.push({ channel: t, type: n, count: r.length });
-    for (const [t, s] of this.patternHandlers)
-      for (const [n, r] of s)
-        r.length > 0 && e.push({ channel: t, type: n, count: r.length });
+    for (const [t, n] of this.handlers)
+      for (const [r, i] of n)
+        i.length > 0 && e.push({ channel: t, type: r, count: i.length });
+    for (const [t, n] of this.patternHandlers)
+      for (const [r, i] of n)
+        i.length > 0 && e.push({ channel: t, type: r, count: i.length });
     return e;
   }
 }
-class V {
+class X {
+  /**
+   * 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;
   }
   /**
@@ -536,138 +524,163 @@ class V {
     return this._reduce(e, t);
   }
 }
-const T = /* @__PURE__ */ new Set();
-function O(c, e) {
-  const t = c ? `${c}.${e}` : e;
-  T.has(t) || (T.add(t), console.warn(
-    `[yoltra] State key "${e}"${c ? ` under "${c}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
+const _ = /* @__PURE__ */ new Set();
+function P(o, e) {
+  const t = o ? `${o}.${e}` : e;
+  _.has(t) || (_.add(t), console.warn(
+    `[yoltra] State key "${e}"${o ? ` under "${o}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
   ));
 }
-function I(c, e, t = "", s = /* @__PURE__ */ new Map()) {
-  const n = [];
-  return P(c, e, t, s, n), n;
+function I(o, e, t = "", n = /* @__PURE__ */ new Map()) {
+  const r = [];
+  return M(o, e, t, n, r), r;
 }
-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 M(o, e, t, n, r) {
+  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);
+    r.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() && r.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) && r.push(t);
     return;
   }
-  if (c instanceof Map || e instanceof Map) {
-    n.push(t);
+  if (o instanceof Map || e instanceof Map) {
+    r.push(t);
     return;
   }
-  if (c instanceof Set || e instanceof Set) {
-    n.push(t);
+  if (o instanceof Set || e instanceof Set) {
+    r.push(t);
     return;
   }
-  const r = c, o = e, l = s.get(r);
-  if (l?.has(o)) return;
-  const i = l ?? /* @__PURE__ */ new Set();
-  i.add(o), l || s.set(r, i);
+  const i = o, s = e, l = n.get(i);
+  if (l?.has(s)) return;
+  const c = l ?? /* @__PURE__ */ new Set();
+  c.add(s), l || n.set(i, c);
   try {
-    const a = Array.isArray(c), d = Array.isArray(e);
+    const a = Array.isArray(o), d = Array.isArray(e);
     if (a !== d) {
-      n.push(t);
+      r.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 h = o, y = e;
+      h.length !== y.length && t && r.push(t);
+      const w = Math.min(h.length, y.length);
+      for (let g = 0; g < w; g++)
+        h[g] !== y[g] && M(h[g], y[g], t ? `${t}.${g}` : `${g}`, n, r);
+      for (let g = w; g < Math.max(h.length, y.length); g++)
+        r.push(t ? `${t}.${g}` : `${g}`);
       return;
     }
-    const u = Object.keys(c), f = Object.keys(e);
-    if (u.length === 0 && f.length === 0) {
-      n.push(t);
+    const f = Object.keys(o), u = Object.keys(e);
+    if (f.length === 0 && u.length === 0) {
+      r.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 = f.length === u.length;
+    if (p) {
+      for (let h = 0; h < u.length; h++)
+        if (!Object.prototype.hasOwnProperty.call(o, u[h])) {
+          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 h of u)
+        o[h] !== e[h] && (process.env.NODE_ENV !== "production" && h.includes(".") && P(t, h), M(o[h], e[h], t ? `${t}.${h}` : h, n, r));
       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;
+    for (const h of u) {
+      const y = Object.prototype.hasOwnProperty.call(o, h);
+      if (y && o[h] === e[h]) continue;
+      process.env.NODE_ENV !== "production" && h.includes(".") && P(t, h);
+      const w = t ? `${t}.${h}` : h;
       if (!y) {
-        n.push(g);
+        r.push(w);
         continue;
       }
-      P(c[h], e[h], g, s, n);
+      M(o[h], e[h], w, n, r);
     }
-    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 h of f)
+      Object.prototype.hasOwnProperty.call(e, h) || (process.env.NODE_ENV !== "production" && h.includes(".") && P(t, h), r.push(t ? `${t}.${h}` : h));
   } finally {
-    i.delete(o), i.size === 0 && s.delete(r);
+    c.delete(s), c.size === 0 && n.delete(i);
   }
 }
-function M(c, e = /* @__PURE__ */ new WeakSet(), t) {
-  if (c === null || typeof c != "object" || e.has(c) || (t !== void 0 && c === t.watch && t.onFound(), Object.isFrozen(c))) return c;
-  if (e.add(c), Array.isArray(c)) {
-    const s = c;
-    for (let n = 0; n < s.length; n++)
-      s[n] = M(s[n], e, t);
-    return Object.freeze(s);
-  }
-  for (const s of Object.getOwnPropertyNames(c)) {
-    const n = Object.getOwnPropertyDescriptor(c, s);
-    !n || !("value" in n) || (c[s] = M(c[s], e, t));
-  }
-  for (const s of Object.getOwnPropertySymbols(c)) {
-    const n = Object.getOwnPropertyDescriptor(c, s);
-    !n || !("value" in n) || (c[s] = M(c[s], e, t));
-  }
-  return Object.freeze(c);
+function C(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)) || (e.add(o), ArrayBuffer.isView(o))) return o;
+  if (Array.isArray(o)) {
+    const n = o;
+    for (let r = 0; r < n.length; r++)
+      n[r] = C(n[r], e, t);
+    return Object.freeze(n);
+  }
+  for (const n of Object.getOwnPropertyNames(o)) {
+    const r = Object.getOwnPropertyDescriptor(o, n);
+    !r || !("value" in r) || (o[n] = C(o[n], e, t));
+  }
+  for (const n of Object.getOwnPropertySymbols(o)) {
+    const r = Object.getOwnPropertyDescriptor(o, n);
+    !r || !("value" in r) || (o[n] = C(o[n], e, t));
+  }
+  return Object.freeze(o);
 }
-const N = /* @__PURE__ */ Symbol.for("yoltra.rejected");
-function le(c) {
-  return { [N]: !0, reason: c };
+const q = /* @__PURE__ */ Symbol.for("yoltra.rejected");
+function Re(o) {
+  return { [q]: !0, reason: o };
 }
-function Q(c) {
-  return typeof c == "object" && c !== null && c[N] === !0;
+function Y(o) {
+  return typeof o == "object" && o !== null && o[q] === !0;
 }
-class G {
+class Z extends Error {
+  channel;
+  type;
+  idleMs;
+  constructor(e, t, n) {
+    super(
+      `[yoltra] call to "${e}/${t}" 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 "${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 = n;
+  }
+}
+class B extends Error {
+  constructor(e) {
+    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
+  }
+}
+function ee(o) {
+  const [e, t] = o;
+  if (t === void 0) return { channel: e, isTerminal: () => !0 };
+  if (typeof t == "string") return { channel: e, isTerminal: (r) => r === t };
+  const n = new Set(t);
+  return { channel: e, isTerminal: (r) => n.has(r) };
+}
+function te(o, e, t) {
+  return o.parentId === e ? !0 : t === void 0 ? !1 : o.meta?.correlationId === t;
+}
+class ne {
   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;
@@ -686,8 +699,8 @@ class G {
   put(e) {
     if (this.closed || this.ended) return Promise.resolve();
     const t = this.takers.shift();
-    return t !== void 0 ? (t({ value: e, done: !1 }), Promise.resolve()) : this.buffer.length < this.highWaterMark ? (this.buffer.push(e), Promise.resolve()) : this.consuming ? new Promise((s) => {
-      this.putters.push({ item: e, release: s });
+    return t !== void 0 ? (t({ value: e, done: !1 }), Promise.resolve()) : this.buffer.length < this.highWaterMark ? (this.buffer.push(e), Promise.resolve()) : this.consuming ? new Promise((n) => {
+      this.putters.push({ item: e, release: n });
     }) : (this.dropped++, Promise.resolve());
   }
   /** Takes the next item, waiting if none is available. Resolves `done` once closed and drained. */
@@ -695,12 +708,12 @@ class G {
     this.consuming = !0;
     const e = this.buffer.shift();
     if (e !== void 0) {
-      const s = this.putters.shift();
-      return s !== void 0 && (this.buffer.push(s.item), s.release()), Promise.resolve({ value: e, done: !1 });
+      const n = this.putters.shift();
+      return n !== void 0 && (this.buffer.push(n.item), n.release()), Promise.resolve({ value: e, done: !1 });
     }
     const t = this.putters.shift();
-    return t !== void 0 ? (t.release(), Promise.resolve({ value: t.item, done: !1 })) : this.closed || this.ended ? Promise.resolve({ value: void 0, done: !0 }) : new Promise((s) => {
-      this.takers.push(s);
+    return t !== void 0 ? (t.release(), Promise.resolve({ value: t.item, done: !1 })) : this.closed || this.ended ? Promise.resolve({ value: void 0, done: !0 }) : new Promise((n) => {
+      this.takers.push(n);
     });
   }
   /**
@@ -721,9 +734,9 @@ class G {
       this.buffer.push(e.item), e.release(), e = this.putters.shift();
     let t = this.takers.shift();
     for (; t !== void 0; ) {
-      const s = this.buffer.shift();
+      const n = this.buffer.shift();
       t(
-        s !== void 0 ? { value: s, done: !1 } : { value: void 0, done: !0 }
+        n !== void 0 ? { value: n, done: !1 } : { value: void 0, done: !0 }
       ), t = this.takers.shift();
     }
   }
@@ -748,513 +761,881 @@ 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 re = 3e4, ie = 16;
+function se(o, e, t, n, r) {
+  const { channel: i, isTerminal: s } = ee(r.reply), l = r.timeoutMs ?? re, c = new ne(r.highWaterMark ?? ie), a = o.idFactory();
+  let d, f, u = !1;
+  const p = new Promise((E, R) => {
+    d = E, f = R;
+  });
+  p.catch(() => {
+  });
+  let h = null, y = null;
+  const w = (E, R = !1) => {
+    u || (u = !0, h !== null && clearTimeout(h), h = null, y?.(), y = null, R ? c.end() : c.close(), r.signal?.removeEventListener("abort", g), E());
+  };
+  function g() {
+    w(() => f(new B(String(r.signal?.reason ?? "signal aborted"))));
+  }
+  const b = () => {
+    h !== null && clearTimeout(h), h = setTimeout(() => {
+      w(() => f(new Z(e, t, l)));
+    }, l), h.unref?.();
+  };
+  return y = 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: i },
+    effect: async (E) => {
+      if (!u && te(E, a, r.correlationId)) {
+        if (b(), s(String(E.type))) {
+          w(() => d(E), !0);
+          return;
+        }
+        await c.put(E);
+      }
+    }
+  }), r.signal !== void 0 && (r.signal.aborted ? g() : r.signal.addEventListener("abort", g, { once: !0 })), b(), o.emit(e, t, n, {
+    id: a,
+    ...r.correlationId !== void 0 ? { meta: { correlationId: r.correlationId } } : {}
+  }), {
+    then: (E, R) => p.then(E, R),
+    catch: (E) => p.catch(E),
+    finally: (E) => p.finally(E),
+    get dropped() {
+      return c.droppedCount;
+    },
+    cancel: (E = "cancelled") => {
+      w(() => f(new B(E)));
+    },
+    [Symbol.asyncIterator]: () => (c.beginConsuming(), {
+      next: () => c.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 () => (c.close(), { value: void 0, done: !0 })
+    })
+  };
+}
+function oe(o, e) {
+  if (!e) return o;
+  const n = (e[0] === "." ? e.slice(1) : e).split(".");
+  let r = o;
+  for (const i of n) {
+    if (r == null) return;
+    r = r[i];
   }
+  return r;
 }
-class C extends Error {
-  constructor(e) {
-    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
+function ce(o) {
+  if (!o) return [];
+  const t = (o[0] === "." ? o.slice(1) : o).split("."), n = [];
+  for (let r = 0; r < t.length; r++)
+    n.push(t.slice(0, r + 1).join("."));
+  return n;
+}
+const m = "$yoltra", O = Object.freeze(
+  Object.assign(/* @__PURE__ */ Object.create(null), {
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array
+  })
+);
+function ae(o) {
+  const e = o.constructor?.name;
+  if (e !== void 0 && Object.prototype.hasOwnProperty.call(O, e))
+    return e;
+  if (o instanceof DataView) return "DataView";
+  for (const t of Object.keys(O)) {
+    const n = O[t];
+    if (n !== void 0 && o instanceof n) return t;
   }
 }
-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 N(o) {
+  const e = globalThis.Buffer;
+  if (e !== void 0) return e.from(o).toString("base64");
+  const t = 8192;
+  let n = "";
+  for (let r = 0; r < o.length; r += t)
+    n += String.fromCharCode(...o.subarray(r, r + t));
+  return btoa(n);
+}
+function de(o) {
+  const e = globalThis.Buffer;
+  if (e !== void 0) {
+    const r = e.from(o, "base64");
+    return new Uint8Array(r.subarray(0, r.length));
+  }
+  const t = atob(o), n = new Uint8Array(t.length);
+  for (let r = 0; r < t.length; r += 1) n[r] = t.charCodeAt(r);
+  return n;
+}
+function j(o, e = {}) {
+  const t = e.maxNodes ?? 1e5, n = e.sanitize, r = [], i = /* @__PURE__ */ new Map();
+  let s = 0, l = !1;
+  function c(d, f) {
+    if (n !== void 0 && (d = n(f, d)), s += 1, s > t)
+      return l = !0, { [m]: "unsupported", kind: "truncated" };
+    switch (typeof d) {
+      case "undefined":
+        return { [m]: "undefined" };
+      case "bigint":
+        return { [m]: "bigint", value: d.toString() };
+      case "number":
+        return Number.isNaN(d) ? { [m]: "nan" } : d === 1 / 0 ? { [m]: "infinity", sign: 1 } : d === -1 / 0 ? { [m]: "infinity", sign: -1 } : d;
+      case "function":
+      case "symbol":
+        return r.push(f), { [m]: "unsupported", kind: typeof d };
+      case "string":
+      case "boolean":
+        return d;
+    }
+    if (d === null) return null;
+    const u = d, p = i.get(u);
+    if (p !== void 0) return { [m]: "ref", path: p };
+    if (i.set(u, f), d instanceof Date)
+      return { [m]: "date", iso: d.toISOString() };
+    if (d instanceof RegExp)
+      return { [m]: "regexp", source: d.source, flags: d.flags };
+    if (d instanceof Error)
+      return { [m]: "error", name: d.name, message: d.message };
+    if (d instanceof Map) {
+      const g = [];
+      let b = 0;
+      for (const [v, E] of d)
+        g.push([c(v, `${f}/@k${b}`), c(E, `${f}/${b}`)]), b += 1;
+      return { [m]: "map", entries: g };
+    }
+    if (d instanceof Set) {
+      const g = [];
+      let b = 0;
+      for (const v of d)
+        g.push(c(v, `${f}/${b}`)), b += 1;
+      return { [m]: "set", values: g };
+    }
+    if (Array.isArray(d))
+      return d.map((g, b) => c(g, `${f}/${b}`));
+    if (d instanceof ArrayBuffer)
+      return s += Math.ceil(d.byteLength / 64), s > t ? (l = !0, { [m]: "unsupported", kind: "truncated" }) : {
+        [m]: "binary",
+        kind: "ArrayBuffer",
+        b64: N(new Uint8Array(d))
+      };
+    if (ArrayBuffer.isView(d)) {
+      const g = d;
+      s += Math.ceil(g.byteLength / 64);
+      const b = ae(g);
+      if (b === void 0)
+        return r.push(f), {
+          [m]: "unsupported",
+          kind: g.constructor?.name ?? "ArrayBufferView"
+        };
+      const v = new Uint8Array(g.buffer, g.byteOffset, g.byteLength), E = { [m]: "binary", kind: b, b64: N(v) };
+      return g.constructor?.name !== b && r.push(f), E;
+    }
+    const h = Object.getPrototypeOf(d), y = d.constructor?.name;
+    if (h !== null && h !== Object.prototype && y !== "Object") {
+      r.push(f);
+      const g = {};
+      for (const [b, v] of Object.entries(d))
+        g[b] = c(v, `${f}/${D(b)}`);
+      return {
+        [m]: "unsupported",
+        kind: y ?? "unknown",
+        value: g
+      };
+    }
+    const w = {};
+    for (const [g, b] of Object.entries(d))
+      w[g] = c(b, `${f}/${D(g)}`);
+    return m in w ? { [m]: "escaped", value: w } : w;
+  }
+  return { value: c(o, ""), report: { truncated: l, unsupported: r } };
+}
+function le(o) {
+  const e = /* @__PURE__ */ new Map(), t = [];
+  function n(s, l) {
+    if (s === null || typeof s != "object") return s;
+    if (Array.isArray(s)) {
+      const a = [];
+      return e.set(l, a), s.forEach((d, f) => {
+        if (z(d)) {
+          t.push({ target: a, key: f, path: d.path }), a[f] = void 0;
+          return;
+        }
+        a[f] = n(d, `${l}/${f}`);
+      }), a;
+    }
+    if (typeof s[m] == "string") {
+      const a = s;
+      switch (a[m]) {
+        case "undefined":
+          return;
+        case "nan":
+          return Number.NaN;
+        case "infinity":
+          return a.sign === 1 ? 1 / 0 : -1 / 0;
+        case "bigint":
+          return BigInt(a.value);
+        case "date":
+          return new Date(a.iso);
+        case "regexp":
+          return new RegExp(a.source, a.flags);
+        case "error": {
+          const d = new Error(a.message);
+          return d.name = a.name, d;
+        }
+        case "binary": {
+          const d = de(a.b64);
+          if (a.kind === "ArrayBuffer") {
+            const p = d.slice();
+            return e.set(l, p.buffer), p.buffer;
+          }
+          if (a.kind === "DataView") {
+            const p = d.slice(), h = new DataView(p.buffer);
+            return e.set(l, h), h;
+          }
+          const f = Object.prototype.hasOwnProperty.call(O, a.kind) ? O[a.kind] : void 0;
+          if (f === void 0) return;
+          const u = new f(d.slice().buffer);
+          return e.set(l, u), u;
+        }
+        case "unsupported":
+          return a.value !== void 0 ? r(a.value, l) : void 0;
+        case "ref":
+          return;
+        case "map": {
+          const d = /* @__PURE__ */ new Map();
+          return e.set(l, d), a.entries.forEach(([f, u], p) => {
+            d.set(n(f, `${l}/@k${p}`), n(u, `${l}/${p}`));
+          }), d;
+        }
+        case "set": {
+          const d = /* @__PURE__ */ new Set();
+          return e.set(l, d), a.values.forEach((f, u) => d.add(n(f, `${l}/${u}`))), d;
+        }
+        case "escaped":
+          return r(a.value, l);
+        default:
+          return;
+      }
+    }
+    return r(s, l);
+  }
+  function r(s, l) {
+    const c = {};
+    e.set(l, c);
+    for (const [a, d] of Object.entries(s)) {
+      const f = `${l}/${D(a)}`;
+      if (z(d)) {
+        t.push({ target: c, key: a, path: d.path }), c[a] = void 0;
+        continue;
+      }
+      c[a] = n(d, f);
+    }
+    return c;
+  }
+  const i = n(o, "");
+  e.set("", i);
+  for (const { target: s, key: l, path: c } of t)
+    s[l] = e.get(c);
+  return i;
+}
+function z(o) {
+  return o !== null && typeof o == "object" && o[m] === "ref" && typeof o.path == "string";
+}
+function D(o) {
+  return o.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function Oe(o, e, t = {}) {
+  let n = t.maxNodes ?? 1e5;
+  for (let r = 0; r < 8; r += 1) {
+    const { value: i, report: s } = j(o, { ...t, maxNodes: n });
+    let l;
+    try {
+      l = JSON.stringify(i)?.length ?? 0;
+    } catch {
+      l = Number.POSITIVE_INFINITY;
+    }
+    if (l <= e)
+      return s.truncated ? {
+        value: i,
+        truncated: !0,
+        note: `State was too large to send in full; parts beyond ${n} nodes are omitted.`
+      } : { value: i, truncated: !1 };
+    const c = Math.floor(n * e * 0.8 / l);
+    if (n = Math.max(1, Math.min(c, n - 1)), n <= 1 && r > 0)
+      break;
+  }
+  return {
+    value: { [m]: "unsupported", kind: "truncated" },
+    truncated: !0,
+    note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
+  };
+}
+const fe = 1e4;
+function x(o) {
+  return o === null || typeof o != "object" ? JSON.stringify(o) ?? "null" : Array.isArray(o) ? `[${o.map(x).join(",")}]` : `{${Object.entries(o).sort(
+    ([t], [n]) => t < n ? -1 : t > n ? 1 : 0
+  ).map(([t, n]) => `${JSON.stringify(t)}:${x(n)}`).join(",")}}`;
+}
+function ue(o, e, t) {
+  const n = `${o}::${e}`;
+  if (t === null) return `${n}::null`;
+  if (t === void 0) return `${n}::undefined`;
+  if (typeof t != "object") return `${n}::${typeof t}:${String(t)}`;
+  try {
+    const { value: r, report: i } = j(t, { maxNodes: fe });
+    return i.truncated ? `${n}::${Date.now()}::${Math.random()}` : `${n}::${x(r)}`;
+  } catch {
+    return `${n}::${Date.now()}::${Math.random()}`;
+  }
+}
+function $(o, e) {
+  return !o || "any" in o && o.any === !0 ? !0 : "keys" in o ? o.keys.some(
+    ([t, n]) => e.channel === t && e.type === n
+  ) : "channel" in o ? e.channel === o.channel : "channels" in o ? o.channels.includes(e.channel) : !1;
+}
+function he(o) {
+  return typeof o == "function" ? o : o.middleware;
 }
-function Y(c, e, t) {
-  return c.parentId === e ? !0 : t === void 0 ? !1 : c.meta?.correlationId === t;
+function A(o) {
+  if (typeof o != "function")
+    return o.when;
 }
-function X(c, e) {
+function U(o) {
+  if (o.when) {
+    const e = o.when;
+    if ("keys" in e)
+      return e.keys;
+  }
+  return [];
+}
+function pe(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 T(o, e) {
+  return process.env.NODE_ENV === "production" ? o : C(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();
-class x {
-  /**
-   * Creates a store from a {@link StoreSpec}.
-   *
-   * @param spec - Store configuration (name, reducers, middleware, optional effects).
+const H = 100, V = 64, ge = 64, ye = 64, W = 16, me = Object.freeze({ committed: !1, written: !1 }), we = Object.freeze({
+  committed: !1,
+  written: !1,
+  reason: "deduped"
+}), F = Object.freeze({
+  committed: !1,
+  written: !1,
+  reason: "cascade"
+}), be = Object.freeze({ committed: !0, written: !1 }), Ee = Object.freeze({ committed: !0, written: !0 }), K = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+class k {
+  /**
+   * Store name (used by DevTools & diagnostics).
    *
    * @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 = {
-      windowMs: e.dedupWindowMs ?? 0,
-      maxCacheSize: 1e3
-    }, Object.entries(e.reducer).forEach(([t, s]) => {
-      this.mountSlice(t, s, { preserveState: !1 });
-    }), e.effects?.length)
-      for (const t of e.effects)
-        this.registerEffect(t);
-    this.dispose = this.dispose.bind(this), this.notifyEffects = this.notifyEffects.bind(this), this.__applyExternalState = this.__applyExternalState.bind(this), this.__replayEvents = this.__replayEvents.bind(this), this.__devtoolsIntrospect = this.__devtoolsIntrospect.bind(this), this.mountSlice = this.mountSlice.bind(this), this.unmountSlice = this.unmountSlice.bind(this), this.getAtPath = this.getAtPath.bind(this), this.emit = this.emit.bind(this), this.subscribe = this.subscribe.bind(this), this.connect = this.connect.bind(this), this.onEffect = this.onEffect.bind(this), this.onEvent = this.onEvent.bind(this), this.getState = this.getState.bind(this), this.registerEffect = this.registerEffect.bind(this), this.registerMiddleware = this.registerMiddleware.bind(this), this.registerReducer = this.registerReducer.bind(this), this.replaceMiddleware = this.replaceMiddleware.bind(this), this.replaceEffects = this.replaceEffects.bind(this), this.replaceReducers = this.replaceReducers.bind(this), this.hotReplace = this.hotReplace.bind(this);
-  }
+  name;
   /**
-   * Cleanup resources (timers, etc.) when disposing the store.
-   * Call this if you're dynamically creating/destroying stores.
+   * Registered middleware pipeline (run **before** reducers).
+   * Stores either raw functions (legacy) or MiddlewareSpec objects.
    *
-   * @example
-   * ```ts
-   * const store = createStore({ ... });
-   * // later
-   * store.dispose();
-   * ```
+   * Only an explicit `false` stops propagation. Returning nothing allows the event, so
+   * middleware that only logs or measures needs no `return` at all.
    *
-   * @public
+   * @internal
    */
-  dispose() {
-    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.writtenEventSubscribers.clear(), this.allEventSubscribers.clear(), this.instrumentObservers.clear(), this.connectorBus.clear(), this.reducerBus.clear(), this.patternReducers.clear(), this.sliceUnsubs.clear(), this.changedPathSink = null;
-  }
+  middleware;
   /**
-   * Generates a fingerprint for an event for deduplication purposes.
-   * Falls back gracefully for non-serializable payloads.
+   * Installed slice reducers keyed by slice name.
    *
-   * @param channel - Event channel.
-   * @param type - Event type.
-   * @param payload - Event payload.
-   * @returns A string fingerprint for the event.
+   * @internal
+   */
+  reducers;
+  /**
+   * Current immutable snapshot of the store state.
+   * This reference changes whenever any slice changes (shallow immutability).
    *
    * @internal
    */
-  fingerprint(e, t, s) {
-    const n = `${e}::${t}`;
-    try {
-      if (s == null)
-        return `${n}::null`;
-      if (typeof s != "object")
-        return `${n}::${String(s)}`;
-      const r = JSON.stringify(s);
-      return `${n}::${r}`;
-    } catch {
-      return `${n}::${Date.now()}::${Math.random()}`;
-    }
-  }
+  state;
   /**
-   * Checks if an event should be deduplicated.
-   * Returns true if this is a duplicate that should be skipped.
+   * Bus for reducer wiring (emit by `(channel, type)`).
    *
-   * @param fp - Event fingerprint.
-   * @returns `true` if duplicate (should skip), `false` otherwise.
+   * @internal
+   */
+  reducerBus;
+  /**
+   * Bus for **granular** connector events (emit by **dotted path** inside a slice).
    *
    * @internal
    */
-  shouldDedupe(e, t) {
-    const s = Date.now(), n = this.processedEvents.get(e);
-    return n !== void 0 && s - n < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, s), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(s), !1);
-  }
+  connectorBus;
   /**
-   * Starts the periodic prune interval if it isn't already running. Called when
-   * the first entry is cached so the timer's lifetime tracks actual dedup use
-   * (content window or identity `dedupKey`), independent of `dedupWindowMs`.
+   * Coarse-grained listeners (called once per committed event, only if state changed).
    *
    * @internal
    */
-  ensureCleanupTimer() {
-    this.eventCleanupTimer === null && (this.eventCleanupTimer = setInterval(() => {
-      this.pruneProcessedEvents(Date.now());
-    }, 5e3), this.eventCleanupTimer.unref?.());
-  }
+  listeners = /* @__PURE__ */ new Set();
   /**
-   * Removes expired entries from the processed events cache.
+   * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
+   * Used for effects with explicit `keys` targeting.
    *
-   * @param now - Current timestamp.
+   * @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
    */
-  pruneProcessedEvents(e) {
-    const t = Math.max(this.dedupConfig.windowMs, D), s = e - t * 2;
-    for (const [n, r] of this.processedEvents)
-      r < s && this.processedEvents.delete(n);
-    this.processedEvents.size === 0 && this.eventCleanupTimer !== null && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null);
-  }
+  patternEffects = /* @__PURE__ */ new Set();
   /**
-   * Reports a breached ceiling and refuses the emit.
+   * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified after reducers, before effects, for events that passed middleware.
    *
-   * @remarks
-   * Console *and* hook, matching how reducer and effect errors are reported: a cascade is a
-   * wiring bug, and the console line is what a developer who has not registered a hook will
-   * actually see. Without one, refusing the emit would look exactly like the event never having
-   * been emitted at all — which is the invisibility this whole guard exists to end.
+   * @internal
+   */
+  committedEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified when middleware rejects an event.
    *
    * @internal
    */
-  reportCascade(e, t, s, n, r) {
-    console.error(
-      `[yoltra] Cascade stopped: "${s.channel}/${s.type}" would exceed ${e} (${t}). This event was refused and the chain ends here. A chain this long is almost always two consumers emitting into each other — check what reacts to "${s.channel}/${s.type}" and what that emits in turn.` + (r.length > 0 ? ` Recent causal chain: ${r.join(" → ")} → (refused).` : "")
-    );
-    try {
-      this.onCascade?.({ limit: e, limitValue: t, event: s, depth: n, chain: r });
-    } catch (o) {
-      console.error("onCascade handler error:", o);
-    }
-  }
+  uncommittedEventSubscribers = /* @__PURE__ */ new Map();
   /**
-   * Checks if an event matches a `When` matcher.
+   * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
+   * Notified for both committed and uncommitted events with phase parameter.
    *
-   * @param when - The When matcher (or undefined for "all events").
-   * @param event - The event to check.
-   * @returns `true` if the event matches, `false` otherwise.
+   * @internal
+   */
+  /**
+   * Subscribers to events that actually changed state, notified after the commit.
    *
    * @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.
+   * 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
    */
-  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;
-  }
+  writtenEventSubscribers = /* @__PURE__ */ new Map();
+  allEventSubscribers = /* @__PURE__ */ new Map();
   /**
-   * Extracts the middleware function from a MiddlewareInput.
-   * Handles both raw functions (legacy) and MiddlewareSpec objects.
+   * True while a devtools time-travel is applying a snapshot or replaying events.
    *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The middleware function.
+   * @remarks
+   * Saved and restored rather than set and cleared to `false`: `__replayEvents` calls
+   * `__applyExternalState` as its first step, so clearing on the inner call's way out would
+   * unset the flag for the entire event loop that follows it.
    *
    * @internal
    */
-  getMiddlewareFunction(e) {
-    return typeof e == "function" ? e : e.middleware;
-  }
+  replaying = !1;
   /**
-   * Gets the `when` matcher from a MiddlewareInput.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The `when` matcher, or `undefined` for raw functions (match all).
+   * Track reducerBus unsubs per slice for HMR/register/unregister.
    *
    * @internal
    */
-  getMiddlewareWhen(e) {
-    if (typeof e != "function")
-      return e.when;
-  }
+  sliceUnsubs = /* @__PURE__ */ new Map();
   /**
-   * Invokes all registered **effects** for a given event.
-   * Handles both key-based effects (O(1) lookup) and pattern-based effects (runtime matching).
-   * Errors are caught and logged.
+   * Pattern-based reducers that need runtime matching.
+   * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
+   * Maps slice name to the `when` matcher.
    *
-   * @param event - The event that was reduced.
    * @internal
    */
-  async notifyEffects(e) {
-    const t = this.scopedEmit(e), s = `${String(e.channel)}::${String(e.type)}`, n = this.effects.get(s);
-    if (n && n.size > 0)
-      for (const r of [...n])
-        try {
-          await r(e, this.getState, t);
-        } catch (o) {
-          console.error("Effect error:", o), this.onEffectError?.(o, e);
-        }
-    for (const { effect: r, when: o } of this.patternEffects)
-      if (this.matchesWhen(o, e))
-        try {
-          await r(e, this.getState, t);
-        } catch (l) {
-          console.error("Effect error:", l), this.onEffectError?.(l, e);
-        }
-  }
+  patternReducers = /* @__PURE__ */ new Map();
   /**
-   * An `emit` that attributes whatever it sends to `cause`.
+   * Where each mounted slice came from. See {@link Origin}.
    *
    * @remarks
-   * Built per event rather than per effect: every effect reacting to one event shares a cause,
-   * and one closure is cheaper than one per handler on a path that runs for every committed
-   * event.
+   * This is what makes `replace*` mean "replace mine" rather than "replace everything". It
+   * is written by `mountSlice` and never by a caller.
    *
    * @internal
    */
-  scopedEmit(e) {
-    const t = {
-      id: e.id,
+  sliceOrigin = /* @__PURE__ */ new Map();
+  /**
+   * Who claims each dynamically mounted slice, for introspection only.
+   *
+   * @remarks
+   * Surfaced in `__devtoolsIntrospect()` and named in the collision error. **Never read by
+   * `replace*`.** Correctness comes from {@link Origin}, which nobody has to remember to
+   * pass; if preservation depended on this string, forgetting it would silently delete a
+   * library's state.
+   *
+   * @internal
+   */
+  sliceOwner = /* @__PURE__ */ new Map();
+  /**
+   * Slices unmounted by their owner, for a development-time diagnostic.
+   *
+   * @remarks
+   * Decoration re-types the store, and after a disposer runs the widened type still claims
+   * a slice that is gone. Reading it would hand a component `undefined` from a type that
+   * promised a value, which is the silent failure this whole feature exists to remove.
+   * Populated only for `dynamic` and `internal` slices: a `spec` slice removed by a
+   * `replace*` was not promised by anyone's widened type.
+   *
+   * Bounded, because a long development session that mounts and disposes repeatedly would
+   * otherwise accumulate an entry per cycle forever. The oldest is dropped: the diagnostic
+   * exists for a slice someone has just stopped using, and a name disposed hundreds of
+   * mounts ago is not the one being read by mistake. Maps to the owner, or `undefined`
+   * when the library did not name itself.
+   *
+   * @internal
+   */
+  disposedSlices = /* @__PURE__ */ new Map();
+  /** @internal */
+  registrationObservers = /* @__PURE__ */ new Set();
+  /**
+   * Changes accumulated inside the current public call, flushed once at its end.
+   *
+   * @internal
+   */
+  pendingRegistrationChanges = null;
+  /**
+   * Depth of nested registration transactions.
+   *
+   * @remarks
+   * `hotReplace` calls three `replace*` methods, and each of those registers repeatedly.
+   * Only the outermost public entry point flushes, so one `hotReplace` produces one batch
+   * spanning all three kinds rather than three batches of intermediate topology.
+   *
+   * @internal
+   */
+  registrationDepth = 0;
+  /** True while observers are being notified, so a re-entrant change is queued. @internal */
+  notifyingRegistrations = !1;
+  /** Batches produced by an observer's own registrations, drained after the current one. @internal */
+  queuedRegistrationBatches = [];
+  /**
+   * 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;
+  /** @internal */
+  onSubscriberError;
+  /**
+   * `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 through the codec, so `Map`, `Set`, `Date`, `BigInt`, binary
+   *   and cyclic payloads all compare by content rather than collapsing to `{}`
+   * - Plain-object keys are sorted, so key order is not content; array and `Map` order is
+   * - If an identical fingerprint is seen within the dedup window, it's skipped
+   * - The window is `dedupWindowMs`, which defaults to `0` (dedup off)
+   *
+   * **Limitations:**
+   * - A payload larger than the fingerprint node budget is never deduplicated, which is the
+   *   safe direction: a missed dedup costs a duplicate, a false one drops a real event
+   * - 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}.
+   *
+   * @param spec - Store configuration (name, reducers, middleware, optional effects).
+   *
+   * @public
+   */
+  constructor(e) {
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new G(), this.connectorBus = new J(), this.middleware = (e.middleware ?? []).map((t) => ({
+      input: t,
+      origin: "spec"
+    })), 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.onSubscriberError = e.onSubscriberError, this.maxReduceDepth = e.maxReduceDepth ?? ye, this.maxTransitionsPerDrain = e.maxTransitionsPerDrain ?? 1 / 0, this.onCascade = e.onCascade, this.onRejected = e.onRejected, this.dedupConfig = {
+      windowMs: e.dedupWindowMs ?? 0,
+      maxCacheSize: 1e3
+    }, Object.entries(e.reducer).forEach(([t, n]) => {
+      this.mountSlice(t, n, { preserveState: !1 });
+    }), e.effects?.length)
+      for (const t of e.effects)
+        this.registerEffectWithOrigin(t, "spec");
+    this.dispose = this.dispose.bind(this), this.notifyEffects = this.notifyEffects.bind(this), this.__applyExternalState = this.__applyExternalState.bind(this), this.__replayEvents = this.__replayEvents.bind(this), this.__devtoolsIntrospect = this.__devtoolsIntrospect.bind(this), this.mountSlice = this.mountSlice.bind(this), this.unmountSlice = this.unmountSlice.bind(this), this.getAtPath = this.getAtPath.bind(this), this.emit = this.emit.bind(this), this.subscribe = this.subscribe.bind(this), this.connect = this.connect.bind(this), this.onEffect = this.onEffect.bind(this), this.onEvent = this.onEvent.bind(this), this.getState = this.getState.bind(this), this.registerEffect = this.registerEffect.bind(this), this.registerMiddleware = this.registerMiddleware.bind(this), this.registerReducer = this.registerReducer.bind(this), this.replaceMiddleware = this.replaceMiddleware.bind(this), this.replaceEffects = this.replaceEffects.bind(this), this.replaceReducers = this.replaceReducers.bind(this), this.hotReplace = this.hotReplace.bind(this);
+  }
+  /**
+   * Cleanup resources (timers, etc.) when disposing the store.
+   * Call this if you're dynamically creating/destroying stores.
+   *
+   * @example
+   * ```ts
+   * const store = createStore({ ... });
+   * // later
+   * store.dispose();
+   * ```
+   *
+   * @public
+   */
+  dispose() {
+    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.writtenEventSubscribers.clear(), this.allEventSubscribers.clear(), this.instrumentObservers.clear(), this.connectorBus.clear(), this.reducerBus.clear(), this.patternReducers.clear(), this.sliceUnsubs.clear(), this.sliceOrigin.clear(), this.sliceOwner.clear(), this.disposedSlices.clear(), this.registrationObservers.clear(), this.pendingRegistrationChanges = null, this.queuedRegistrationBatches.length = 0, this.middleware.length = 0, this.changedPathSink = null;
+  }
+  /**
+   * Generates a fingerprint for an event for deduplication purposes.
+   * Falls back gracefully for non-serializable payloads.
+   *
+   * @param channel - Event channel.
+   * @param type - Event type.
+   * @param payload - Event payload.
+   * @returns A string fingerprint for the event.
+   *
+   * @internal
+   */
+  fingerprint(e, t, n) {
+    return ue(e, t, n);
+  }
+  /**
+   * Checks if an event should be deduplicated.
+   * Returns true if this is a duplicate that should be skipped.
+   *
+   * @param fp - Event fingerprint.
+   * @returns `true` if duplicate (should skip), `false` otherwise.
+   *
+   * @internal
+   */
+  shouldDedupe(e, t) {
+    const n = Date.now(), r = this.processedEvents.get(e);
+    return r !== void 0 && n - r < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, n), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(n), !1);
+  }
+  /**
+   * Starts the periodic prune interval if it isn't already running. Called when
+   * the first entry is cached so the timer's lifetime tracks actual dedup use
+   * (content window or identity `dedupKey`), independent of `dedupWindowMs`.
+   *
+   * @internal
+   */
+  ensureCleanupTimer() {
+    this.eventCleanupTimer === null && (this.eventCleanupTimer = setInterval(() => {
+      this.pruneProcessedEvents(Date.now());
+    }, 5e3), this.eventCleanupTimer.unref?.());
+  }
+  /**
+   * Removes expired entries from the processed events cache.
+   *
+   * @param now - Current timestamp.
+   *
+   * @internal
+   */
+  pruneProcessedEvents(e) {
+    const t = Math.max(this.dedupConfig.windowMs, H), n = e - t * 2;
+    for (const [r, i] of this.processedEvents)
+      i < n && this.processedEvents.delete(r);
+    this.processedEvents.size === 0 && this.eventCleanupTimer !== null && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null);
+  }
+  /**
+   * Reports a breached ceiling and refuses the emit.
+   *
+   * @remarks
+   * Console *and* hook, matching how reducer and effect errors are reported: a cascade is a
+   * wiring bug, and the console line is what a developer who has not registered a hook will
+   * actually see. Without one, refusing the emit would look exactly like the event never having
+   * been emitted at all — which is the invisibility this whole guard exists to end.
+   *
+   * @internal
+   */
+  reportCascade(e, t, n, r, i) {
+    console.error(
+      `[yoltra] Cascade stopped: "${n.channel}/${n.type}" would exceed ${e} (${t}). This event was refused and the chain ends here. A chain this long is almost always two consumers emitting into each other — check what reacts to "${n.channel}/${n.type}" and what that emits in turn.` + (i.length > 0 ? ` Recent causal chain: ${i.join(" → ")} → (refused).` : "")
+    );
+    try {
+      this.onCascade?.({ limit: e, limitValue: t, event: n, depth: r, chain: i });
+    } catch (s) {
+      console.error("onCascade handler error:", s);
+    }
+  }
+  /**
+   * Invokes all registered **effects** for a given event.
+   * Handles both key-based effects (O(1) lookup) and pattern-based effects (runtime matching).
+   * Errors are caught and logged.
+   *
+   * @param event - The event that was reduced.
+   * @internal
+   */
+  async notifyEffects(e) {
+    const t = this.scopedEmit(e), n = `${String(e.channel)}::${String(e.type)}`, r = this.effects.get(n);
+    if (r && r.size > 0)
+      for (const i of [...r])
+        try {
+          await i.effect(e, this.getState, t);
+        } catch (s) {
+          console.error("Effect error:", s), this.onEffectError?.(s, e);
+        }
+    for (const { effect: i, when: s } of this.patternEffects)
+      if ($(s, e))
+        try {
+          await i(e, this.getState, t);
+        } catch (l) {
+          console.error("Effect error:", l), this.onEffectError?.(l, e);
+        }
+  }
+  /**
+   * An `emit` that attributes whatever it sends to `cause`.
+   *
+   * @remarks
+   * Built per event rather than per effect: every effect reacting to one event shares a cause,
+   * and one closure is cheaper than one per handler on a path that runs for every committed
+   * event.
+   *
+   * @internal
+   */
+  scopedEmit(e) {
+    const t = {
+      id: e.id,
       depth: e.depth ?? 0,
-      chain: [...this.currentEvent?.chain ?? [], e.id].slice(-z)
+      chain: [...this.currentEvent?.chain ?? [], e.id].slice(-W)
     };
-    return ((s, n, r, o) => this.emitCaused(t, s, n, r, o));
+    return ((n, r, i, s) => this.emitCaused(t, n, r, i, s));
   }
   /**
    * Notifies event subscribers for a specific phase.
@@ -1267,13 +1648,15 @@ class x {
    * @internal
    */
   notifyEventSubscribers(e, t) {
-    const s = `${String(e.channel)}::${String(e.type)}`, r = (t === "committed" ? this.committedEventSubscribers : t === "written" ? this.writtenEventSubscribers : this.uncommittedEventSubscribers).get(s);
-    if (r?.size)
-      for (const l of [...r]) this.invokeEventSubscriber(l, e, t);
+    const n = `${String(e.channel)}::${String(e.type)}`, i = (t === "committed" ? this.committedEventSubscribers : t === "written" ? this.writtenEventSubscribers : this.uncommittedEventSubscribers).get(n);
+    if (i?.size)
+      for (const l of [...i])
+        this.replaying && !l.duringReplay || this.invokeEventSubscriber(l.handler, 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 s = this.allEventSubscribers.get(n);
+    if (s?.size)
+      for (const l of [...s])
+        this.replaying && !l.duringReplay || this.invokeEventSubscriber(l.handler, e, t);
   }
   /**
    * Invokes a single event-subscription handler **fire-and-forget**: synchronous
@@ -1282,12 +1665,15 @@ class x {
    *
    * @internal
    */
-  invokeEventSubscriber(e, t, s) {
+  invokeEventSubscriber(e, t, n) {
+    const r = (i) => {
+      console.error("Event subscription error:", i), this.onSubscriberError?.(i, t, n);
+    };
     try {
-      const n = e(t, this.getState, this.emit, s);
-      n && typeof n.then == "function" && n.catch((r) => console.error("Event subscription error:", r));
-    } catch (n) {
-      console.error("Event subscription error:", n);
+      const i = e(t, this.getState, this.emit, n);
+      i && typeof i.then == "function" && i.catch(r);
+    } catch (i) {
+      r(i);
     }
   }
   /**
@@ -1341,11 +1727,11 @@ class x {
    *
    * @internal
    */
-  stageSliceGuarded(e, t, s) {
+  stageSliceGuarded(e, t, n) {
     try {
-      return this.stageSlice(e, t, s);
-    } catch (n) {
-      return console.error(`Reducer error in slice "${e}":`, n), this.onReducerError?.(n, t, e), null;
+      return this.stageSlice(e, t, n);
+    } catch (r) {
+      return console.error(`Reducer error in slice "${e}":`, r), this.onReducerError?.(r, t, e), null;
     }
   }
   /**
@@ -1364,13 +1750,13 @@ class x {
    *
    * @internal
    */
-  stageSlice(e, t, s) {
-    const n = this.state[e], r = this.reducers[e].reduce(n, t);
-    if (Q(r)) return r;
-    if (n === r) return null;
-    const o = I(n, r);
-    if (o.length === 0) return null;
-    const l = t.payload, i = process.env.NODE_ENV !== "production" && l !== null && typeof l == "object" ? {
+  stageSlice(e, t, n) {
+    const r = this.state[e], i = this.reducers[e].reduce(r, t);
+    if (Y(i)) return i;
+    if (r === i) return null;
+    const s = I(r, i);
+    if (s.length === 0) return null;
+    const l = t.payload, c = process.env.NODE_ENV !== "production" && l !== null && typeof l == "object" ? {
       watch: l,
       onFound: () => {
         const a = `${e}:${t.channel}:${t.type}`;
@@ -1379,11 +1765,11 @@ class x {
         ));
       }
     } : void 0;
-    return s.push({
+    return n.push({
       name: e,
-      prev: n,
-      frozen: R(r, i),
-      leafPaths: o
+      prev: r,
+      frozen: T(i, c),
+      leafPaths: s
     }), null;
   }
   /**
@@ -1407,26 +1793,26 @@ class x {
    */
   commitStaged(e, t) {
     if (e.length === 0) return !1;
-    const s = { ...this.state };
-    for (const n of e) s[n.name] = n.frozen;
-    if (this.state = s, this.changedPathSink)
-      for (const n of e)
-        for (const r of n.leafPaths)
-          this.changedPathSink.push(r ? `${n.name}.${r}` : n.name);
-    for (const n of e) {
-      const r = /* @__PURE__ */ new Set();
-      for (const o of n.leafPaths) {
-        if (o === "") {
-          r.add("");
+    const n = { ...this.state };
+    for (const r of e) n[r.name] = r.frozen;
+    if (this.state = n, this.changedPathSink)
+      for (const r of e)
+        for (const i of r.leafPaths)
+          this.changedPathSink.push(i ? `${r.name}.${i}` : r.name);
+    for (const r of e) {
+      const i = /* @__PURE__ */ new Set();
+      for (const s of r.leafPaths) {
+        if (s === "") {
+          i.add("");
           continue;
         }
-        for (const l of x.buildAncestorPaths(o)) r.add(l);
+        for (const l of k.buildAncestorPaths(s)) i.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 s of i)
+        this.connectorBus.emitWith(r.name, s, () => ({
+          oldValue: this.getAtPath(r.prev, s),
+          newValue: this.getAtPath(r.frozen, s),
+          path: s,
           // 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.
@@ -1448,65 +1834,68 @@ class x {
    * @public
    */
   __devtoolsIntrospect() {
-    const e = Object.keys(this.reducers).map((l) => {
-      const i = this.patternReducers.get(l);
-      return { name: l, when: i };
+    const e = Object.keys(this.reducers).map((c) => {
+      const a = this.patternReducers.get(c);
+      return {
+        name: c,
+        when: a,
+        origin: this.sliceOrigin.get(c) ?? "spec",
+        owner: this.sliceOwner.get(c)
+      };
     }), 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 });
+    for (const [c, a] of this.effects) {
+      if (a.size === 0) continue;
+      const [d, f] = c.split("::");
+      for (const u of a) {
+        const p = this.effectMeta.get(u.effect);
+        t.push({
+          channel: d,
+          type: f,
+          name: p?.name,
+          description: p?.description,
+          origin: u.origin
+        });
       }
     }
-    for (const l of this.patternEffects) {
-      const i = this.effectMeta.get(l.effect);
+    for (const c of this.patternEffects) {
+      const a = this.effectMeta.get(c.effect);
       t.push({
         channel: "*",
         type: "*",
-        name: i?.name,
-        description: i?.description
+        name: a?.name,
+        description: a?.description,
+        origin: c.origin
       });
     }
-    const s = [];
-    for (const l of this.middleware)
-      typeof l == "function" ? s.push({ name: l.name || void 0 }) : s.push({
-        name: l.meta?.name,
-        description: l.meta?.description,
-        when: l.when
-      });
     const n = [];
-    for (const l of this.connectorBus.__introspect())
-      for (let i = 0; i < l.count; i++)
-        n.push({ reducer: l.channel, property: l.type });
+    for (const { input: c, origin: a } of this.middleware)
+      typeof c == "function" ? n.push({ name: c.name || void 0, origin: a }) : n.push({
+        name: c.meta?.name,
+        description: c.meta?.description,
+        when: c.when,
+        origin: a
+      });
     const r = [];
-    for (const [l, i] of this.committedEventSubscribers) {
-      if (i.size === 0) continue;
-      const [a, d] = l.split("::");
-      for (let u = 0; u < i.size; u++)
-        r.push({ channel: a, type: d, phase: "committed" });
-    }
-    for (const [l, i] of this.uncommittedEventSubscribers) {
-      if (i.size === 0) continue;
-      const [a, d] = l.split("::");
-      for (let u = 0; u < i.size; u++)
-        r.push({ channel: a, type: d, phase: "uncommitted" });
-    }
-    for (const [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 o = this.listeners.size;
+    for (const c of this.connectorBus.__introspect())
+      for (let a = 0; a < c.count; a++)
+        r.push({ reducer: c.channel, property: c.type });
+    const i = [], s = (c, a) => {
+      for (const [d, f] of c) {
+        if (f.size === 0) continue;
+        const [u, p] = d.split("::");
+        for (const h of f)
+          i.push({ channel: u, type: p, phase: a, duringReplay: h.duringReplay });
+      }
+    };
+    s(this.committedEventSubscribers, "committed"), s(this.uncommittedEventSubscribers, "uncommitted"), s(this.writtenEventSubscribers, "written"), s(this.allEventSubscribers, "all");
+    const l = this.listeners.size;
     return {
       reducers: e,
       effects: t,
-      middleware: s,
-      atomic: n,
-      event: r,
-      coarse: o,
+      middleware: n,
+      atomic: r,
+      event: i,
+      coarse: l,
       dedupHits: this.dedupCount,
       queueDepth: this.reduceQueue.length + this.inFlightEffects
     };
@@ -1531,36 +1920,50 @@ class x {
       throw new Error(
         "[yoltra] External state apply (time-travel) is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
-    const t = this.state, s = e, n = { ...this.state };
-    let r = !1;
-    Object.keys(this.reducers).forEach((o) => {
-      const l = t?.[o], i = s?.[o];
-      if (i === void 0) {
-        process.env.NODE_ENV !== "production" && console.warn(
+    const t = this.replaying;
+    this.replaying = !0;
+    try {
+      return this.applyExternalStateInner(e);
+    } finally {
+      this.replaying = t;
+    }
+  }
+  /**
+   * The body of {@link __applyExternalState}, with the replay flag already set.
+   *
+   * @internal
+   */
+  applyExternalStateInner(e) {
+    const t = this.state, n = e, r = { ...this.state };
+    let i = !1;
+    Object.keys(this.reducers).forEach((s) => {
+      const l = t?.[s], c = n?.[s];
+      if (c === void 0) {
+        process.env.NODE_ENV !== "production" && (this.sliceOrigin.get(s) ?? "spec") === "spec" && console.warn(
           `[yoltra] External state is missing slice "${String(
-            o
+            s
           )}"; 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 (l === c) return;
+      const a = T(c);
+      r[s] = a, i = !0;
+      const d = I(l, c);
       if (d.length === 0) return;
-      const u = /* @__PURE__ */ new Set();
-      for (const f of d) {
-        if (f === "") {
-          u.add("");
+      const f = /* @__PURE__ */ new Set();
+      for (const u of d) {
+        if (u === "") {
+          f.add("");
           continue;
         }
-        for (const m of x.buildAncestorPaths(f)) u.add(m);
+        for (const p of k.buildAncestorPaths(u)) f.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 u of f) {
+        const p = this.getAtPath(l, u), h = this.getAtPath(a, u);
+        this.connectorBus.emit(s, u, { oldValue: p, newValue: h, path: u });
       }
-    }), r && (this.state = n), r && this.listeners.forEach((o) => o());
+    }), i && (this.state = r), i && this.listeners.forEach((s) => s());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -1579,25 +1982,39 @@ class x {
       throw new Error(
         "[yoltra] Event replay is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
+    const n = this.replaying;
+    this.replaying = !0;
+    try {
+      this.replayEventsInner(e, t);
+    } finally {
+      this.replaying = n;
+    }
+  }
+  /**
+   * The body of {@link __replayEvents}, with the replay flag already set.
+   *
+   * @internal
+   */
+  replayEventsInner(e, t) {
     this.__applyExternalState(e);
-    for (const s of t) {
-      const n = s, r = [];
-      this.stagingSink = r;
-      let o = null;
+    for (const n of t) {
+      const r = n, i = [];
+      this.stagingSink = i;
+      let s = null;
       try {
-        this.reducerBus.emit(n.channel, n.type, n.payload, n), o = this.stagedRejection;
-        for (const [i, a] of this.patternReducers) {
-          if (o !== null) break;
-          if (this.matchesWhen(a, n)) {
-            const d = this.stageSliceGuarded(i, n, r);
-            d !== null && (o = d);
+        this.reducerBus.emit(r.channel, r.type, r.payload, r), s = this.stagedRejection;
+        for (const [c, a] of this.patternReducers) {
+          if (s !== null) break;
+          if ($(a, r)) {
+            const d = this.stageSliceGuarded(c, r, i);
+            d !== null && (s = d);
           }
         }
       } finally {
         this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
       }
-      const l = o === null && this.commitStaged(r, n);
-      this.notifyEventSubscribers(n, "committed"), l && (this.notifyEventSubscribers(n, "written"), this.listeners.forEach((i) => i()));
+      const l = s === null && this.commitStaged(i, r);
+      this.notifyEventSubscribers(r, "committed"), l && (this.notifyEventSubscribers(r, "written"), this.listeners.forEach((c) => c()));
     }
   }
   /**
@@ -1643,8 +2060,8 @@ class x {
    *
    * @public
    */
-  async emit(e, t, s, n) {
-    return this.emitCaused(null, e, t, s, n);
+  async emit(e, t, n, r) {
+    return this.emitCaused(null, e, t, n, r);
   }
   /**
    * The real emit, with an explicitly supplied cause.
@@ -1658,45 +2075,45 @@ 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 $;
+  async emitCaused(e, t, n, r, i) {
+    const s = i?.dedupKey, l = this.dedupConfig.windowMs;
+    if (i?.skipDedup !== !0 && (l > 0 || s !== void 0)) {
+      const p = s !== void 0 && l <= 0 ? H : l, h = s !== void 0 ? `${t}::${n}::#${s}` : this.fingerprint(t, n, r);
+      if (this.shouldDedupe(h, p))
+        return we;
     }
-    const i = r?.id ?? this.idFactory(), a = this.currentEvent ?? e, d = a === null ? 0 : a.depth + 1;
+    const c = i?.id ?? this.idFactory(), a = this.currentEvent ?? e, d = a === null ? 0 : a.depth + 1;
     if (a !== null && d > this.maxReduceDepth)
       return this.reportCascade(
         "maxReduceDepth",
         this.maxReduceDepth,
         {
           channel: t,
-          type: s,
-          payload: n,
-          id: i,
-          ...r?.meta !== void 0 ? { meta: r.meta } : {},
+          type: n,
+          payload: r,
+          id: c,
+          ...i?.meta !== void 0 ? { meta: i.meta } : {},
           parentId: a.id,
           depth: d
         },
         d,
         a.chain
-      ), $;
-    let u;
-    const f = new Promise((m) => {
-      u = m;
+      ), F;
+    let f;
+    const u = new Promise((p) => {
+      f = p;
     });
     return this.reduceQueue.push({
       channel: t,
-      type: s,
-      payload: n,
-      id: i,
-      meta: r?.meta,
-      resolve: u,
+      type: n,
+      payload: r,
+      id: c,
+      meta: i?.meta,
+      resolve: f,
       // 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;
+    }), this.drainReduce(), u;
   }
   /**
    * Drains the reduce queue **synchronously**. For each event it runs middleware,
@@ -1713,47 +2130,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: n, payload: r, id: i, meta: s, resolve: l, parentId: c, depth: a, chain: d } = e, f = {
             channel: t,
-            type: s,
-            payload: n,
-            id: r,
-            ...o !== void 0 ? { meta: o } : {},
-            ...i !== void 0 ? { parentId: i, depth: a } : {}
+            type: n,
+            payload: r,
+            id: i,
+            ...s !== void 0 ? { meta: s } : {},
+            ...c !== void 0 ? { parentId: c, depth: a } : {}
           };
-          if (i !== void 0 && ++this.transitionsThisDrain > this.maxTransitionsPerDrain) {
+          if (c !== void 0 && ++this.transitionsThisDrain > this.maxTransitionsPerDrain) {
             this.reportCascade(
               "maxTransitionsPerDrain",
               this.maxTransitionsPerDrain,
-              u,
+              f,
               a,
               d
-            ), l($);
+            ), l(F);
             continue;
           }
           this.currentEvent = {
-            id: r,
+            id: i,
             depth: a ?? 0,
-            chain: [...d ?? [], r].slice(-z)
+            chain: [...d ?? [], i].slice(-W)
           };
-          const f = this.instrumentObservers.size > 0, m = f ? this.state : void 0, h = f ? [] : void 0;
+          const u = this.instrumentObservers.size > 0, p = u ? this.state : void 0, h = u ? [] : void 0;
           h !== void 0 && (this.changedPathSink = h);
-          const y = f ? A() : 0;
-          let g = $;
+          const y = u ? K() : 0;
+          let w = me;
           try {
-            g = this.applyEventSync(u);
-          } catch (w) {
-            console.error("Emit reduce error:", w);
+            w = this.applyEventSync(f);
+          } catch (g) {
+            console.error("Emit reduce error:", g);
           } finally {
-            f && (this.changedPathSink = null), this.currentEvent = null;
+            u && (this.changedPathSink = null), this.currentEvent = null;
           }
-          f && this.emitInstrumentation(
-            u,
-            g,
+          u && this.emitInstrumentation(
+            f,
+            w,
             h ?? [],
-            m,
-            A() - y
-          ), this.runEventEffects(u, g, l);
+            p,
+            K() - y
+          ), this.runEventEffects(f, w, l);
         }
       } finally {
         this.isReducing = !1;
@@ -1771,45 +2188,56 @@ 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 { input: s } of this.middleware) {
+      const l = A(s);
+      if (!$(l, e)) continue;
+      const c = he(s);
       let a;
       try {
-        a = i(this.state, e, this.emit), process.env.NODE_ENV !== "production" && typeof a?.then == "function" && console.error(
+        a = c(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;
+        console.error(
+          `[yoltra] Middleware threw for "${e.channel}/${e.type}"; the event was vetoed and did not reach any reducer.`,
+          d
+        ), a = !1;
+      }
+      if (a === !1) {
+        this.notifyEventSubscribers(e, "uncommitted");
+        const d = typeof s == "function" ? s.name || void 0 : s.meta?.name;
+        return Object.freeze({
+          committed: !1,
+          written: !1,
+          reason: "vetoed",
+          ...d !== void 0 && d !== "" ? { vetoedBy: d } : {}
+        });
       }
-      if (!a)
-        return this.notifyEventSubscribers(e, "uncommitted"), $;
     }
     const t = [];
     this.stagingSink = t;
-    let s = null, n = "";
+    let n = null, r = "";
     try {
       this.reducerBus.emit(
         e.channel,
         e.type,
         e.payload,
         e
-      ), s = this.stagedRejection, n = this.stagedRejectedBy;
-      for (const [o, l] of this.patternReducers) {
-        if (s !== null) break;
-        if (this.matchesWhen(l, e)) {
-          const i = this.stageSliceGuarded(o, e, t);
-          i !== null && (s = i, n = o);
+      ), n = this.stagedRejection, r = this.stagedRejectedBy;
+      for (const [s, l] of this.patternReducers) {
+        if (n !== null) break;
+        if ($(l, e)) {
+          const c = this.stageSliceGuarded(s, e, t);
+          c !== null && (n = c, r = s);
         }
       }
     } finally {
       this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
     }
-    if (s !== null)
-      return this.onRejected?.(s, e, n), this.notifyEventSubscribers(e, "committed"), { committed: !0, written: !1, rejected: s };
-    const r = this.commitStaged(t, e);
-    return this.notifyEventSubscribers(e, "committed"), r && (this.notifyEventSubscribers(e, "written"), this.listeners.forEach((o) => o())), r ? se : ne;
+    if (n !== null)
+      return this.onRejected?.(n, e, r), this.notifyEventSubscribers(e, "committed"), { committed: !0, written: !1, rejected: n };
+    const i = this.commitStaged(t, e);
+    return this.notifyEventSubscribers(e, "committed"), i && (this.notifyEventSubscribers(e, "written"), this.listeners.forEach((s) => s())), i ? Ee : be;
   }
   /**
    * Runs a single committed event's effects as an **independent async task**,
@@ -1819,14 +2247,14 @@ class x {
    *
    * @internal
    */
-  async runEventEffects(e, t, s) {
+  async runEventEffects(e, t, n) {
     this.inFlightEffects++;
     try {
       t.committed && await this.notifyEffects(e);
-    } catch (n) {
-      console.error("Effect error:", n);
+    } catch (r) {
+      console.error("Effect error:", r);
     } finally {
-      this.inFlightEffects--, s(t);
+      this.inFlightEffects--, n(t);
     }
   }
   /**
@@ -1847,11 +2275,11 @@ class x {
    *
    * @internal
    */
-  emitInstrumentation(e, t, s, n, r) {
-    const o = {}, l = {};
-    for (const a of s)
-      o[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
-    const i = {
+  emitInstrumentation(e, t, n, r, i) {
+    const s = {}, l = {};
+    for (const a of n)
+      s[a] = this.getAtPath(r, a), l[a] = this.getAtPath(this.state, a);
+    const c = {
       event: {
         id: e.id,
         channel: e.channel,
@@ -1862,17 +2290,17 @@ class x {
         ...e.meta !== void 0 ? { meta: e.meta } : {}
       },
       committed: t.committed,
-      changedPaths: s,
-      prevValues: o,
+      changedPaths: n,
+      prevValues: s,
       nextValues: l,
-      reduceTimeMs: r,
+      reduceTimeMs: i,
       // Present only when a reducer refused, so an observer can tell a refusal from a veto —
       // identical in state, entirely different in cause.
       ...t.rejected !== void 0 ? { rejected: t.rejected } : {}
     };
     for (const a of [...this.instrumentObservers])
       try {
-        a(i);
+        a(c);
       } catch (d) {
         console.error("Instrumentation observer error:", d);
       }
@@ -1894,24 +2322,220 @@ class x {
    * off();
    * ```
    *
-   * @example Wildcard pattern
-   * ```ts
-   * // Listen to any item title change
-   * const off = store.connect(
-   *   { reducer: 'todos', property: 'items.*.title' },
-   *   (chg) => console.log('some title changed')
-   * );
-   * ```
+   * @example Wildcard pattern
+   * ```ts
+   * // Listen to any item title change
+   * const off = store.connect(
+   *   { reducer: 'todos', property: 'items.*.title' },
+   *   (chg) => console.log('some title changed')
+   * );
+   * ```
+   *
+   * @public
+   */
+  connect(e, t, n) {
+    if (process.env.NODE_ENV !== "production" && this.disposedSlices.has(e.reducer)) {
+      const i = this.disposedSlices.get(e.reducer);
+      throw new Error(
+        `[yoltra] Slice "${String(e.reducer)}" was unmounted by its owner${i === void 0 ? "" : ` (${i})`}. Hooks and subscriptions widened for it are no longer valid.`
+      );
+    }
+    const r = this.connectorBus.on(e.reducer, e.property, t);
+    if (n?.immediate === !0) {
+      const i = this.state[e.reducer], s = e.property.includes("*") ? "" : e.property;
+      t({ oldValue: void 0, newValue: this.getAtPath(i, s), path: s });
+    }
+    return r;
+  }
+  /**
+   * Subscribe to reducer, middleware and effect registrations.
+   *
+   * Delivered as an array, one batch per public call: `replaceReducers` unmounts and then
+   * remounts, and a per-change observer would see a spurious unmount of a slice that is only
+   * being updated. Observers run after the state broadcast, and a registration made by an
+   * observer is queued rather than delivered re-entrantly.
+   *
+   * Replay never produces a change, so there is no `duringReplay` option here. `dispose()`
+   * fires nothing.
+   *
+   * @param observer - Receives one batch per registration change.
+   * @param options - `emitCurrent` synthesizes a `'mounted'` batch for everything already
+   * installed, delivered synchronously before this call returns, carrying each registration's
+   * real origin rather than a synthetic marker.
+   * @returns Unsubscribe function.
+   *
+   * @example
+   * ```ts
+   * const off = store.onRegistrationChange((changes) => {
+   *   for (const c of changes) {
+   *     console.log(c.op, c.kind, c.name, c.origin);
+   *   }
+   * }, { emitCurrent: true });
+   * off();
+   * ```
+   *
+   * @public
+   */
+  onRegistrationChange(e, t) {
+    if (this.registrationObservers.add(e), t?.emitCurrent === !0) {
+      const n = this.describeCurrentRegistrations();
+      if (n.length > 0) {
+        const r = this.notifyingRegistrations;
+        this.notifyingRegistrations = !0;
+        try {
+          this.invokeRegistrationObserver(e, n);
+        } finally {
+          this.notifyingRegistrations = r;
+        }
+        r || this.drainQueuedRegistrationBatches();
+      }
+    }
+    return () => {
+      this.registrationObservers.delete(e);
+    };
+  }
+  /**
+   * Everything currently installed, as `"mounted"` changes.
+   *
+   * @internal
+   */
+  describeCurrentRegistrations() {
+    const e = [];
+    for (const t of Object.keys(this.reducers))
+      e.push({
+        kind: "reducer",
+        op: "mounted",
+        name: t,
+        // The real origin, never a synthetic "existing" marker. Filtering on provenance is
+        // the main thing an observer does, and a snapshot that lied about it would break
+        // exactly the registrations that were already there.
+        origin: this.sliceOrigin.get(t) ?? "spec",
+        owner: this.sliceOwner.get(t),
+        when: this.patternReducers.get(t),
+        // From this observer's point of view the state exists; it never saw a prior value.
+        state: "initialized",
+        dispatch: this.patternReducers.has(t) ? "pattern" : "keyed"
+      });
+    for (const t of this.middleware) {
+      const n = typeof t.input == "function" ? void 0 : t.input.meta;
+      e.push({
+        kind: "middleware",
+        op: "mounted",
+        name: n?.name ?? (typeof t.input == "function" ? t.input.name : void 0),
+        description: n?.description,
+        origin: t.origin,
+        when: A(t.input),
+        dispatch: "pattern"
+      });
+    }
+    for (const [t, n] of this.effects) {
+      const [r, i] = t.split("::");
+      for (const s of n)
+        e.push({
+          kind: "effect",
+          op: "mounted",
+          name: this.effectMeta.get(s.effect)?.name,
+          description: this.effectMeta.get(s.effect)?.description,
+          origin: s.origin,
+          when: { keys: [[r, i]] },
+          dispatch: "keyed"
+        });
+    }
+    for (const t of this.patternEffects)
+      e.push({
+        kind: "effect",
+        op: "mounted",
+        name: this.effectMeta.get(t.effect)?.name,
+        description: this.effectMeta.get(t.effect)?.description,
+        origin: t.origin,
+        when: t.when,
+        dispatch: "pattern"
+      });
+    return e;
+  }
+  /**
+   * Runs `fn` as one registration transaction, flushing a single batch at the outermost end.
+   *
+   * @internal
+   */
+  inRegistrationTransaction(e) {
+    this.registrationDepth += 1;
+    try {
+      return e();
+    } finally {
+      this.registrationDepth -= 1, this.registrationDepth === 0 && this.flushRegistrationChanges();
+    }
+  }
+  /**
+   * Records a change, to be delivered when the current transaction ends.
+   *
+   * @remarks
+   * Guarded on observer count **before** anything is allocated. These call sites run inside
+   * `createStore`, so a twenty-slice store with nobody listening must build no objects and
+   * no arrays at all - the same discipline `emitInstrumentation` already follows.
+   *
+   * @internal
+   */
+  recordRegistrationChange(e) {
+    this.registrationObservers.size !== 0 && ((this.pendingRegistrationChanges ??= []).push(e()), this.registrationDepth === 0 && this.flushRegistrationChanges());
+  }
+  /** @internal */
+  flushRegistrationChanges() {
+    const e = this.pendingRegistrationChanges;
+    if (this.pendingRegistrationChanges = null, !(e === null || e.length === 0)) {
+      if (this.notifyingRegistrations) {
+        this.queuedRegistrationBatches.push(e);
+        return;
+      }
+      this.notifyingRegistrations = !0;
+      try {
+        this.deliverRegistrationBatch(e), this.drainQueuedRegistrationBatches();
+      } finally {
+        this.notifyingRegistrations = !1;
+      }
+    }
+  }
+  /**
+   * Delivers batches an observer produced while being notified.
+   *
+   * @remarks
+   * Bounded like the reduce depth, and for the same reason: two observers registering in
+   * response to each other would otherwise loop forever. Logged rather than thrown - the
+   * topology is correct at that point, and throwing would truncate the stream *and* unwind a
+   * caller that did nothing wrong.
    *
-   * @public
+   * @internal
    */
-  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 });
+  drainQueuedRegistrationBatches() {
+    let e = 0;
+    for (; this.queuedRegistrationBatches.length > 0; ) {
+      if (e >= V) {
+        console.error(
+          `[yoltra] Registration notifications exceeded ${V} rounds; dropping the rest. Two observers are most likely registering in response to each other.`
+        ), this.queuedRegistrationBatches.length = 0;
+        break;
+      }
+      e += 1, this.deliverRegistrationBatch(this.queuedRegistrationBatches.shift());
+    }
+  }
+  /** @internal */
+  deliverRegistrationBatch(e) {
+    for (const t of [...this.registrationObservers])
+      this.invokeRegistrationObserver(t, e);
+  }
+  /** @internal */
+  invokeRegistrationObserver(e, t) {
+    try {
+      const n = e(t);
+      process.env.NODE_ENV !== "production" && typeof n?.then == "function" && console.error(
+        "[yoltra] A registration observer returned a Promise. Registration notifications are synchronous: the store has already moved on by the time it resolves. Do the work synchronously, or schedule it yourself and accept that the topology may have changed again."
+      );
+    } catch (n) {
+      console.error("Registration observer error:", n);
     }
-    return n;
+  }
+  get isReplaying() {
+    return this.replaying;
   }
   /**
    * Subscribe to events by channel and type.
@@ -1924,8 +2548,15 @@ class x {
    * - `'committed'` (default): Events that passed middleware and reached reducers.
    *   Notified after reducers, before effects.
    * - `'uncommitted'`: Events rejected by middleware. Notified immediately after rejection.
+   * - `'written'`: Events that actually changed state. Stricter than `committed`, which
+   *   fires for every event a store accepts including one with no reducers at all.
    * - `'all'`: Both committed and uncommitted events. Handler receives the phase parameter
-   *   to distinguish between the two.
+   *   to distinguish between the two. Deliberately not `written` as well: an event that
+   *   writes is also committed, so folding it in would notify every existing `all`
+   *   subscriber twice for one event.
+   *
+   * **Replay:** a handler is not called while devtools is replaying, unless it opted in with
+   * `{ duringReplay: true }`.
    *
    * @typeParam C - Channel key within `EM`.
    * @typeParam T - Event type key within channel `C`.
@@ -1959,11 +2590,16 @@ 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));
+  onEvent(e, t, n, r = "committed", i) {
+    const s = `${e}::${String(t)}`, l = r === "committed" ? this.committedEventSubscribers : r === "uncommitted" ? this.uncommittedEventSubscribers : r === "written" ? this.writtenEventSubscribers : this.allEventSubscribers;
+    l.has(s) || l.set(s, /* @__PURE__ */ new Set());
+    const c = {
+      handler: n,
+      duringReplay: i?.duringReplay === !0
+    };
+    return l.get(s).add(c), () => {
+      const a = l.get(s);
+      a && (a.delete(c), a.size === 0 && l.delete(s));
     };
   }
   /**
@@ -2037,10 +2673,86 @@ class x {
    * @public
    */
   registerMiddleware(e) {
-    return this.middleware.push(e), () => {
-      const t = this.middleware.indexOf(e);
-      t !== -1 && this.middleware.splice(t, 1);
-    };
+    const t = { input: e, origin: "dynamic" };
+    return this.middleware.push(t), this.recordMiddlewareChange(t, "mounted"), this.asRegistration(() => {
+      const n = this.middleware.indexOf(t);
+      n !== -1 && (this.middleware.splice(n, 1), this.recordMiddlewareChange(t, "unmounted"));
+    });
+  }
+  /**
+   * Turns a disposer into the callable object `register*` returns.
+   *
+   * @remarks
+   * `Object.assign` onto the function rather than a new object, so every existing call site
+   * keeps working verbatim: `const off = store.registerEffect(spec); off();` compiles and
+   * runs exactly as before, while `.store` and `.dispose` become available to a library that
+   * wants the widened type.
+   *
+   * A callable object rather than an overload or a second method: an overload cannot change
+   * the return shape based on nothing, and a parallel `registerSliceX` family would leave
+   * the originals permanently second class and force libraries to branch on the core version.
+   *
+   * @internal
+   */
+  recordMiddlewareChange(e, t) {
+    this.recordRegistrationChange(() => {
+      const n = typeof e.input == "function" ? void 0 : e.input.meta;
+      return {
+        kind: "middleware",
+        op: t,
+        name: n?.name ?? (typeof e.input == "function" ? e.input.name : void 0),
+        description: n?.description,
+        origin: e.origin,
+        when: A(e.input),
+        dispatch: "pattern"
+      };
+    });
+  }
+  /**
+   * Drops an effect's metadata only once nothing is still registered with it.
+   *
+   * @remarks
+   * `effectMeta` is keyed by the effect *function*, and the same function can legitimately
+   * back several registrations. Deleting on the first disposal stripped the name and
+   * description of the ones still live, which a devtools panel then showed as unnamed.
+   *
+   * @internal
+   */
+  releaseEffectMeta(e) {
+    for (const t of this.effects.values())
+      for (const n of t) if (n.effect === e) return;
+    for (const t of this.patternEffects) if (t.effect === e) return;
+    this.effectMeta.delete(e);
+  }
+  /** @internal */
+  recordEffectChange(e, t, n, r, i) {
+    this.recordRegistrationChange(() => ({
+      kind: "effect",
+      op: r,
+      name: this.effectMeta.get(e)?.name,
+      description: this.effectMeta.get(e)?.description,
+      origin: n,
+      when: t,
+      dispatch: i
+    }));
+  }
+  /** @internal */
+  asRegistration(e) {
+    return Object.assign(e, { store: this, dispose: e });
+  }
+  /**
+   * The one place the widening cast lives.
+   *
+   * @remarks
+   * Decoration is type-level only. This returns the **same runtime object**: subscriptions,
+   * effects, middleware, the dedup cache, both buses and any in-flight `call()` are
+   * untouched, and nothing re-subscribes. Keeping the cast here means no call site needs one,
+   * which is the entire point of the feature.
+   *
+   * @internal
+   */
+  widened() {
+    return this;
   }
   /**
    * Dynamically **adds** a named slice reducer at runtime.
@@ -2064,14 +2776,65 @@ class x {
    *
    * @public
    */
-  registerReducer(e, t) {
+  registerReducer(e, t, n) {
+    return this.registerSlice(e, t, n);
+  }
+  /**
+   * Mounts a slice and hands back the widened store alongside a disposer.
+   *
+   * @remarks
+   * The name `registerSlice` is what the guide uses; `registerReducer` keeps its broader
+   * `name: string` signature and delegates here, so existing call sites are untouched.
+   *
+   * @public
+   */
+  registerSlice(e, t, n) {
+    return this.inRegistrationTransaction(() => this.registerSliceInner(e, t, n));
+  }
+  /** @internal */
+  registerSliceInner(e, t, n) {
     if (Object.prototype.hasOwnProperty.call(this.reducers, e))
       throw new Error(`Reducer ${e} already exists`);
     return this.mountSlice(e, t, {
-      preserveState: !1
-    }), this.listeners.forEach((s) => s()), () => {
-      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((s) => s());
-    };
+      preserveState: !1,
+      origin: "dynamic",
+      owner: n?.owner
+    }), this.listeners.forEach((r) => r()), this.announceMountedSlice(e, this.state[e]), this.asRegistration(() => {
+      Object.prototype.hasOwnProperty.call(this.reducers, e) && this.inRegistrationTransaction(() => {
+        this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((r) => r());
+      });
+    });
+  }
+  /**
+   * Mounts a slice and returns the widened store, for chaining.
+   *
+   * @remarks
+   * No disposer, deliberately. After a disposer runs, the widened type still promises a
+   * slice that is gone, and TypeScript cannot express "valid until that call". The chaining
+   * API therefore does not hand one out, so the footgun does not exist on the path most
+   * people take; {@link registerSlice} carries one for the library that owns the slice, and
+   * the documented rule is that a disposer stays library-private.
+   *
+   * @public
+   */
+  withSlice(e, t, n) {
+    return this.registerSlice(e, t, n), this.widened();
+  }
+  /**
+   * Registers middleware and returns the widened store, for chaining.
+   *
+   * @public
+   */
+  withMiddleware(e) {
+    return this.registerMiddleware(e), this.widened();
+  }
+  /**
+   * Registers an effect and returns the widened store, for chaining.
+   *
+   * @public
+   */
+  withEffect(e) {
+    return this.registerEffect(e), this.widened();
   }
   /**
    * Registers an **effect** (stateless async event consumer) that runs after reducers.
@@ -2168,13 +2931,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
@@ -2190,84 +2947,65 @@ 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;
+  call(e, t, n, r) {
+    return se(
+      {
+        idFactory: this.idFactory,
+        // `internal`, so an in-flight call survives even `replaceEffects(next, { scope: "all" })`.
+        // A test harness resetting a store between cases never means "and abandon the call
+        // that is currently awaiting a reply", and the symptom would be a hang to the idle
+        // timeout with nothing pointing at the reset.
+        registerEffect: (i) => this.registerEffectWithOrigin(i, "internal"),
+        emit: this.emit
       },
-      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 })
-      })
-    };
+      e,
+      t,
+      n,
+      r
+    );
   }
   registerEffect(e) {
-    const { effect: t, meta: s, when: n } = e, r = [];
-    if (s && this.effectMeta.set(t, s), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
-      const i = { effect: t, when: n };
-      return this.patternEffects.add(i), () => {
-        this.patternEffects.delete(i);
+    return this.asRegistration(this.registerEffectWithOrigin(e, "dynamic"));
+  }
+  /**
+   * {@link registerEffect}, with the provenance the caller cannot set.
+   *
+   * @remarks
+   * Kept private so no origin parameter leaks into `StoreInstance`. Three callers: the
+   * constructor (`spec`), the public method (`dynamic`), and `store.call()` (`internal`).
+   *
+   * @internal
+   */
+  registerEffectWithOrigin(e, t) {
+    const { effect: n, meta: r, when: i } = e, s = [];
+    if (r && this.effectMeta.set(n, r), i && ("any" in i && i.any === !0 || "channel" in i || "channels" in i)) {
+      const a = { effect: n, when: i, origin: t };
+      return this.patternEffects.add(a), this.recordEffectChange(n, i, t, "mounted", "pattern"), () => {
+        this.recordEffectChange(n, i, t, "unmounted", "pattern"), this.patternEffects.delete(a), this.releaseEffectMeta(n);
       };
     }
-    const l = this.normalizeEventKeys(e);
-    if (l.length === 0 && !n) {
-      const i = { effect: t, when: { any: !0 } };
-      return this.patternEffects.add(i), () => {
-        this.patternEffects.delete(i);
+    const c = U(e);
+    if (c.length === 0 && !i) {
+      const a = { any: !0 }, d = { effect: n, when: a, origin: t };
+      return this.patternEffects.add(d), this.recordEffectChange(n, a, t, "mounted", "pattern"), () => {
+        this.recordEffectChange(n, a, t, "unmounted", "pattern"), this.patternEffects.delete(d), this.releaseEffectMeta(n);
       };
     }
-    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));
+    for (const [a, d] of c) {
+      const f = `${String(a)}::${String(d)}`;
+      this.effects.has(f) || this.effects.set(f, /* @__PURE__ */ new Set());
+      const u = { effect: n, origin: t };
+      this.effects.get(f).add(u);
+      const p = { keys: [[a, d]] };
+      this.recordEffectChange(n, p, t, "mounted", "keyed"), s.push(() => {
+        this.recordEffectChange(n, p, t, "unmounted", "keyed");
+        const h = this.effects.get(f);
+        h && (h.delete(u), h.size === 0 && this.effects.delete(f));
       });
     }
     return () => {
-      for (const i of r) i();
+      for (const a of s) a();
+      this.releaseEffectMeta(n);
     };
   }
   /**
@@ -2291,15 +3029,15 @@ class x {
    *
    * @public
    */
-  onEffect(e, t, s) {
-    const n = async (r, o, l) => {
-      if (r.channel !== e || r.type !== t) return;
-      const i = r;
-      return s(i.payload, o, l, i);
+  onEffect(e, t, n) {
+    const r = async (i, s, l) => {
+      if (i.channel !== e || i.type !== t) return;
+      const c = i;
+      return n(c.payload, s, l, c);
     };
     return this.registerEffect({
       when: { keys: [[e, t]] },
-      effect: n
+      effect: r
     });
   }
   /**
@@ -2318,9 +3056,23 @@ class x {
    *
    * @public
    */
-  replaceMiddleware(e) {
+  replaceMiddleware(e, t = {}) {
+    this.inRegistrationTransaction(() => this.replaceMiddlewareInner(e, t));
+  }
+  /** @internal */
+  replaceMiddlewareInner(e, t = {}) {
+    const n = t.scope ?? "spec", r = this.middleware.filter(
+      (i) => n === "all" ? i.origin === "internal" : i.origin !== "spec"
+    );
+    for (const i of this.middleware)
+      r.includes(i) || this.recordMiddlewareChange(i, "unmounted");
     this.middleware.length = 0;
-    for (const t of e) this.middleware.push(t);
+    for (const i of e) {
+      const s = { input: i, origin: "spec" };
+      this.middleware.push(s), this.recordMiddlewareChange(s, "mounted");
+    }
+    for (const i of r) this.middleware.push(i);
+    this.reportPreserved("replaceMiddleware", r.length, n);
   }
   /**
    * Replaces all registered **effects** (HMR-friendly).
@@ -2338,16 +3090,53 @@ class x {
    *
    * @public
    */
-  replaceEffects(e) {
-    this.effects.clear(), this.patternEffects.clear();
-    for (const t of e)
-      this.registerEffect(t);
+  replaceEffects(e, t = {}) {
+    this.inRegistrationTransaction(() => this.replaceEffectsInner(e, t));
+  }
+  /** @internal */
+  replaceEffectsInner(e, t = {}) {
+    const n = t.scope ?? "spec", r = (s) => n === "all" ? s === "internal" : s !== "spec";
+    let i = 0;
+    for (const [s, l] of this.effects) {
+      for (const c of [...l]) {
+        if (r(c.origin)) {
+          i += 1;
+          continue;
+        }
+        this.recordEffectChange(
+          c.effect,
+          { keys: [s.split("::")] },
+          c.origin,
+          "unmounted",
+          "keyed"
+        ), l.delete(c), this.releaseEffectMeta(c.effect);
+      }
+      l.size === 0 && this.effects.delete(s);
+    }
+    for (const s of [...this.patternEffects]) {
+      if (r(s.origin)) {
+        i += 1;
+        continue;
+      }
+      this.recordEffectChange(s.effect, s.when, s.origin, "unmounted", "pattern"), this.patternEffects.delete(s), this.releaseEffectMeta(s.effect);
+    }
+    for (const s of e)
+      this.registerEffectWithOrigin(s, "spec");
+    this.reportPreserved("replaceEffects", i, n);
   }
   /**
    * Replaces the entire **reducer set** (HMR-friendly).
    *
    * @param next - Map of slice specs keyed by slice name.
-   * @param opts - `{ preserveState?: boolean }` (default `true`).
+   * @param opts - `{ preserveState?: boolean }` (default `true`) and
+   * `{ scope?: "spec" | "all" }` (default `"spec"`).
+   *
+   * @remarks
+   * Replaces **spec-provenance slices only**. A slice mounted after construction with
+   * `registerSlice` survives, along with its state: it was never part of the set this call
+   * is replacing. Pass `{ scope: "all" }` for the pre-0.8.0 wholesale behaviour.
+   *
+   * Throws, before mutating anything, if `next` names a slice a library mounted at runtime.
    *
    * @example Hot module replacement
    * ```ts
@@ -2361,11 +3150,67 @@ 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));
-    for (const l of n)
-      o.has(l) || this.unmountSlice(l, { deleteState: !0 });
-    for (const [l, i] of r)
-      n.has(l) ? (this.unmountSlice(l, { deleteState: !1 }), this.mountSlice(l, i, { preserveState: s })) : this.mountSlice(l, i, { preserveState: !1 });
+    this.inRegistrationTransaction(() => this.replaceReducersInner(e, t));
+  }
+  /** @internal */
+  replaceReducersInner(e, t = {}) {
+    const n = t.preserveState !== !1, r = t.scope ?? "spec", i = new Set(Object.keys(this.reducers)), s = Object.entries(e), l = new Set(s.map(([d]) => d));
+    this.assertNoSliceCollision(e, r);
+    const c = this.state;
+    let a = 0;
+    for (const d of i) {
+      if (l.has(d)) continue;
+      const f = this.sliceOrigin.get(d) ?? "spec";
+      if (!(r === "all" ? f !== "internal" : f === "spec")) {
+        a += 1;
+        continue;
+      }
+      this.unmountSlice(d, { deleteState: !0 });
+    }
+    for (const [d, f] of s)
+      i.has(d) ? (this.unmountSlice(d, { deleteState: !1 }), this.mountSlice(d, f, { preserveState: n, origin: "spec" })) : this.mountSlice(d, f, { preserveState: !1, origin: "spec" });
+    this.state !== c && this.listeners.forEach((d) => d()), this.reportPreserved("replaceReducers", a, r);
+  }
+  /**
+   * Refuses, before anything is mutated, to take over a slice mounted at runtime.
+   *
+   * @remarks
+   * An application authoring a slice a library owns is a real mistake, and a silent takeover
+   * is the worst available outcome: the library keeps a disposer for a slice that is no
+   * longer its own. Throwing part-way through would be worse still, which is why this runs
+   * as a pre-flight and why `hotReplace` calls it before swapping anything at all.
+   *
+   * @internal
+   */
+  assertNoSliceCollision(e, t) {
+    if (t !== "spec") return;
+    const n = Object.keys(e).filter(
+      (i) => this.sliceOrigin.get(i) === "dynamic"
+    );
+    if (n.length === 0) return;
+    const r = n.map((i) => {
+      const s = this.sliceOwner.get(i);
+      return s === void 0 ? `"${i}"` : `"${i}" (owner: ${s})`;
+    }).join(", ");
+    throw new Error(
+      `[yoltra] replaceReducers would take over ${n.length === 1 ? "a slice" : "slices"} mounted at runtime: ${r}. Rename the slice, or pass { scope: "all" } to replace it deliberately.`
+    );
+  }
+  /**
+   * Says what a `replace*` call left alone, when it left anything alone.
+   *
+   * @remarks
+   * Development only, and silent unless something was actually preserved, so the normal HMR
+   * path stays quiet. `console.debug` rather than `warn`: this is correct operation, and
+   * every existing `warn` in this file marks a genuine problem. It exists so "why is that
+   * effect still firing after a reload" has an answer that does not require reading core.
+   *
+   * @internal
+   */
+  reportPreserved(e, t, n) {
+    t !== 0 && process.env.NODE_ENV !== "production" && console.debug(
+      `[yoltra] ${e} preserved ${t} registration${t === 1 ? "" : "s"} made after construction.${n === "spec" ? ' Pass { scope: "all" } to replace them too.' : ""}`
+    );
   }
   /**
    * Convenience API to replace **any subset** of store parts (HMR patterns).
@@ -2385,7 +3230,10 @@ class x {
    * @public
    */
   hotReplace(e) {
-    e.middleware && this.replaceMiddleware(e.middleware), e.effects && this.replaceEffects(e.effects), e.reducer && this.replaceReducers(e.reducer, { preserveState: e.preserveState });
+    const t = e.scope;
+    e.reducer && this.assertNoSliceCollision(e.reducer, t ?? "spec"), this.inRegistrationTransaction(() => {
+      e.middleware && this.replaceMiddleware(e.middleware, { scope: t }), e.effects && this.replaceEffects(e.effects, { scope: t }), e.reducer && this.replaceReducers(e.reducer, { preserveState: e.preserveState, scope: t });
+    });
   }
   /**
    * Mounts a slice: installs reducer, initializes state (unless preserved),
@@ -2397,36 +3245,99 @@ 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 = {
+  mountSlice(e, t, n) {
+    this.mountSliceInner(e, t, n), this.recordSliceChange(
+      e,
+      "mounted",
+      n.preserveState ? "preserved" : "initialized"
+    );
+  }
+  /** @internal */
+  mountSliceInner(e, t, n) {
+    const r = e;
+    this.sliceOrigin.set(r, n.origin ?? "spec"), n.owner !== void 0 && this.sliceOwner.set(r, n.owner), this.disposedSlices.delete(r);
+    const { reducer: i, state: s, when: l } = t;
+    if (this.reducers[e] = new X(i), (!n.preserveState || this.state[r] === void 0) && (this.state = {
       ...this.state,
-      [n]: R(X(n, o))
+      [r]: T(pe(r, s))
     }), l && ("any" in l && l.any === !0 || "channel" in l || "channels" in l)) {
-      this.patternReducers.set(e, l), this.sliceUnsubs.set(n, []);
+      this.patternReducers.set(e, l), this.sliceUnsubs.set(r, []);
       return;
     }
-    const a = this.normalizeEventKeys(t);
+    const a = U(t);
     if (a.length === 0 && !l) {
-      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
+      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(r, []);
       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,
+    for (const [f, u] of a) {
+      const p = this.reducerBus.on(f, u, (h, y) => {
+        const w = y ?? {
+          channel: f,
+          type: u,
           payload: h,
           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, w, this.stagingSink);
+        g !== null && this.stagedRejection === null && (this.stagedRejection = g, this.stagedRejectedBy = e);
+      });
+      d.push(p);
+    }
+    this.sliceUnsubs.set(r, d);
+  }
+  /**
+   * Records a slice mount or unmount for {@link onRegistrationChange}.
+   *
+   * @internal
+   */
+  recordSliceChange(e, t, n) {
+    this.recordRegistrationChange(() => ({
+      kind: "reducer",
+      op: t,
+      name: e,
+      origin: this.sliceOrigin.get(e) ?? "spec",
+      owner: this.sliceOwner.get(e),
+      when: this.patternReducers.get(e),
+      state: n,
+      dispatch: this.patternReducers.has(e) ? "pattern" : "keyed"
+    }));
+  }
+  /**
+   * Announces a newly mounted slice on the connector bus.
+   *
+   * @remarks
+   * `registerReducer` has always broadcast to `listeners`, which wakes `subscribe` and so
+   * `useSelector`. It emitted **nothing** on `connectorBus`, which is what `connect` rides,
+   * so `useAtomicProp`, `useAtomicProps` and the Suspense hooks never woke for a slice
+   * mounted after creation: a component subscribed to a path inside it simply never
+   * re-rendered. That makes the decoration story ship a documented-as-working path that does
+   * not work, which is why this is here rather than filed as a follow-up.
+   *
+   * Scope, stated precisely because it is narrower than it looks: this emits the slice root
+   * and its **top-level** keys, which is exactly what an ordinary commit emits when a
+   * subtree first appears - `detectChangedProps` reports a newly-appearing branch at its
+   * root, not leaf by leaf. So a `connect` on `"deep.n"` does not fire here, and does not
+   * fire on a normal commit that first creates `deep` either. Consistent, not complete.
+   *
+   * Skipped when nothing is subscribed, and skipped entirely during construction, where no
+   * subscriber can exist yet.
+   *
+   * @internal
+   */
+  announceMountedSlice(e, t) {
+    const r = I(typeof t == "object" && t !== null ? {} : void 0, t), i = /* @__PURE__ */ new Set([""]);
+    for (const s of r)
+      if (s !== "")
+        for (const l of k.buildAncestorPaths(s)) i.add(l);
+    for (const s of i) {
+      const l = this.getAtPath(this.state[e], s);
+      this.connectorBus.emit(e, s, {
+        oldValue: void 0,
+        newValue: l,
+        path: s
       });
-      d.push(m);
     }
-    this.sliceUnsubs.set(n, d);
   }
   /**
    * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
@@ -2438,38 +3349,28 @@ class x {
    * @internal
    */
   unmountSlice(e, t) {
-    const s = e;
-    this.patternReducers.delete(e);
-    const n = this.sliceUnsubs.get(s);
-    if (n) {
-      for (const r of n)
+    const n = e;
+    if (this.recordSliceChange(n, "unmounted", t.deleteState ? "deleted" : "retained"), this.patternReducers.delete(e), process.env.NODE_ENV !== "production") {
+      const i = this.sliceOrigin.get(n);
+      if (i === "dynamic" || i === "internal")
+        for (this.disposedSlices.set(n, this.sliceOwner.get(n)); this.disposedSlices.size > ge; )
+          this.disposedSlices.delete(this.disposedSlices.keys().next().value);
+    }
+    this.sliceOrigin.delete(n), this.sliceOwner.delete(n);
+    const r = this.sliceUnsubs.get(n);
+    if (r) {
+      for (const i of r)
         try {
-          r();
-        } catch (o) {
-          console.error(`[Store error]: ${o}`);
+          i();
+        } catch (s) {
+          console.error(`[Store error]: ${s}`);
         }
-      this.sliceUnsubs.delete(s);
+      this.sliceUnsubs.delete(n);
     }
     if (delete this.reducers[e], t.deleteState) {
-      const { [s]: r, ...o } = this.state;
-      this.state = o;
-    }
-  }
-  /**
-   * Normalizes event targeting from `when` to an array of EventKeys.
-   *
-   * @param spec - Object with an optional `when` matcher.
-   * @returns Array of `[channel, type]` pairs.
-   *
-   * @internal
-   */
-  normalizeEventKeys(e) {
-    if (e.when) {
-      const t = e.when;
-      if ("keys" in t)
-        return t.keys;
+      const { [n]: i, ...s } = this.state;
+      this.state = s;
     }
-    return [];
   }
   /**
    * Reads a dotted path from an object (supports numeric array indices via string keys).
@@ -2478,17 +3379,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 oe(e, t);
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -2506,368 +3404,215 @@ 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 ce(e);
   }
 }
-function de(c) {
-  return new x({
-    ...c,
-    reducer: c.reducer ?? {},
-    middleware: c.middleware ?? [],
-    effects: c.effects ?? []
+function ke(o) {
+  return new k({
+    ...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 $e = (o) => (e, t) => t.map((n) => [e, n]), Me = () => (o) => o, Ce = () => (o) => o, Pe = () => (o) => o, Ie = () => (o) => o, L = /* @__PURE__ */ new Set();
+function ve(o) {
+  const e = String(o);
+  L.has(e) || (L.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 Se(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 Ae(o = {}) {
+  const e = o.selectId ?? ((c) => c.id), { sortComparer: t } = o, n = (c, 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 d = [...a].sort((f, u) => {
+      const p = c.entities[f], h = c.entities[u];
+      return p === void 0 || h === void 0 ? 0 : t(p, h);
     });
-    return ie(a, d);
-  }, n = (i, a, d) => {
-    const u = { ...i, entities: a, ids: d };
-    return { ...u, ids: s(u, d) };
-  }, r = (i, a, d) => {
-    let u = null, f = null;
-    for (const m of a) {
-      const h = e(m);
-      process.env.NODE_ENV !== "production" && String(h).includes(".") && re(h);
-      const y = (u ?? i.entities)[h];
+    return Se(a, d);
+  }, r = (c, a, d) => {
+    const f = { ...c, entities: a, ids: d };
+    return { ...f, ids: n(f, d) };
+  }, i = (c, a, d) => {
+    let f = null, u = null;
+    for (const p of a) {
+      const h = e(p);
+      process.env.NODE_ENV !== "production" && String(h).includes(".") && ve(h);
+      const y = (f ?? c.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));
+      const w = y !== void 0 && d === "upsert" ? { ...y, ...p } : p;
+      f ??= { ...c.entities }, f[h] = w, y === void 0 && (u ??= [...c.ids], u.push(h));
     }
-    return u === null ? i : n(i, u, f ?? i.ids);
-  }, o = (i, a) => {
+    return f === null ? c : r(c, f, u ?? c.ids);
+  }, s = (c, 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, i.ids);
-  }, l = (i, a) => {
-    const d = new Set(a.filter((f) => i.entities[f] !== void 0));
-    if (d.size === 0) return i;
-    const u = { ...i.entities };
-    for (const f of d) delete u[f];
-    return n(
-      i,
-      u,
-      i.ids.filter((f) => !d.has(f))
+    for (const { id: f, changes: u } of a) {
+      const p = (d ?? c.entities)[f];
+      p !== void 0 && (d ??= { ...c.entities }, d[f] = { ...p, ...u });
+    }
+    return d === null ? c : r(c, d, c.ids);
+  }, l = (c, a) => {
+    const d = new Set(a.filter((u) => c.entities[u] !== void 0));
+    if (d.size === 0) return c;
+    const f = { ...c.entities };
+    for (const u of d) delete f[u];
+    return r(
+      c,
+      f,
+      c.ids.filter((u) => !d.has(u))
     );
   };
   return {
-    getInitialState(i) {
+    getInitialState(c) {
       const a = { ids: [], entities: {} };
-      return i === void 0 ? a : { ...a, ...i };
+      return c === void 0 ? a : { ...a, ...c };
     },
-    addOne: (i, a) => r(i, [a], "add"),
-    addMany: (i, a) => r(i, a, "add"),
-    setOne: (i, a) => r(i, [a], "set"),
-    setMany: (i, a) => r(i, a, "set"),
-    setAll: (i, a) => {
-      const d = {}, u = [];
-      for (const f of a) {
-        const m = e(f);
-        d[m] === void 0 && u.push(m), d[m] = f;
+    addOne: (c, a) => i(c, [a], "add"),
+    addMany: (c, a) => i(c, a, "add"),
+    setOne: (c, a) => i(c, [a], "set"),
+    setMany: (c, a) => i(c, a, "set"),
+    setAll: (c, a) => {
+      const d = {}, f = [];
+      for (const u of a) {
+        const p = e(u);
+        d[p] === void 0 && f.push(p), d[p] = u;
       }
-      return n(i, d, u);
+      return r(c, d, f);
     },
-    updateOne: (i, a) => o(i, [a]),
-    updateMany: (i, a) => o(i, a),
-    upsertOne: (i, a) => r(i, [a], "upsert"),
-    upsertMany: (i, a) => r(i, a, "upsert"),
-    removeOne: (i, a) => l(i, [a]),
-    removeMany: (i, a) => l(i, a),
-    removeAll: (i) => i.ids.length === 0 ? i : n(i, {}, []),
-    selectIds: (i) => i.ids,
-    selectEntities: (i) => i.entities,
-    selectAll: (i) => i.ids.map((a) => i.entities[a]),
-    selectById: (i, a) => i.entities[a],
-    selectTotal: (i) => i.ids.length,
+    updateOne: (c, a) => s(c, [a]),
+    updateMany: (c, a) => s(c, a),
+    upsertOne: (c, a) => i(c, [a], "upsert"),
+    upsertMany: (c, a) => i(c, a, "upsert"),
+    removeOne: (c, a) => l(c, [a]),
+    removeMany: (c, a) => l(c, a),
+    removeAll: (c) => c.ids.length === 0 ? c : r(c, {}, []),
+    selectIds: (c) => c.ids,
+    selectEntities: (c) => c.entities,
+    selectAll: (c) => c.ids.map((a) => c.entities[a]),
+    selectById: (c, a) => c.entities[a],
+    selectTotal: (c) => c.ids.length,
     idsPath: "ids",
-    pathTo: (i, a) => a === void 0 ? `entities.${i}` : `entities.${i}.${a}`,
-    anyField: (i) => `entities.*.${i}`
-  };
-}
-const E = "$yoltra";
-function B(c, e = {}) {
-  const t = e.maxNodes ?? 1e5, s = e.sanitize, n = [], r = /* @__PURE__ */ new Map();
-  let o = 0, l = !1;
-  function i(d, u) {
-    if (s !== void 0 && (d = s(u, d)), o += 1, o > t)
-      return l = !0, { [E]: "unsupported", kind: "truncated" };
-    switch (typeof d) {
-      case "undefined":
-        return { [E]: "undefined" };
-      case "bigint":
-        return { [E]: "bigint", value: d.toString() };
-      case "number":
-        return Number.isNaN(d) ? { [E]: "nan" } : d === 1 / 0 ? { [E]: "infinity", sign: 1 } : d === -1 / 0 ? { [E]: "infinity", sign: -1 } : d;
-      case "function":
-      case "symbol":
-        return n.push(u), { [E]: "unsupported", kind: typeof d };
-      case "string":
-      case "boolean":
-        return d;
-    }
-    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 (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 (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 } };
-}
-function oe(c) {
-  const e = /* @__PURE__ */ new Map(), t = [];
-  function s(o, l) {
-    if (o === null || typeof o != "object") return o;
-    if (Array.isArray(o)) {
-      const a = [];
-      return e.set(l, a), o.forEach((d, u) => {
-        if (j(d)) {
-          t.push({ target: a, key: u, path: d.path }), a[u] = void 0;
-          return;
-        }
-        a[u] = s(d, `${l}/${u}`);
-      }), a;
-    }
-    if (typeof o[E] == "string") {
-      const a = o;
-      switch (a[E]) {
-        case "undefined":
-          return;
-        case "nan":
-          return Number.NaN;
-        case "infinity":
-          return a.sign === 1 ? 1 / 0 : -1 / 0;
-        case "bigint":
-          return BigInt(a.value);
-        case "date":
-          return new Date(a.iso);
-        case "regexp":
-          return new RegExp(a.source, a.flags);
-        case "error": {
-          const d = new Error(a.message);
-          return d.name = a.name, d;
-        }
-        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;
-        }
-        case "set": {
-          const d = /* @__PURE__ */ new Set();
-          return e.set(l, d), a.values.forEach((u, f) => d.add(s(u, `${l}/${f}`))), d;
-        }
-        case "escaped":
-          return n(a.value, l);
-        default:
-          return;
-      }
-    }
-    return n(o, l);
-  }
-  function n(o, l) {
-    const i = {};
-    e.set(l, i);
-    for (const [a, d] of Object.entries(o)) {
-      const u = `${l}/${H(a)}`;
-      if (j(d)) {
-        t.push({ target: i, key: a, path: d.path }), i[a] = void 0;
-        continue;
-      }
-      i[a] = s(d, u);
-    }
-    return i;
-  }
-  const r = s(c, "");
-  e.set("", r);
-  for (const { target: o, key: l, path: i } of t)
-    o[l] = e.get(i);
-  return r;
-}
-function j(c) {
-  return c !== null && typeof c == "object" && c[E] === "ref" && typeof c.path == "string";
-}
-function H(c) {
-  return c.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function pe(c, e, t = {}) {
-  let s = t.maxNodes ?? 1e5;
-  for (let n = 0; n < 8; n += 1) {
-    const { value: r, report: o } = B(c, { ...t, maxNodes: s });
-    let l;
-    try {
-      l = JSON.stringify(r)?.length ?? 0;
-    } catch {
-      l = Number.POSITIVE_INFINITY;
-    }
-    if (l <= e)
-      return o.truncated ? {
-        value: r,
-        truncated: !0,
-        note: `State was too large to send in full; parts beyond ${s} nodes are omitted.`
-      } : { value: r, truncated: !1 };
-    const i = Math.floor(s * e * 0.8 / l);
-    if (s = Math.max(1, Math.min(i, s - 1)), s <= 1 && n > 0)
-      break;
-  }
-  return {
-    value: { [E]: "unsupported", kind: "truncated" },
-    truncated: !0,
-    note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
+    pathTo: (c, a) => a === void 0 ? `entities.${c}` : `entities.${c}.${a}`,
+    anyField: (c) => `entities.*.${c}`
   };
 }
-function v(c, e, t) {
-  c.onError?.(e, t);
+function S(o, e, t) {
+  o.onError?.(e, t);
 }
-async function me(c) {
+async function Te(o) {
   const e = { slices: {}, restored: !1 };
   let t;
   try {
-    t = c.source ?? await c.adapter.read(c.key);
-  } catch (n) {
-    return v(c, n, "read"), e;
+    t = o.source ?? await o.adapter.read(o.key);
+  } catch (r) {
+    return S(o, r, "read"), e;
   }
   if (t == null || t === "") return e;
-  let s;
+  let n;
   try {
-    s = oe(JSON.parse(t));
-  } catch (n) {
-    return v(c, n, "decode"), e;
-  }
-  if (s === null || typeof s != "object" || typeof s.version != "number")
-    return v(c, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
-  if (s.version !== c.version) {
-    if (c.migrate === void 0)
-      return v(
-        c,
+    n = le(JSON.parse(t));
+  } catch (r) {
+    return S(o, r, "decode"), e;
+  }
+  if (n === null || typeof n != "object" || typeof n.version != "number")
+    return S(o, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
+  if (n.version !== o.version) {
+    if (o.migrate === void 0)
+      return S(
+        o,
         new Error(
-          `persisted state is version ${s.version}, this build expects ${c.version}, and no migrate was supplied`
+          `persisted state is version ${n.version}, this build expects ${o.version}, and no migrate was supplied`
         ),
         "migrate"
       ), e;
     try {
-      const n = c.migrate(s.slices, s.version);
-      return n === null ? e : { slices: n, restored: !0 };
-    } catch (n) {
-      return v(c, n, "migrate"), e;
+      const r = o.migrate(n.slices, n.version);
+      return r === null ? e : { slices: r, restored: !0 };
+    } catch (r) {
+      return S(o, r, "migrate"), e;
     }
   }
-  return { slices: s.slices ?? {}, restored: !0 };
+  return { slices: n.slices ?? {}, restored: !0 };
 }
-function ye(c, e) {
-  if (!e.restored) return c;
+function De(o, e) {
+  if (!e.restored) return o;
   const t = {};
-  for (const [s, n] of Object.entries(c)) {
-    const r = e.slices[s];
-    t[s] = r === void 0 ? n : { ...n, state: r };
+  for (const [n, r] of Object.entries(o)) {
+    const i = e.slices[n];
+    t[n] = i === void 0 ? r : { ...r, state: i };
   }
   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 Q(o, e) {
+  const t = o ?? {}, n = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((s) => s in t).map((s) => [s, t[s]])), { value: r, report: i } = j({ version: e.version, slices: n });
+  if (i.truncated || i.unsupported.length > 0) {
+    const s = [];
+    i.truncated && s.push("state was too large to encode in full"), i.unsupported.length > 0 && s.push(`values with no faithful representation at: ${i.unsupported.join(", ")}`);
+    const l = s.join("; ");
+    S(
+      e,
+      new Error(`[yoltra] Persisted state is incomplete - ${l}.`),
+      "encode"
+    );
+  }
+  return JSON.stringify(r);
 }
-function ge(c, e) {
-  const t = e.throttleMs ?? 250, s = e.slices;
-  let n = null, r = !1;
-  const o = () => {
-    if (r) {
-      r = !1;
+function xe(o, e) {
+  const t = e.throttleMs ?? 250, n = e.slices;
+  let r = null, i = !1;
+  const s = () => {
+    if (i) {
+      i = !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, Q(o.getState(), e));
+        a instanceof Promise && a.catch((d) => S(e, d, "write"));
       } catch (a) {
-        v(e, a, "write");
+        S(e, a, "write");
       }
     }
   }, l = () => {
-    if (r = !0, t <= 0) {
-      o();
+    if (i = !0, t <= 0) {
+      s();
       return;
     }
-    n === null && (n = setTimeout(() => {
-      n = null, o();
-    }, t), n.unref?.());
-  }, i = c.instrument((a) => {
-    if (s === void 0) {
+    r === null && (r = setTimeout(() => {
+      r = null, s();
+    }, t), r.unref?.());
+  }, c = o.instrument((a) => {
+    if (n === void 0) {
       l();
       return;
     }
     (a.changedPaths ?? []).some(
-      (u) => s.some((f) => u === f || u.startsWith(`${f}.`))
+      (f) => n.some((u) => f === u || f.startsWith(`${u}.`))
     ) && l();
   });
   return () => {
-    i(), n !== null && (clearTimeout(n), n = null), o();
+    c(), r !== null && (clearTimeout(r), r = null), s();
   };
 }
-function we(c, e) {
-  return W(c.getState(), e);
+function je(o, e) {
+  return Q(o.getState(), e);
 }
-function Ee(c) {
+function _e(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 Be(o) {
+  const e = new Map(Object.entries(o ?? {}));
   return {
     read: (t) => e.get(t) ?? null,
-    write: (t, s) => {
-      e.set(t, s);
+    write: (t, n) => {
+      e.set(t, n);
     },
     remove: (t) => {
       e.delete(t);
@@ -2875,28 +3620,31 @@ function be(c) {
   };
 }
 export {
-  C as CallAbortedError,
-  J as CallTimeoutError,
-  U as EventBus,
-  L as LooseEventBus,
-  V as Reducer,
-  le as Rejected,
-  x as Store,
-  he as createEntityAdapter,
-  be as createMemoryAdapter,
-  de as createStore,
-  Ee as createWebStorageAdapter,
-  oe as decodeState,
-  we as dehydrate,
+  B as CallAbortedError,
+  Z as CallTimeoutError,
+  G as EventBus,
+  J as LooseEventBus,
+  X as Reducer,
+  Re as Rejected,
+  k as Store,
+  Ae as createEntityAdapter,
+  Be as createMemoryAdapter,
+  ke as createStore,
+  _e as createWebStorageAdapter,
+  le as decodeState,
+  Ie as defineEffect,
+  Pe as defineMiddleware,
+  Ce as defineSlice,
+  je as dehydrate,
   I as detectChangedProps,
-  B as encodeState,
-  pe as encodeStateBounded,
-  fe as eventKeys,
-  M as freezeState,
-  me as hydrate,
-  Q as isRejected,
-  ge as persist,
-  ue as typedEvents,
-  ye as withHydration
+  j as encodeState,
+  Oe as encodeStateBounded,
+  Me as eventKeys,
+  C as freezeState,
+  Te as hydrate,
+  Y as isRejected,
+  xe as persist,
+  $e as typedEvents,
+  De as withHydration
 };
 //# sourceMappingURL=yoltra.mjs.map