@yoltra/core 0.7.0 → 0.8.0

package/dist/yoltra.mjs

@@ -1,8 +1,8 @@
 /*!
- * @yoltra/core v0.7.0
+ * @yoltra/core v0.8.0
  * (c) 2026 Manu Ramirez <@pixerael>
  * License: MIT */
-class W {
+class G {
   /**
    * Internal registry: `channel → type → Set<handler>`.
    * @internal
@@ -40,11 +40,11 @@ class W {
    *
    * @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`}.
@@ -66,11 +66,11 @@ class W {
    *
    * @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)`.
@@ -94,16 +94,16 @@ class W {
    *
    * @public
    */
-  emit(e, t, s, n) {
-    const r = this.handlers.get(e);
-    if (!r) return;
-    const c = r.get(t);
-    if (!(!c || c.size === 0))
-      for (const l of [...c])
+  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);
         }
   }
   /**
@@ -123,7 +123,7 @@ class W {
     this.handlers.clear();
   }
 }
-class U {
+class J {
   /**
    * Exact handlers: `channel → type → [handlers]`.
    * @internal
@@ -184,18 +184,18 @@ class U {
    *
    * @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 c = this.patternHandlers.get(e);
-      return c.has(r) || (c.set(r, []), this.indexPattern(e, r)), c.get(r).push(s), () => this.offPattern(e, r, s);
+      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 c = this.handlers.get(e);
-      return c.has(r) || c.set(r, []), c.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);
     }
   }
   /**
@@ -216,9 +216,9 @@ class U {
    *
    * @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.
@@ -228,13 +228,13 @@ class U {
    * @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 c = r.indexOf(s);
-    c !== -1 && r.splice(c, 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.
@@ -244,13 +244,13 @@ class U {
    * @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 c = r.indexOf(s);
-    c !== -1 && r.splice(c, 1), r.length === 0 && (n.delete(t), this.unindexPattern(e, t)), n.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
+    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.
@@ -272,21 +272,21 @@ class U {
    *
    * @public
    */
-  emit(e, t, s) {
-    const n = String(t), r = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n), i = /* @__PURE__ */ new Set(), a = (u) => {
-      for (const d of [...u])
-        if (!i.has(d)) {
-          i.add(d);
+  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 {
-            d(s);
-          } catch (h) {
-            console.error(h);
+            f(n);
+          } catch (u) {
+            console.error(u);
             continue;
           }
         }
     };
-    a(c);
-    for (const u of l) a(u);
+    a(s);
+    for (const d of l) a(d);
   }
   /**
    * Emits a payload that is only built if somebody is listening.
@@ -304,23 +304,23 @@ class U {
    *
    * @public
    */
-  emitWith(e, t, s) {
-    const n = String(t), r = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n);
-    if (c.length === 0 && l.length === 0) return;
-    const i = s(), a = /* @__PURE__ */ new Set(), u = (d) => {
-      for (const h of [...d])
-        if (!a.has(h)) {
-          a.add(h);
+  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 {
-            h(i);
+            u(c);
           } catch (p) {
             console.error(p);
             continue;
           }
         }
     };
-    u(c);
-    for (const d of l) u(d);
+    d(s);
+    for (const f of l) d(f);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -359,27 +359,27 @@ class U {
    * @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 }, c = n[0];
-    if (c === void 0 || c === "*" || c === "**") {
-      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(c);
-    l === void 0 ? s.byHead.set(c, [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 c = r.findIndex((l) => l.pattern === t);
-    c !== -1 && r.splice(c, 1), r.length === 0 && r !== s.anyHead && n !== void 0 && s.byHead.delete(n);
+    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.
@@ -393,20 +393,20 @@ class U {
    * @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), c = [], l = (a) => {
-      for (const u of a) {
-        if (!this.matchSegments(u.segments, r)) continue;
-        const d = s.get(u.pattern);
-        d !== void 0 && c.push(d);
+    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, 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), c;
+    return l(r.anyHead), s;
   }
   /**
    * Pattern matcher over dot-separated segments, which arrive already split.
@@ -437,18 +437,18 @@ class U {
    * @internal
    */
   matchSegments(e, t) {
-    let s = 0, n = 0, r = -1, c = 0;
-    for (; n < t.length; )
-      if (s < e.length && (e[s] === "*" || e[s] === t[n]))
-        s++, n++;
-      else if (s < e.length && e[s] === "**")
-        r = s, c = n, s++;
-      else if (r !== -1)
-        s = r + 1, n = ++c;
+    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.
@@ -473,16 +473,16 @@ class U {
    */
   __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 L {
+class X {
   /**
    * The underlying pure reducer function.
    * @internal
@@ -524,147 +524,147 @@ class L {
     return this._reduce(e, t);
   }
 }
-const T = /* @__PURE__ */ new Set();
-function O(o, e) {
+const _ = /* @__PURE__ */ new Set();
+function P(o, e) {
   const t = o ? `${o}.${e}` : e;
-  T.has(t) || (T.add(t), console.warn(
+  _.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(o, e, t = "", s = /* @__PURE__ */ new Map()) {
-  const n = [];
-  return P(o, 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(o, e, t, s, n) {
+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 (o instanceof Date && e instanceof Date) {
-    o.getTime() !== e.getTime() && n.push(t);
+    o.getTime() !== e.getTime() && r.push(t);
     return;
   }
   if (o instanceof RegExp && e instanceof RegExp) {
-    (o.source !== e.source || e.flags !== o.flags) && n.push(t);
+    (o.source !== e.source || e.flags !== o.flags) && r.push(t);
     return;
   }
   if (o instanceof Map || e instanceof Map) {
-    n.push(t);
+    r.push(t);
     return;
   }
   if (o instanceof Set || e instanceof Set) {
-    n.push(t);
+    r.push(t);
     return;
   }
-  const r = o, c = e, l = s.get(r);
-  if (l?.has(c)) return;
-  const i = l ?? /* @__PURE__ */ new Set();
-  i.add(c), l || s.set(r, i);
+  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(o), u = Array.isArray(e);
-    if (a !== u) {
-      n.push(t);
+    const a = Array.isArray(o), d = Array.isArray(e);
+    if (a !== d) {
+      r.push(t);
       return;
     }
     if (a) {
-      const f = o, m = e;
-      f.length !== m.length && t && n.push(t);
-      const y = Math.min(f.length, m.length);
-      for (let g = 0; g < y; g++)
-        f[g] !== m[g] && P(f[g], m[g], t ? `${t}.${g}` : `${g}`, s, n);
-      for (let g = y; g < Math.max(f.length, m.length); g++)
-        n.push(t ? `${t}.${g}` : `${g}`);
+      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 d = Object.keys(o), h = Object.keys(e);
-    if (d.length === 0 && h.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 p = d.length === h.length;
+    let p = f.length === u.length;
     if (p) {
-      for (let f = 0; f < h.length; f++)
-        if (!Object.prototype.hasOwnProperty.call(o, h[f])) {
+      for (let h = 0; h < u.length; h++)
+        if (!Object.prototype.hasOwnProperty.call(o, u[h])) {
           p = !1;
           break;
         }
     }
     if (p) {
-      for (const f of h)
-        o[f] !== e[f] && (process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f), P(o[f], e[f], t ? `${t}.${f}` : f, s, n));
+      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 f of h) {
-      const m = Object.prototype.hasOwnProperty.call(o, f);
-      if (m && o[f] === e[f]) continue;
-      process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f);
-      const y = t ? `${t}.${f}` : f;
-      if (!m) {
-        n.push(y);
+    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) {
+        r.push(w);
         continue;
       }
-      P(o[f], e[f], y, s, n);
+      M(o[h], e[h], w, n, r);
     }
-    for (const f of d)
-      Object.prototype.hasOwnProperty.call(e, f) || (process.env.NODE_ENV !== "production" && f.includes(".") && O(t, f), n.push(t ? `${t}.${f}` : f));
+    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(c), i.size === 0 && s.delete(r);
+    c.delete(s), c.size === 0 && n.delete(i);
   }
 }
-function M(o, e = /* @__PURE__ */ new WeakSet(), t) {
-  if (o === null || typeof o != "object" || e.has(o) || (t !== void 0 && o === t.watch && t.onFound(), Object.isFrozen(o))) return o;
-  if (e.add(o), Array.isArray(o)) {
-    const s = o;
-    for (let n = 0; n < s.length; n++)
-      s[n] = M(s[n], e, t);
-    return Object.freeze(s);
-  }
-  for (const s of Object.getOwnPropertyNames(o)) {
-    const n = Object.getOwnPropertyDescriptor(o, s);
-    !n || !("value" in n) || (o[s] = M(o[s], e, t));
-  }
-  for (const s of Object.getOwnPropertySymbols(o)) {
-    const n = Object.getOwnPropertyDescriptor(o, s);
-    !n || !("value" in n) || (o[s] = M(o[s], e, t));
+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 B = /* @__PURE__ */ Symbol.for("yoltra.rejected");
-function fe(o) {
-  return { [B]: !0, reason: o };
+const q = /* @__PURE__ */ Symbol.for("yoltra.rejected");
+function Re(o) {
+  return { [q]: !0, reason: o };
 }
-function V(o) {
-  return typeof o == "object" && o !== null && o[B] === !0;
+function Y(o) {
+  return typeof o == "object" && o !== null && o[q] === !0;
 }
-class Q extends Error {
+class Z extends Error {
   channel;
   type;
   idleMs;
-  constructor(e, t, s) {
+  constructor(e, t, n) {
     super(
-      `[yoltra] call to "${e}/${t}" saw no correlated reply for ${s}ms. The timeout is idle rather than total, so this means the responder went quiet, not that it was slow. Check that something handles "${e}/${t}" and that its reply is emitted through the \`emit\` it was handed — a reply emitted from an unrelated context carries no causal link, and needs an explicit correlationId instead.`
-    ), this.name = "CallTimeoutError", this.channel = e, this.type = t, this.idleMs = s;
+      `[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 C extends Error {
+class B extends Error {
   constructor(e) {
     super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
   }
 }
-function G(o) {
+function ee(o) {
   const [e, t] = o;
   if (t === void 0) return { channel: e, isTerminal: () => !0 };
-  if (typeof t == "string") return { channel: e, isTerminal: (n) => n === t };
-  const s = new Set(t);
-  return { channel: e, isTerminal: (n) => s.has(n) };
+  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 J(o, e, t) {
+function te(o, e, t) {
   return o.parentId === e ? !0 : t === void 0 ? !1 : o.meta?.correlationId === t;
 }
-class q {
+class ne {
   constructor(e) {
     this.highWaterMark = e;
   }
@@ -699,8 +699,8 @@ class q {
   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. */
@@ -708,12 +708,12 @@ class q {
     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);
     });
   }
   /**
@@ -734,9 +734,9 @@ class q {
       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();
     }
   }
@@ -761,91 +761,356 @@ class q {
       t.release(), t = this.putters.shift();
   }
 }
-const Y = 3e4, X = 16;
-function Z(o, e, t, s, n) {
-  const { channel: r, isTerminal: c } = G(n.reply), l = n.timeoutMs ?? Y, i = new q(n.highWaterMark ?? X), a = o.idFactory();
-  let u, d, h = !1;
-  const p = new Promise((E, v) => {
-    u = E, d = v;
+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 f = null, m = null;
-  const y = (E, v = !1) => {
-    h || (h = !0, f !== null && clearTimeout(f), f = null, m?.(), m = null, v ? i.end() : i.close(), n.signal?.removeEventListener("abort", g), E());
+  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() {
-    y(() => d(new C(String(n.signal?.reason ?? "signal aborted"))));
+    w(() => f(new B(String(r.signal?.reason ?? "signal aborted"))));
   }
-  const $ = () => {
-    f !== null && clearTimeout(f), f = setTimeout(() => {
-      y(() => d(new Q(e, t, l)));
-    }, l), f.unref?.();
+  const b = () => {
+    h !== null && clearTimeout(h), h = setTimeout(() => {
+      w(() => f(new Z(e, t, l)));
+    }, l), h.unref?.();
   };
-  return m = o.registerEffect({
+  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: r },
+    when: { channel: i },
     effect: async (E) => {
-      if (!h && J(E, a, n.correlationId)) {
-        if ($(), c(String(E.type))) {
-          y(() => u(E), !0);
+      if (!u && te(E, a, r.correlationId)) {
+        if (b(), s(String(E.type))) {
+          w(() => d(E), !0);
           return;
         }
-        await i.put(E);
+        await c.put(E);
       }
     }
-  }), n.signal !== void 0 && (n.signal.aborted ? g() : n.signal.addEventListener("abort", g, { once: !0 })), $(), o.emit(e, t, s, {
+  }), r.signal !== void 0 && (r.signal.aborted ? g() : r.signal.addEventListener("abort", g, { once: !0 })), b(), o.emit(e, t, n, {
     id: a,
-    ...n.correlationId !== void 0 ? { meta: { correlationId: n.correlationId } } : {}
+    ...r.correlationId !== void 0 ? { meta: { correlationId: r.correlationId } } : {}
   }), {
-    then: (E, v) => p.then(E, v),
+    then: (E, R) => p.then(E, R),
     catch: (E) => p.catch(E),
     finally: (E) => p.finally(E),
     get dropped() {
-      return i.droppedCount;
+      return c.droppedCount;
     },
     cancel: (E = "cancelled") => {
-      y(() => d(new C(E)));
+      w(() => f(new B(E)));
     },
-    [Symbol.asyncIterator]: () => (i.beginConsuming(), {
-      next: () => i.take(),
+    [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 () => (i.close(), { value: void 0, done: !0 })
+      return: async () => (c.close(), { value: void 0, done: !0 })
     })
   };
 }
-function ee(o, e) {
+function oe(o, e) {
   if (!e) return o;
-  const s = (e[0] === "." ? e.slice(1) : e).split(".");
-  let n = o;
-  for (const r of s) {
-    if (n == null) return;
-    n = n[r];
+  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 n;
+  return r;
 }
-function te(o) {
+function ce(o) {
   if (!o) return [];
-  const t = (o[0] === "." ? o.slice(1) : o).split("."), s = [];
-  for (let n = 0; n < t.length; n++)
-    s.push(t.slice(0, n + 1).join("."));
-  return s;
+  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 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 k(o, e) {
+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, s]) => e.channel === t && e.type === s
+    ([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 ne(o) {
+function he(o) {
   return typeof o == "function" ? o : o.middleware;
 }
-function se(o) {
+function A(o) {
   if (typeof o != "function")
     return o.when;
 }
-function D(o) {
+function U(o) {
   if (o.when) {
     const e = o.when;
     if ("keys" in e)
@@ -853,7 +1118,7 @@ function D(o) {
   }
   return [];
 }
-function re(o, e) {
+function pe(o, e) {
   try {
     return structuredClone(e);
   } catch (t) {
@@ -862,11 +1127,19 @@ function re(o, e) {
     );
   }
 }
-function R(o, e) {
-  return process.env.NODE_ENV === "production" ? o : M(o, /* @__PURE__ */ new WeakSet(), e);
+function T(o, e) {
+  return process.env.NODE_ENV === "production" ? o : C(o, /* @__PURE__ */ new WeakSet(), e);
 }
-const A = 100, ie = 64, z = 16, S = Object.freeze({ committed: !1, written: !1 }), oe = Object.freeze({ committed: !0, written: !1 }), ce = Object.freeze({ committed: !0, written: !0 }), _ = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
-class x {
+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).
    *
@@ -876,7 +1149,9 @@ class x {
   /**
    * Registered middleware pipeline (run **before** reducers).
    * Stores either raw functions (legacy) or MiddlewareSpec objects.
-   * Return `false` from the middleware function to stop propagation.
+   *
+   * Only an explicit `false` stops propagation. Returning nothing allows the event, so
+   * middleware that only logs or measures needs no `return` at all.
    *
    * @internal
    */
@@ -960,6 +1235,17 @@ class x {
    */
   writtenEventSubscribers = /* @__PURE__ */ new Map();
   allEventSubscribers = /* @__PURE__ */ new Map();
+  /**
+   * True while a devtools time-travel is applying a snapshot or replaying events.
+   *
+   * @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
+   */
+  replaying = !1;
   /**
    * Track reducerBus unsubs per slice for HMR/register/unregister.
    *
@@ -974,6 +1260,70 @@ class x {
    * @internal
    */
   patternReducers = /* @__PURE__ */ new Map();
+  /**
+   * Where each mounted slice came from. See {@link Origin}.
+   *
+   * @remarks
+   * This is what makes `replace*` mean "replace mine" rather than "replace everything". It
+   * is written by `mountSlice` and never by a caller.
+   *
+   * @internal
+   */
+  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`.
@@ -1000,6 +1350,8 @@ class x {
    * signal that a reducer misbehaved.
    */
   onReducerError;
+  /** @internal */
+  onSubscriberError;
   /**
    * `slice:channel:type` combinations already warned about for payload aliasing.
    *
@@ -1089,13 +1441,15 @@ class x {
    * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
    *
    * **Deduplication Behavior:**
-   * - Events are fingerprinted using `channel::type::JSON(payload)`
+   * - 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 50ms in development, 100ms in production
+   * - The window is `dedupWindowMs`, which defaults to `0` (dedup off)
    *
    * **Limitations:**
-   * - Non-serializable payloads (functions, symbols, circular refs) get unique
-   *   fingerprints and won't be deduplicated
+   * - 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
    *
@@ -1138,14 +1492,17 @@ class x {
    * @public
    */
   constructor(e) {
-    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new W(), this.connectorBus = new U(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.idFactory = e.idFactory ?? (() => crypto.randomUUID()), this.onEffectError = e.onEffectError, this.onReducerError = e.onReducerError, this.maxReduceDepth = e.maxReduceDepth ?? ie, this.maxTransitionsPerDrain = e.maxTransitionsPerDrain ?? 1 / 0, this.onCascade = e.onCascade, this.onRejected = e.onRejected, this.dedupConfig = {
+    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, s]) => {
-      this.mountSlice(t, s, { preserveState: !1 });
+    }, Object.entries(e.reducer).forEach(([t, n]) => {
+      this.mountSlice(t, n, { preserveState: !1 });
     }), e.effects?.length)
       for (const t of e.effects)
-        this.registerEffect(t);
+        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);
   }
   /**
@@ -1162,7 +1519,7 @@ class x {
    * @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.changedPathSink = null;
+    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.writtenEventSubscribers.clear(), this.allEventSubscribers.clear(), this.instrumentObservers.clear(), this.connectorBus.clear(), this.reducerBus.clear(), this.patternReducers.clear(), this.sliceUnsubs.clear(), this.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.
@@ -1175,18 +1532,8 @@ class x {
    *
    * @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()}`;
-    }
+  fingerprint(e, t, n) {
+    return ue(e, t, n);
   }
   /**
    * Checks if an event should be deduplicated.
@@ -1198,8 +1545,8 @@ class x {
    * @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);
+    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
@@ -1221,9 +1568,9 @@ class x {
    * @internal
    */
   pruneProcessedEvents(e) {
-    const t = Math.max(this.dedupConfig.windowMs, A), s = e - t * 2;
-    for (const [n, r] of this.processedEvents)
-      r < s && this.processedEvents.delete(n);
+    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);
   }
   /**
@@ -1237,14 +1584,14 @@ class x {
    *
    * @internal
    */
-  reportCascade(e, t, s, n, r) {
+  reportCascade(e, t, n, r, i) {
     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).` : "")
+      `[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: s, depth: n, chain: r });
-    } catch (c) {
-      console.error("onCascade handler error:", c);
+      this.onCascade?.({ limit: e, limitValue: t, event: n, depth: r, chain: i });
+    } catch (s) {
+      console.error("onCascade handler error:", s);
     }
   }
   /**
@@ -1256,18 +1603,18 @@ class x {
    * @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])
+    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 r(e, this.getState, t);
-        } catch (c) {
-          console.error("Effect error:", c), this.onEffectError?.(c, e);
+          await i.effect(e, this.getState, t);
+        } catch (s) {
+          console.error("Effect error:", s), this.onEffectError?.(s, e);
         }
-    for (const { effect: r, when: c } of this.patternEffects)
-      if (k(c, e))
+    for (const { effect: i, when: s } of this.patternEffects)
+      if ($(s, e))
         try {
-          await r(e, this.getState, t);
+          await i(e, this.getState, t);
         } catch (l) {
           console.error("Effect error:", l), this.onEffectError?.(l, e);
         }
@@ -1286,9 +1633,9 @@ class x {
     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, c) => this.emitCaused(t, s, n, r, c));
+    return ((n, r, i, s) => this.emitCaused(t, n, r, i, s));
   }
   /**
    * Notifies event subscribers for a specific phase.
@@ -1301,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 c = this.allEventSubscribers.get(s);
-    if (c?.size)
-      for (const l of [...c]) 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
@@ -1316,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);
     }
   }
   /**
@@ -1375,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;
     }
   }
   /**
@@ -1398,13 +1750,13 @@ class x {
    *
    * @internal
    */
-  stageSlice(e, t, s) {
-    const n = this.state[e], r = this.reducers[e].reduce(n, t);
-    if (V(r)) return r;
-    if (n === r) return null;
-    const c = I(n, r);
-    if (c.length === 0) return null;
-    const l = t.payload, i = process.env.NODE_ENV !== "production" && l !== null && typeof l == "object" ? {
+  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}`;
@@ -1413,11 +1765,11 @@ class x {
         ));
       }
     } : void 0;
-    return s.push({
+    return n.push({
       name: e,
-      prev: n,
-      frozen: R(r, i),
-      leafPaths: c
+      prev: r,
+      frozen: T(i, c),
+      leafPaths: s
     }), null;
   }
   /**
@@ -1441,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 c of n.leafPaths) {
-        if (c === "") {
-          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(c)) r.add(l);
+        for (const l of k.buildAncestorPaths(s)) i.add(l);
       }
-      for (const c of r)
-        this.connectorBus.emitWith(n.name, c, () => ({
-          oldValue: this.getAtPath(n.prev, c),
-          newValue: this.getAtPath(n.frozen, c),
-          path: c,
+      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.
@@ -1482,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, u] = l.split("::");
-      for (const d of i) {
-        const h = this.effectMeta.get(d);
-        t.push({ channel: a, type: u, name: h?.name, description: h?.description });
+    for (const [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, u] = l.split("::");
-      for (let d = 0; d < i.size; d++)
-        r.push({ channel: a, type: u, phase: "committed" });
-    }
-    for (const [l, i] of this.uncommittedEventSubscribers) {
-      if (i.size === 0) continue;
-      const [a, u] = l.split("::");
-      for (let d = 0; d < i.size; d++)
-        r.push({ channel: a, type: u, phase: "uncommitted" });
-    }
-    for (const [l, i] of this.allEventSubscribers) {
-      if (i.size === 0) continue;
-      const [a, u] = l.split("::");
-      for (let d = 0; d < i.size; d++)
-        r.push({ channel: a, type: u, phase: "all" });
-    }
-    const c = 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: c,
+      middleware: n,
+      atomic: r,
+      event: i,
+      coarse: l,
       dedupHits: this.dedupCount,
       queueDepth: this.reduceQueue.length + this.inFlightEffects
     };
@@ -1565,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((c) => {
-      const l = t?.[c], i = s?.[c];
-      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(
-            c
+            s
           )}"; retaining its current value. Time-travel snapshots should contain all slices.`
         );
         return;
       }
-      if (l === i) return;
-      const a = R(i);
-      n[c] = a, r = !0;
-      const u = I(l, i);
-      if (u.length === 0) return;
-      const d = /* @__PURE__ */ new Set();
-      for (const h of u) {
-        if (h === "") {
-          d.add("");
+      if (l === c) return;
+      const a = T(c);
+      r[s] = a, i = !0;
+      const d = I(l, c);
+      if (d.length === 0) return;
+      const f = /* @__PURE__ */ new Set();
+      for (const u of d) {
+        if (u === "") {
+          f.add("");
           continue;
         }
-        for (const p of x.buildAncestorPaths(h)) d.add(p);
+        for (const p of k.buildAncestorPaths(u)) f.add(p);
       }
-      for (const h of d) {
-        const p = this.getAtPath(l, h), f = this.getAtPath(a, h);
-        this.connectorBus.emit(c, h, { oldValue: p, newValue: f, path: h });
+      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((c) => c());
+    }), i && (this.state = r), i && this.listeners.forEach((s) => s());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -1613,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 c = 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), c = this.stagedRejection;
-        for (const [i, a] of this.patternReducers) {
-          if (c !== null) break;
-          if (k(a, n)) {
-            const u = this.stageSliceGuarded(i, n, r);
-            u !== null && (c = u);
+        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 = c === 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()));
     }
   }
   /**
@@ -1677,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.
@@ -1692,45 +2075,45 @@ class x {
    *
    * @internal
    */
-  async emitCaused(e, t, s, n, r) {
-    const c = r?.dedupKey, l = this.dedupConfig.windowMs;
-    if (r?.skipDedup !== !0 && (l > 0 || c !== void 0)) {
-      const p = c !== void 0 && l <= 0 ? A : l, f = c !== void 0 ? `${t}::${s}::#${c}` : this.fingerprint(t, s, n);
-      if (this.shouldDedupe(f, p))
-        return S;
+  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, u = a === null ? 0 : a.depth + 1;
-    if (a !== null && u > this.maxReduceDepth)
+    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: u
+          depth: d
         },
-        u,
+        d,
         a.chain
-      ), S;
-    let d;
-    const h = new Promise((p) => {
-      d = p;
+      ), 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: d,
+      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: u, chain: a.chain } : {}
-    }), this.drainReduce(), h;
+      ...a !== null ? { parentId: a.id, depth: d, chain: a.chain } : {}
+    }), this.drainReduce(), u;
   }
   /**
    * Drains the reduce queue **synchronously**. For each event it runs middleware,
@@ -1747,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: c, resolve: l, parentId: i, depth: a, chain: u } = e, d = {
+          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,
-            ...c !== void 0 ? { meta: c } : {},
-            ...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,
-              d,
+              f,
               a,
-              u
-            ), l(S);
+              d
+            ), l(F);
             continue;
           }
           this.currentEvent = {
-            id: r,
+            id: i,
             depth: a ?? 0,
-            chain: [...u ?? [], r].slice(-z)
+            chain: [...d ?? [], i].slice(-W)
           };
-          const h = this.instrumentObservers.size > 0, p = h ? this.state : void 0, f = h ? [] : void 0;
-          f !== void 0 && (this.changedPathSink = f);
-          const m = h ? _() : 0;
-          let y = S;
+          const u = this.instrumentObservers.size > 0, p = u ? this.state : void 0, h = u ? [] : void 0;
+          h !== void 0 && (this.changedPathSink = h);
+          const y = u ? K() : 0;
+          let w = me;
           try {
-            y = this.applyEventSync(d);
+            w = this.applyEventSync(f);
           } catch (g) {
             console.error("Emit reduce error:", g);
           } finally {
-            h && (this.changedPathSink = null), this.currentEvent = null;
+            u && (this.changedPathSink = null), this.currentEvent = null;
           }
-          h && this.emitInstrumentation(
-            d,
-            y,
-            f ?? [],
+          u && this.emitInstrumentation(
+            f,
+            w,
+            h ?? [],
             p,
-            _() - m
-          ), this.runEventEffects(d, y, l);
+            K() - y
+          ), this.runEventEffects(f, w, l);
         }
       } finally {
         this.isReducing = !1;
@@ -1805,45 +2188,56 @@ class x {
    * @internal
    */
   applyEventSync(e) {
-    for (const c of this.middleware) {
-      const l = se(c);
-      if (!k(l, e)) continue;
-      const i = ne(c);
+    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 (u) {
-        console.error("Middleware error:", u), a = !1;
+      } catch (d) {
+        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"), S;
     }
     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 [c, l] of this.patternReducers) {
-        if (s !== null) break;
-        if (k(l, e)) {
-          const i = this.stageSliceGuarded(c, e, t);
-          i !== null && (s = i, n = c);
+      ), 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((c) => c())), r ? ce : oe;
+    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**,
@@ -1853,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);
     }
   }
   /**
@@ -1881,11 +2275,11 @@ class x {
    *
    * @internal
    */
-  emitInstrumentation(e, t, s, n, r) {
-    const c = {}, l = {};
-    for (const a of s)
-      c[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
-    const i = {
+  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,
@@ -1896,19 +2290,19 @@ class x {
         ...e.meta !== void 0 ? { meta: e.meta } : {}
       },
       committed: t.committed,
-      changedPaths: s,
-      prevValues: c,
+      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);
-      } catch (u) {
-        console.error("Instrumentation observer error:", u);
+        a(c);
+      } catch (d) {
+        console.error("Instrumentation observer error:", d);
       }
   }
   /**
@@ -1939,13 +2333,209 @@ class x {
    *
    * @public
    */
-  connect(e, t, s) {
-    const n = this.connectorBus.on(e.reducer, e.property, t);
-    if (s?.immediate === !0) {
-      const r = this.state[e.reducer], c = e.property.includes("*") ? "" : e.property;
-      t({ oldValue: void 0, newValue: this.getAtPath(r, c), path: c });
+  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"
+        });
     }
-    return n;
+    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.
+   *
+   * @internal
+   */
+  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);
+    }
+  }
+  get isReplaying() {
+    return this.replaying;
   }
   /**
    * Subscribe to events by channel and type.
@@ -1958,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`.
@@ -1993,11 +2590,16 @@ class x {
    *
    * @public
    */
-  onEvent(e, t, s, n = "committed") {
-    const r = `${e}::${String(t)}`, c = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : n === "written" ? this.writtenEventSubscribers : this.allEventSubscribers;
-    return c.has(r) || c.set(r, /* @__PURE__ */ new Set()), c.get(r).add(s), () => {
-      const l = c.get(r);
-      l && (l.delete(s), l.size === 0 && c.delete(r));
+  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));
     };
   }
   /**
@@ -2071,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.
@@ -2098,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.
@@ -2218,39 +2947,65 @@ class x {
    *
    * @public
    */
-  call(e, t, s, n) {
-    return Z(
-      { idFactory: this.idFactory, registerEffect: this.registerEffect, emit: this.emit },
+  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
+      },
       e,
       t,
-      s,
-      n
+      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 = D(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 u = `${String(i)}::${String(a)}`;
-      this.effects.has(u) || this.effects.set(u, /* @__PURE__ */ new Set()), this.effects.get(u).add(t), r.push(() => {
-        const d = this.effects.get(u);
-        d && (d.delete(t), d.size === 0 && this.effects.delete(u));
+    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);
     };
   }
   /**
@@ -2274,15 +3029,15 @@ class x {
    *
    * @public
    */
-  onEffect(e, t, s) {
-    const n = async (r, c, l) => {
-      if (r.channel !== e || r.type !== t) return;
-      const i = r;
-      return s(i.payload, c, l, i);
+  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
     });
   }
   /**
@@ -2301,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).
@@ -2321,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
@@ -2344,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), c = new Set(r.map(([l]) => l));
-    for (const l of n)
-      c.has(l) || this.unmountSlice(l, { deleteState: !0 });
-    for (const [l, i] of r)
-      n.has(l) ? (this.unmountSlice(l, { deleteState: !1 }), this.mountSlice(l, i, { preserveState: s })) : this.mountSlice(l, i, { preserveState: !1 });
+    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).
@@ -2368,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),
@@ -2380,36 +3245,99 @@ class x {
    *
    * @internal
    */
-  mountSlice(e, t, s) {
-    const n = e, { reducer: r, state: c, when: l } = t;
-    if (this.reducers[e] = new L(r), (!s.preserveState || this.state[n] === void 0) && (this.state = {
+  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(re(n, c))
+      [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 = D(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 u = [];
-    for (const [d, h] of a) {
-      const p = this.reducerBus.on(d, h, (f, m) => {
-        const y = m ?? {
-          channel: d,
-          type: h,
-          payload: f,
+    const d = [];
+    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 g = this.stageSliceGuarded(e, y, this.stagingSink);
+        const g = this.stageSliceGuarded(e, w, this.stagingSink);
         g !== null && this.stagedRejection === null && (this.stagedRejection = g, this.stagedRejectedBy = e);
       });
-      u.push(p);
+      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
+      });
     }
-    this.sliceUnsubs.set(n, u);
   }
   /**
    * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
@@ -2421,21 +3349,27 @@ 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 (c) {
-          console.error(`[Store error]: ${c}`);
+          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, ...c } = this.state;
-      this.state = c;
+      const { [n]: i, ...s } = this.state;
+      this.state = s;
     }
   }
   /**
@@ -2452,7 +3386,7 @@ class x {
    * @internal
    */
   getAtPath(e, t) {
-    return ee(e, t);
+    return oe(e, t);
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -2470,364 +3404,215 @@ class x {
    * @public
    */
   static buildAncestorPaths(e) {
-    return te(e);
+    return ce(e);
   }
 }
-function he(o) {
-  return new x({
+function ke(o) {
+  return new k({
     ...o,
     reducer: o.reducer ?? {},
     middleware: o.middleware ?? [],
     effects: o.effects ?? []
   });
 }
-const pe = (o) => (e, t) => t.map((s) => [e, s]), me = () => (o) => o, j = /* @__PURE__ */ new Set();
-function ae(o) {
+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);
-  j.has(e) || (j.add(e), console.warn(
+  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 le(o, e) {
+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 ye(o = {}) {
-  const e = o.selectId ?? ((i) => i.id), { sortComparer: t } = o, 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 u = [...a].sort((d, h) => {
-      const p = i.entities[d], f = i.entities[h];
-      return p === void 0 || f === void 0 ? 0 : t(p, f);
+    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 le(a, u);
-  }, n = (i, a, u) => {
-    const d = { ...i, entities: a, ids: u };
-    return { ...d, ids: s(d, u) };
-  }, r = (i, a, u) => {
-    let d = null, h = null;
+    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 f = e(p);
-      process.env.NODE_ENV !== "production" && String(f).includes(".") && ae(f);
-      const m = (d ?? i.entities)[f];
-      if (m !== void 0 && u === "add") continue;
-      const y = m !== void 0 && u === "upsert" ? { ...m, ...p } : p;
-      d ??= { ...i.entities }, d[f] = y, m === void 0 && (h ??= [...i.ids], h.push(f));
-    }
-    return d === null ? i : n(i, d, h ?? i.ids);
-  }, c = (i, a) => {
-    let u = null;
-    for (const { id: d, changes: h } of a) {
-      const p = (u ?? i.entities)[d];
-      p !== void 0 && (u ??= { ...i.entities }, u[d] = { ...p, ...h });
-    }
-    return u === null ? i : n(i, u, i.ids);
-  }, l = (i, a) => {
-    const u = new Set(a.filter((h) => i.entities[h] !== void 0));
-    if (u.size === 0) return i;
-    const d = { ...i.entities };
-    for (const h of u) delete d[h];
-    return n(
-      i,
-      d,
-      i.ids.filter((h) => !u.has(h))
+      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 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 f === null ? c : r(c, f, u ?? c.ids);
+  }, s = (c, a) => {
+    let d = null;
+    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 u = {}, d = [];
-      for (const h of a) {
-        const p = e(h);
-        u[p] === void 0 && d.push(p), u[p] = h;
+    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, u, d);
+      return r(c, d, f);
     },
-    updateOne: (i, a) => c(i, [a]),
-    updateMany: (i, a) => c(i, a),
-    upsertOne: (i, a) => r(i, [a], "upsert"),
-    upsertMany: (i, a) => r(i, a, "upsert"),
-    removeOne: (i, a) => l(i, [a]),
-    removeMany: (i, a) => l(i, a),
-    removeAll: (i) => i.ids.length === 0 ? i : n(i, {}, []),
-    selectIds: (i) => i.ids,
-    selectEntities: (i) => i.entities,
-    selectAll: (i) => i.ids.map((a) => i.entities[a]),
-    selectById: (i, a) => i.entities[a],
-    selectTotal: (i) => i.ids.length,
+    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}`
+    pathTo: (c, a) => a === void 0 ? `entities.${c}` : `entities.${c}.${a}`,
+    anyField: (c) => `entities.*.${c}`
   };
 }
-const w = "$yoltra";
-function H(o, e = {}) {
-  const t = e.maxNodes ?? 1e5, s = e.sanitize, n = [], r = /* @__PURE__ */ new Map();
-  let c = 0, l = !1;
-  function i(u, d) {
-    if (s !== void 0 && (u = s(d, u)), c += 1, c > t)
-      return l = !0, { [w]: "unsupported", kind: "truncated" };
-    switch (typeof u) {
-      case "undefined":
-        return { [w]: "undefined" };
-      case "bigint":
-        return { [w]: "bigint", value: u.toString() };
-      case "number":
-        return Number.isNaN(u) ? { [w]: "nan" } : u === 1 / 0 ? { [w]: "infinity", sign: 1 } : u === -1 / 0 ? { [w]: "infinity", sign: -1 } : u;
-      case "function":
-      case "symbol":
-        return n.push(d), { [w]: "unsupported", kind: typeof u };
-      case "string":
-      case "boolean":
-        return u;
-    }
-    if (u === null) return null;
-    const h = u, p = r.get(h);
-    if (p !== void 0) return { [w]: "ref", path: p };
-    if (r.set(h, d), u instanceof Date)
-      return { [w]: "date", iso: u.toISOString() };
-    if (u instanceof RegExp)
-      return { [w]: "regexp", source: u.source, flags: u.flags };
-    if (u instanceof Error)
-      return { [w]: "error", name: u.name, message: u.message };
-    if (u instanceof Map) {
-      const m = [];
-      let y = 0;
-      for (const [g, $] of u)
-        m.push([i(g, `${d}/@k${y}`), i($, `${d}/${y}`)]), y += 1;
-      return { [w]: "map", entries: m };
-    }
-    if (u instanceof Set) {
-      const m = [];
-      let y = 0;
-      for (const g of u)
-        m.push(i(g, `${d}/${y}`)), y += 1;
-      return { [w]: "set", values: m };
-    }
-    if (Array.isArray(u))
-      return u.map((m, y) => i(m, `${d}/${y}`));
-    const f = {};
-    for (const [m, y] of Object.entries(u))
-      f[m] = i(y, `${d}/${F(m)}`);
-    return w in f ? { [w]: "escaped", value: f } : f;
-  }
-  return { value: i(o, ""), report: { truncated: l, unsupported: n } };
-}
-function ue(o) {
-  const e = /* @__PURE__ */ new Map(), t = [];
-  function s(c, l) {
-    if (c === null || typeof c != "object") return c;
-    if (Array.isArray(c)) {
-      const a = [];
-      return e.set(l, a), c.forEach((u, d) => {
-        if (N(u)) {
-          t.push({ target: a, key: d, path: u.path }), a[d] = void 0;
-          return;
-        }
-        a[d] = s(u, `${l}/${d}`);
-      }), a;
-    }
-    if (typeof c[w] == "string") {
-      const a = c;
-      switch (a[w]) {
-        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 u = new Error(a.message);
-          return u.name = a.name, u;
-        }
-        case "unsupported":
-          return;
-        case "ref":
-          return;
-        case "map": {
-          const u = /* @__PURE__ */ new Map();
-          return e.set(l, u), a.entries.forEach(([d, h], p) => {
-            u.set(s(d, `${l}/@k${p}`), s(h, `${l}/${p}`));
-          }), u;
-        }
-        case "set": {
-          const u = /* @__PURE__ */ new Set();
-          return e.set(l, u), a.values.forEach((d, h) => u.add(s(d, `${l}/${h}`))), u;
-        }
-        case "escaped":
-          return n(a.value, l);
-        default:
-          return;
-      }
-    }
-    return n(c, l);
-  }
-  function n(c, l) {
-    const i = {};
-    e.set(l, i);
-    for (const [a, u] of Object.entries(c)) {
-      const d = `${l}/${F(a)}`;
-      if (N(u)) {
-        t.push({ target: i, key: a, path: u.path }), i[a] = void 0;
-        continue;
-      }
-      i[a] = s(u, d);
-    }
-    return i;
-  }
-  const r = s(o, "");
-  e.set("", r);
-  for (const { target: c, key: l, path: i } of t)
-    c[l] = e.get(i);
-  return r;
-}
-function N(o) {
-  return o !== null && typeof o == "object" && o[w] === "ref" && typeof o.path == "string";
-}
-function F(o) {
-  return o.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function ge(o, e, t = {}) {
-  let s = t.maxNodes ?? 1e5;
-  for (let n = 0; n < 8; n += 1) {
-    const { value: r, report: c } = H(o, { ...t, maxNodes: s });
-    let l;
-    try {
-      l = JSON.stringify(r)?.length ?? 0;
-    } catch {
-      l = Number.POSITIVE_INFINITY;
-    }
-    if (l <= e)
-      return c.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: { [w]: "unsupported", kind: "truncated" },
-    truncated: !0,
-    note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
-  };
-}
-function b(o, e, t) {
+function S(o, e, t) {
   o.onError?.(e, t);
 }
-async function we(o) {
+async function Te(o) {
   const e = { slices: {}, restored: !1 };
   let t;
   try {
     t = o.source ?? await o.adapter.read(o.key);
-  } catch (n) {
-    return b(o, n, "read"), e;
+  } catch (r) {
+    return S(o, r, "read"), e;
   }
   if (t == null || t === "") return e;
-  let s;
+  let n;
   try {
-    s = ue(JSON.parse(t));
-  } catch (n) {
-    return b(o, n, "decode"), e;
+    n = le(JSON.parse(t));
+  } catch (r) {
+    return S(o, r, "decode"), e;
   }
-  if (s === null || typeof s != "object" || typeof s.version != "number")
-    return b(o, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
-  if (s.version !== o.version) {
+  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 b(
+      return S(
         o,
         new Error(
-          `persisted state is version ${s.version}, this build expects ${o.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 = o.migrate(s.slices, s.version);
-      return n === null ? e : { slices: n, restored: !0 };
-    } catch (n) {
-      return b(o, 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 Ee(o, e) {
+function De(o, e) {
   if (!e.restored) return o;
   const t = {};
-  for (const [s, n] of Object.entries(o)) {
-    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 K(o, e) {
-  const t = o ?? {}, s = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((n) => n in t).map((n) => [n, t[n]]));
-  return JSON.stringify(H({ version: e.version, slices: s }).value);
+function 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 be(o, e) {
-  const t = e.throttleMs ?? 250, s = e.slices;
-  let n = null, r = !1;
-  const c = () => {
-    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, K(o.getState(), e));
-        a instanceof Promise && a.catch((u) => b(e, u, "write"));
+        const a = e.adapter.write(e.key, Q(o.getState(), e));
+        a instanceof Promise && a.catch((d) => S(e, d, "write"));
       } catch (a) {
-        b(e, a, "write");
+        S(e, a, "write");
       }
     }
   }, l = () => {
-    if (r = !0, t <= 0) {
-      c();
+    if (i = !0, t <= 0) {
+      s();
       return;
     }
-    n === null && (n = setTimeout(() => {
-      n = null, c();
-    }, t), n.unref?.());
-  }, i = o.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(
-      (d) => s.some((h) => d === h || d.startsWith(`${h}.`))
+      (f) => n.some((u) => f === u || f.startsWith(`${u}.`))
     ) && l();
   });
   return () => {
-    i(), n !== null && (clearTimeout(n), n = null), c();
+    c(), r !== null && (clearTimeout(r), r = null), s();
   };
 }
-function ve(o, e) {
-  return K(o.getState(), e);
+function je(o, e) {
+  return Q(o.getState(), e);
 }
-function Se(o) {
+function _e(o) {
   return {
     read: (e) => o.getItem(e),
     write: (e, t) => o.setItem(e, t),
     remove: (e) => o.removeItem(e)
   };
 }
-function $e(o) {
+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);
@@ -2835,28 +3620,31 @@ function $e(o) {
   };
 }
 export {
-  C as CallAbortedError,
-  Q as CallTimeoutError,
-  W as EventBus,
-  U as LooseEventBus,
-  L as Reducer,
-  fe as Rejected,
-  x as Store,
-  ye as createEntityAdapter,
-  $e as createMemoryAdapter,
-  he as createStore,
-  Se as createWebStorageAdapter,
-  ue as decodeState,
-  ve as dehydrate,
+  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,
-  H as encodeState,
-  ge as encodeStateBounded,
-  me as eventKeys,
-  M as freezeState,
-  we as hydrate,
-  V as isRejected,
-  be as persist,
-  pe as typedEvents,
-  Ee as withHydration
+  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