@yoltra/core 0.3.0 → 0.4.0

package/dist/yoltra.esm.js

@@ -1,5 +1,5 @@
 /*!
- * @yoltra/core v0.3.0
+ * @yoltra/core v0.4.0
  * (c) 2026 Manu Ramirez <@pixerael>
  * License: MIT
  * Homepage: https://yoltra.dev
@@ -7,16 +7,16 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree
  */
-var P = Object.defineProperty;
-var z = (a, e, t) => e in a ? P(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
-var d = (a, e, t) => z(a, typeof e != "symbol" ? e + "" : e, t);
-class O {
+var T = Object.defineProperty;
+var C = (o, e, t) => e in o ? T(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var p = (o, e, t) => C(o, typeof e != "symbol" ? e + "" : e, t);
+class B {
   constructor() {
     /**
      * Internal registry: `channel → type → Set<handler>`.
      * @internal
      */
-    d(this, "handlers", /* @__PURE__ */ new Map());
+    p(this, "handlers", /* @__PURE__ */ new Map());
   }
   /**
    * Subscribes a handler to an exact `(channel, type)`.
@@ -25,7 +25,10 @@ class O {
    * @typeParam T - Type key within channel `C` (must be a string key of `EM[C]`).
    * @param channel - Channel name to subscribe to.
    * @param type - Event type within the channel.
-   * @param handler - Function invoked with the payload type `EM[C][T]`.
+   * @param handler - Function invoked with the payload type `EM[C][T]`. It optionally
+   * receives the **source event** as a second argument when the emitter supplies one, so
+   * subscribers can read the true `id` (and any `meta`) instead of reconstructing an event
+   * from the payload alone. Handlers that declare only `payload` remain valid.
    * @returns An **unsubscribe** function that removes this handler.
    *
    * @example
@@ -38,13 +41,20 @@ class O {
    * off();
    * ```
    *
+   * @example Reading the source event
+   * ```ts
+   * bus.on('data', 'loaded', (payload, event) => {
+   *   console.log('event id:', event?.id);
+   * });
+   * ```
+   *
    * @public
    */
-  on(e, t, r) {
-    let n = this.handlers.get(e);
-    n || (n = /* @__PURE__ */ new Map(), this.handlers.set(e, n));
-    let s = n.get(t);
-    return s || (s = /* @__PURE__ */ new Set(), n.set(t, s)), s.add(r), () => this.off(e, t, r);
+  on(e, t, n) {
+    let s = this.handlers.get(e);
+    s || (s = /* @__PURE__ */ new Map(), this.handlers.set(e, s));
+    let i = s.get(t);
+    return i || (i = /* @__PURE__ */ new Set(), s.set(t, i)), i.add(n), () => this.off(e, t, n);
   }
   /**
    * Removes a specific handler previously added with {@link EventBus.on | `on`}.
@@ -66,11 +76,11 @@ class O {
    *
    * @public
    */
-  off(e, t, r) {
-    const n = this.handlers.get(e);
-    if (!n) return;
-    const s = n.get(t);
-    s && (s.delete(r), s.size === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e));
+  off(e, t, n) {
+    const s = this.handlers.get(e);
+    if (!s) return;
+    const i = s.get(t);
+    i && (i.delete(n), i.size === 0 && s.delete(t), s.size === 0 && this.handlers.delete(e));
   }
   /**
    * Emits an event to all subscribers of the exact `(channel, type)`.
@@ -83,6 +93,9 @@ class O {
    * @param channel - Channel name to emit on.
    * @param type - Event type to emit.
    * @param payload - Payload matching `EM[C][T]`.
+   * @param event - Optional **source event**, forwarded to handlers as a second argument.
+   * Supply it whenever the caller already holds the real event so subscribers observe its
+   * true `id` rather than reconstructing one; omitting it keeps the original behaviour.
    *
    * @example
    * ```ts
@@ -91,16 +104,16 @@ class O {
    *
    * @public
    */
-  emit(e, t, r) {
-    const n = this.handlers.get(e);
-    if (!n) return;
-    const s = n.get(t);
-    if (!(!s || s.size === 0))
-      for (const c of [...s])
+  emit(e, t, n, s) {
+    const i = this.handlers.get(e);
+    if (!i) return;
+    const d = i.get(t);
+    if (!(!d || d.size === 0))
+      for (const a of [...d])
         try {
-          c(r);
-        } catch (i) {
-          console.error("EventBus handler error:", i);
+          a(n, s);
+        } catch (r) {
+          console.error("EventBus handler error:", r);
         }
   }
   /**
@@ -120,18 +133,36 @@ class O {
     this.handlers.clear();
   }
 }
-class k {
+class H {
   constructor() {
     /**
      * Exact handlers: `channel → type → [handlers]`.
      * @internal
      */
-    d(this, "handlers", /* @__PURE__ */ new Map());
+    p(this, "handlers", /* @__PURE__ */ new Map());
     /**
      * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
      * @internal
      */
-    d(this, "patternHandlers", /* @__PURE__ */ new Map());
+    p(this, "patternHandlers", /* @__PURE__ */ new Map());
+    /**
+     * Patterns bucketed by their first segment, so an emit tests only what could match.
+     *
+     * @remarks
+     * Delivery used to walk every pattern registered on the channel and run the full segment
+     * matcher against each. That is linear in the number of patterns rather than in the number
+     * that match, and it re-split both the pattern and the subject on every test — for a thousand
+     * patterns, two thousand string splits to deliver one event.
+     *
+     * A subject's first segment can only be matched by a pattern whose first segment is that same
+     * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
+     * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
+     * the handful that begin with a wildcard.
+     *
+     * It buys nothing for a channel where every pattern starts with `**`, since all of those must
+     * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
+     */
+    p(this, "patternIndex", /* @__PURE__ */ new Map());
   }
   /**
    * Subscribes a handler to either an **exact** type or a **pattern**.
@@ -165,18 +196,18 @@ class k {
    *
    * @public
    */
-  on(e, t, r) {
-    const n = String(t);
-    if (this.isPattern(n)) {
-      const s = n;
+  on(e, t, n) {
+    const s = String(t);
+    if (this.isPattern(s)) {
+      const i = s;
       this.patternHandlers.has(e) || this.patternHandlers.set(e, /* @__PURE__ */ new Map());
-      const c = this.patternHandlers.get(e);
-      return c.has(s) || c.set(s, []), c.get(s).push(r), () => this.offPattern(e, s, r);
+      const d = this.patternHandlers.get(e);
+      return d.has(i) || (d.set(i, []), this.indexPattern(e, i)), d.get(i).push(n), () => this.offPattern(e, i, n);
     } else {
-      const s = this.normalizeTypeKey(n);
+      const i = this.normalizeTypeKey(s);
       this.handlers.has(e) || this.handlers.set(e, /* @__PURE__ */ new Map());
-      const c = this.handlers.get(e);
-      return c.has(s) || c.set(s, []), c.get(s).push(r), () => this.offExactNormalized(e, s, r);
+      const d = this.handlers.get(e);
+      return d.has(i) || d.set(i, []), d.get(i).push(n), () => this.offExactNormalized(e, i, n);
     }
   }
   /**
@@ -197,9 +228,9 @@ class k {
    *
    * @public
    */
-  off(e, t, r) {
-    const n = this.normalizeTypeKey(String(t));
-    this.offExactNormalized(e, n, r);
+  off(e, t, n) {
+    const s = this.normalizeTypeKey(String(t));
+    this.offExactNormalized(e, s, n);
   }
   /**
    * Internal exact unsubscription using an already **normalized** type key.
@@ -209,13 +240,13 @@ class k {
    * @param handler - Handler to remove.
    * @internal
    */
-  offExactNormalized(e, t, r) {
-    const n = this.handlers.get(e);
-    if (!n) return;
-    const s = n.get(t);
+  offExactNormalized(e, t, n) {
+    const s = this.handlers.get(e);
     if (!s) return;
-    const c = s.indexOf(r);
-    c !== -1 && s.splice(c, 1), s.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
+    const i = s.get(t);
+    if (!i) return;
+    const d = i.indexOf(n);
+    d !== -1 && i.splice(d, 1), i.length === 0 && s.delete(t), s.size === 0 && this.handlers.delete(e);
   }
   /**
    * Internal removal for a **pattern** subscription. No-ops if missing.
@@ -225,13 +256,13 @@ class k {
    * @param handler - Handler to remove.
    * @internal
    */
-  offPattern(e, t, r) {
-    const n = this.patternHandlers.get(e);
-    if (!n) return;
-    const s = n.get(t);
+  offPattern(e, t, n) {
+    const s = this.patternHandlers.get(e);
     if (!s) return;
-    const c = s.indexOf(r);
-    c !== -1 && s.splice(c, 1), s.length === 0 && n.delete(t), n.size === 0 && this.patternHandlers.delete(e);
+    const i = s.get(t);
+    if (!i) return;
+    const d = i.indexOf(n);
+    d !== -1 && i.splice(d, 1), i.length === 0 && (s.delete(t), this.unindexPattern(e, t)), s.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
   }
   /**
    * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
@@ -253,27 +284,55 @@ class k {
    *
    * @public
    */
-  emit(e, t, r) {
-    const n = String(t), s = this.normalizeTypeKey(n), c = this.handlers.get(e)?.get(s) ?? [], i = this.patternHandlers.get(e), o = [];
-    if (i && i.size) {
-      const l = this.normalizeTypeKey(n);
-      for (const [u, p] of i.entries())
-        this.matchPattern(u, l) && o.push(p);
-    }
-    const f = /* @__PURE__ */ new Set(), h = (l) => {
-      for (const u of [...l])
-        if (!f.has(u)) {
-          f.add(u);
+  emit(e, t, n) {
+    const s = String(t), i = this.normalizeTypeKey(s), d = this.handlers.get(e)?.get(i) ?? [], a = this.matchingPatternHandlers(e, s), r = /* @__PURE__ */ new Set(), f = (c) => {
+      for (const u of [...c])
+        if (!r.has(u)) {
+          r.add(u);
+          try {
+            u(n);
+          } catch (l) {
+            console.error(l);
+            continue;
+          }
+        }
+    };
+    f(d);
+    for (const c of a) f(c);
+  }
+  /**
+   * Emits a payload that is only built if somebody is listening.
+   *
+   * @param channel - Channel to emit on.
+   * @param type - Concrete event type.
+   * @param make - Builds the payload. Called at most once, and only when a handler matched.
+   *
+   * @remarks
+   * Same matching as {@link LooseEventBus.emit}; the difference is *when* the payload exists.
+   * The store's change notification carries the old and new value at a path, and reading those
+   * means walking the state tree twice per path. Doing that eagerly meant a slice nobody had
+   * subscribed to paid the full cost of describing changes to an audience of nobody — the
+   * matching work was already being done to discover there were no handlers.
+   *
+   * @public
+   */
+  emitWith(e, t, n) {
+    const s = String(t), i = this.normalizeTypeKey(s), d = this.handlers.get(e)?.get(i) ?? [], a = this.matchingPatternHandlers(e, s);
+    if (d.length === 0 && a.length === 0) return;
+    const r = n(), f = /* @__PURE__ */ new Set(), c = (u) => {
+      for (const l of [...u])
+        if (!f.has(l)) {
+          f.add(l);
           try {
-            u(r);
-          } catch (p) {
-            console.error(p);
+            l(r);
+          } catch (y) {
+            console.error(y);
             continue;
           }
         }
     };
-    h(c);
-    for (const l of o) h(l);
+    c(d);
+    for (const u of a) c(u);
   }
   /**
    * Determines if a string is a **pattern** (contains `*`).
@@ -308,42 +367,100 @@ class k {
     return this.normalizeTypeKey(e).split(".").filter(Boolean);
   }
   /**
-   * Pattern matcher over dot-separated segments.
+   * Files a pattern under the first segment that could select it.
+   * @internal
+   */
+  indexPattern(e, t) {
+    let n = this.patternIndex.get(e);
+    n === void 0 && (n = { byHead: /* @__PURE__ */ new Map(), anyHead: [] }, this.patternIndex.set(e, n));
+    const s = this.splitPath(t), i = { pattern: t, segments: s }, d = s[0];
+    if (d === void 0 || d === "*" || d === "**") {
+      n.anyHead.push(i);
+      return;
+    }
+    const a = n.byHead.get(d);
+    a === void 0 ? n.byHead.set(d, [i]) : a.push(i);
+  }
+  /**
+   * Removes a pattern from the index. Paired with {@link LooseEventBus.offPattern}.
+   * @internal
+   */
+  unindexPattern(e, t) {
+    const n = this.patternIndex.get(e);
+    if (n === void 0) return;
+    const s = this.splitPath(t)[0], i = s === void 0 || s === "*" || s === "**" ? n.anyHead : n.byHead.get(s);
+    if (i === void 0) return;
+    const d = i.findIndex((a) => a.pattern === t);
+    d !== -1 && i.splice(d, 1), i.length === 0 && i !== n.anyHead && s !== void 0 && n.byHead.delete(s);
+  }
+  /**
+   * The handler lists of every pattern matching this subject.
+   *
+   * @remarks
+   * Shared by `emit` and `emitWith` so the two cannot drift on what "matching" means — which
+   * they could, being two copies of the same walk before.
+   *
+   * The subject is split once here rather than once per pattern tested.
+   *
+   * @internal
+   */
+  matchingPatternHandlers(e, t) {
+    const n = this.patternHandlers.get(e), s = this.patternIndex.get(e);
+    if (n === void 0 || n.size === 0 || s === void 0) return [];
+    const i = this.splitPath(t), d = [], a = (f) => {
+      for (const c of f) {
+        if (!this.matchSegments(c.segments, i)) continue;
+        const u = n.get(c.pattern);
+        u !== void 0 && d.push(u);
+      }
+    }, r = i[0];
+    if (r !== void 0) {
+      const f = s.byHead.get(r);
+      f !== void 0 && a(f);
+    }
+    return a(s.anyHead), d;
+  }
+  /**
+   * Pattern matcher over dot-separated segments, which arrive already split.
    *
    * Rules:
    * - **literal**: exact match.
    * - `*`   : matches exactly **one** segment.
    * - `**`  : matches **zero or more** remaining segments (including empty).
    *
-   * @param pattern - Pattern (may include `*`/`**`).
-   * @param path - Subject event type key to test.
-   * @returns `true` if the pattern matches the path; otherwise `false`.
+   * @remarks
+   * Takes segments rather than strings so delivery can split each pattern once at registration
+   * and the subject once per emit, instead of both once per test. Re-splitting per test was most
+   * of what made wildcard delivery expensive: a thousand patterns meant two thousand string
+   * splits to deliver one event.
+   *
+   * @param pSegs - Pattern segments (may include `*`/`**`).
+   * @param sSegs - Subject segments to test.
+   * @returns `true` if the pattern matches; otherwise `false`.
    *
    * @example
    * ```ts
-   * matchPattern('a.*', 'a.b')        // true
-   * matchPattern('a.*', 'a.b.c')      // false
-   * matchPattern('a.**', 'a')         // true
-   * matchPattern('a.**', 'a.b.c')     // true
-   * matchPattern('**.end', 'x.y.end') // true
+   * matchSegments(['a', '*'], ['a', 'b'])           // true
+   * matchSegments(['a', '*'], ['a', 'b', 'c'])      // false
+   * matchSegments(['a', '**'], ['a'])               // true
+   * matchSegments(['**', 'end'], ['x', 'y', 'end']) // true
    * ```
    *
    * @internal
    */
-  matchPattern(e, t) {
-    const r = this.splitPath(e), n = this.splitPath(t);
-    let s = 0, c = 0, i = -1, o = 0;
-    for (; c < n.length; )
-      if (s < r.length && (r[s] === "*" || r[s] === n[c]))
-        s++, c++;
-      else if (s < r.length && r[s] === "**")
-        i = s, o = c, s++;
+  matchSegments(e, t) {
+    let n = 0, s = 0, i = -1, d = 0;
+    for (; s < t.length; )
+      if (n < e.length && (e[n] === "*" || e[n] === t[s]))
+        n++, s++;
+      else if (n < e.length && e[n] === "**")
+        i = n, d = s, n++;
       else if (i !== -1)
-        s = i + 1, c = ++o;
+        n = i + 1, s = ++d;
       else
         return !1;
-    for (; s < r.length && r[s] === "**"; ) s++;
-    return s === r.length;
+    for (; n < e.length && e[n] === "**"; ) n++;
+    return n === e.length;
   }
   /**
    * Removes **all** listeners (exact and pattern). Useful for tests/HMR teardown.
@@ -356,7 +473,7 @@ class k {
    * @public
    */
   clear() {
-    this.handlers.clear(), this.patternHandlers.clear();
+    this.handlers.clear(), this.patternHandlers.clear(), this.patternIndex.clear();
   }
   /**
    * Returns a snapshot of all registered subscriptions for DevTools introspection.
@@ -368,16 +485,16 @@ class k {
    */
   __introspect() {
     const e = [];
-    for (const [t, r] of this.handlers)
-      for (const [n, s] of r)
-        s.length > 0 && e.push({ channel: t, type: n, count: s.length });
-    for (const [t, r] of this.patternHandlers)
-      for (const [n, s] of r)
-        s.length > 0 && e.push({ channel: t, type: n, count: s.length });
+    for (const [t, n] of this.handlers)
+      for (const [s, i] of n)
+        i.length > 0 && e.push({ channel: t, type: s, count: i.length });
+    for (const [t, n] of this.patternHandlers)
+      for (const [s, i] of n)
+        i.length > 0 && e.push({ channel: t, type: s, count: i.length });
     return e;
   }
 }
-class _ {
+class K {
   /**
    * Creates a new {@link Reducer} from a pure reducer function.
    *
@@ -398,7 +515,7 @@ class _ {
      * The underlying pure reducer function.
      * @internal
      */
-    d(this, "_reduce");
+    p(this, "_reduce");
     this._reduce = e;
   }
   /**
@@ -419,68 +536,128 @@ class _ {
     return this._reduce(e, t);
   }
 }
-function g(a, e, t = "", r = /* @__PURE__ */ new Map()) {
-  if (a === e) return [];
-  if (typeof a != "object" || typeof e != "object" || a === null || e === null)
-    return typeof a == "number" && Number.isNaN(a) && Number.isNaN(e) ? [] : [t];
-  if (a instanceof Date && e instanceof Date)
-    return a.getTime() === e.getTime() ? [] : [t];
-  if (a instanceof RegExp && e instanceof RegExp)
-    return a.source === e.source && e.flags === a.flags ? [] : [t];
-  const n = a, s = e, c = r.get(n);
-  if (c?.has(s)) return [];
-  const i = c ?? /* @__PURE__ */ new Set();
-  i.add(s), c || r.set(n, i);
+const P = /* @__PURE__ */ new Set();
+function M(o, e) {
+  const t = o ? `${o}.${e}` : e;
+  P.has(t) || (P.add(t), console.warn(
+    `[yoltra] State key "${e}"${o ? ` under "${o}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
+  ));
+}
+function O(o, e, t = "", n = /* @__PURE__ */ new Map()) {
+  const s = [];
+  return v(o, e, t, n, s), s;
+}
+function v(o, e, t, n, s) {
+  if (o === e) return;
+  if (typeof o != "object" || typeof e != "object" || o === null || e === null) {
+    if (typeof o == "number" && Number.isNaN(o) && Number.isNaN(e))
+      return;
+    s.push(t);
+    return;
+  }
+  if (o instanceof Date && e instanceof Date) {
+    o.getTime() !== e.getTime() && s.push(t);
+    return;
+  }
+  if (o instanceof RegExp && e instanceof RegExp) {
+    (o.source !== e.source || e.flags !== o.flags) && s.push(t);
+    return;
+  }
+  if (o instanceof Map || e instanceof Map) {
+    s.push(t);
+    return;
+  }
+  if (o instanceof Set || e instanceof Set) {
+    s.push(t);
+    return;
+  }
+  const i = o, d = e, a = n.get(i);
+  if (a?.has(d)) return;
+  const r = a ?? /* @__PURE__ */ new Set();
+  r.add(d), a || n.set(i, r);
   try {
-    const o = Array.isArray(a), f = Array.isArray(e);
-    if (o !== f) return [t];
-    const h = [];
-    if (o) {
-      const u = a, p = e;
-      if (u.length !== p.length) return [t];
-      for (let y = 0; y < u.length; y++) {
-        const m = t ? `${t}.${y}` : `${y}`;
-        h.push(...g(u[y], p[y], m, r));
-      }
-      return h.filter(Boolean);
+    const f = Array.isArray(o), c = Array.isArray(e);
+    if (f !== c) {
+      s.push(t);
+      return;
     }
-    const l = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(e)]);
-    for (const u of l) {
-      const p = t ? `${t}.${u}` : u, y = Object.prototype.hasOwnProperty.call(a, u), m = Object.prototype.hasOwnProperty.call(e, u);
-      if (!y || !m) {
-        h.push(p);
+    if (f) {
+      const h = o, m = e;
+      h.length !== m.length && t && s.push(t);
+      const g = Math.min(h.length, m.length);
+      for (let w = 0; w < g; w++)
+        h[w] !== m[w] && v(h[w], m[w], t ? `${t}.${w}` : `${w}`, n, s);
+      for (let w = g; w < Math.max(h.length, m.length); w++)
+        s.push(t ? `${t}.${w}` : `${w}`);
+      return;
+    }
+    const u = Object.keys(o), l = Object.keys(e);
+    if (u.length === 0 && l.length === 0) {
+      s.push(t);
+      return;
+    }
+    let y = u.length === l.length;
+    if (y) {
+      for (let h = 0; h < l.length; h++)
+        if (!Object.prototype.hasOwnProperty.call(o, l[h])) {
+          y = !1;
+          break;
+        }
+    }
+    if (y) {
+      for (const h of l)
+        o[h] !== e[h] && (process.env.NODE_ENV !== "production" && h.includes(".") && M(t, h), v(o[h], e[h], t ? `${t}.${h}` : h, n, s));
+      return;
+    }
+    for (const h of l) {
+      const m = Object.prototype.hasOwnProperty.call(o, h);
+      if (m && o[h] === e[h]) continue;
+      process.env.NODE_ENV !== "production" && h.includes(".") && M(t, h);
+      const g = t ? `${t}.${h}` : h;
+      if (!m) {
+        s.push(g);
         continue;
       }
-      h.push(...g(a[u], e[u], p, r));
+      v(o[h], e[h], g, n, s);
     }
-    return h.filter(Boolean);
+    for (const h of u)
+      Object.prototype.hasOwnProperty.call(e, h) || (process.env.NODE_ENV !== "production" && h.includes(".") && M(t, h), s.push(t ? `${t}.${h}` : h));
   } finally {
-    i.delete(s), i.size === 0 && r.delete(n);
+    r.delete(d), r.size === 0 && n.delete(i);
+  }
+}
+function S(o, e = /* @__PURE__ */ new WeakSet(), t) {
+  if (o === null || typeof o != "object" || e.has(o) || (t !== void 0 && o === t.watch && t.onFound(), Object.isFrozen(o))) return o;
+  if (e.add(o), Array.isArray(o)) {
+    const n = o;
+    for (let s = 0; s < n.length; s++)
+      n[s] = S(n[s], e, t);
+    return Object.freeze(n);
   }
+  for (const n of Object.getOwnPropertyNames(o)) {
+    const s = Object.getOwnPropertyDescriptor(o, n);
+    !s || !("value" in s) || (o[n] = S(o[n], e, t));
+  }
+  for (const n of Object.getOwnPropertySymbols(o)) {
+    const s = Object.getOwnPropertyDescriptor(o, n);
+    !s || !("value" in s) || (o[n] = S(o[n], e, t));
+  }
+  return Object.freeze(o);
 }
-function E(a, e = /* @__PURE__ */ new WeakSet()) {
-  if (a === null || typeof a != "object" || e.has(a) || Object.isFrozen(a)) return a;
-  if (e.add(a), Array.isArray(a)) {
-    const t = a;
-    for (let r = 0; r < t.length; r++)
-      t[r] = E(t[r], e);
-    return Object.freeze(t);
-  }
-  for (const t of Object.getOwnPropertyNames(a)) {
-    const r = Object.getOwnPropertyDescriptor(a, t);
-    !r || !("value" in r) || (a[t] = E(a[t], e));
-  }
-  for (const t of Object.getOwnPropertySymbols(a)) {
-    const r = Object.getOwnPropertyDescriptor(a, t);
-    !r || !("value" in r) || (a[t] = E(a[t], e));
-  }
-  return Object.freeze(a);
+function W(o, e) {
+  try {
+    return structuredClone(e);
+  } catch (t) {
+    throw new Error(
+      `[yoltra] Initial state for slice "${String(o)}" could not be copied: ${t instanceof Error ? t.message : String(t)}. State must be structured-cloneable — functions, class instances and DOM nodes are not. Keep behaviour out of state and store plain data.`
+    );
+  }
 }
-function b(a) {
-  return process.env.NODE_ENV === "production" ? a : E(a);
+function k(o, e) {
+  return process.env.NODE_ENV === "production" ? o : S(o, /* @__PURE__ */ new WeakSet(), e);
 }
-const w = 100, S = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
-class v {
+const x = 100, z = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+class $ {
   /**
    * Creates a store from a {@link StoreSpec}.
    *
@@ -494,7 +671,7 @@ class v {
      *
      * @public
      */
-    d(this, "name");
+    p(this, "name");
     /**
      * Registered middleware pipeline (run **before** reducers).
      * Stores either raw functions (legacy) or MiddlewareSpec objects.
@@ -502,45 +679,45 @@ class v {
      *
      * @internal
      */
-    d(this, "middleware");
+    p(this, "middleware");
     /**
      * Installed slice reducers keyed by slice name.
      *
      * @internal
      */
-    d(this, "reducers");
+    p(this, "reducers");
     /**
      * Current immutable snapshot of the store state.
      * This reference changes whenever any slice changes (shallow immutability).
      *
      * @internal
      */
-    d(this, "state");
+    p(this, "state");
     /**
      * Bus for reducer wiring (emit by `(channel, type)`).
      *
      * @internal
      */
-    d(this, "reducerBus");
+    p(this, "reducerBus");
     /**
      * Bus for **granular** connector events (emit by **dotted path** inside a slice).
      *
      * @internal
      */
-    d(this, "connectorBus");
+    p(this, "connectorBus");
     /**
      * Coarse-grained listeners (called once per committed event, only if state changed).
      *
      * @internal
      */
-    d(this, "listeners", /* @__PURE__ */ new Set());
+    p(this, "listeners", /* @__PURE__ */ new Set());
     /**
      * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
-     * Used for effects with explicit `keys` or legacy `events` targeting.
+     * Used for effects with explicit `keys` targeting.
      *
      * @internal
      */
-    d(this, "effects", /* @__PURE__ */ new Map());
+    p(this, "effects", /* @__PURE__ */ new Map());
     /**
      * Pattern-based effects that need runtime matching.
      * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
@@ -548,34 +725,34 @@ class v {
      *
      * @internal
      */
-    d(this, "patternEffects", /* @__PURE__ */ new Set());
+    p(this, "patternEffects", /* @__PURE__ */ new Set());
     /**
      * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
      * Notified after reducers, before effects, for events that passed middleware.
      *
      * @internal
      */
-    d(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
+    p(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
      * Notified when middleware rejects an event.
      *
      * @internal
      */
-    d(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
+    p(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
      * Notified for both committed and uncommitted events with phase parameter.
      *
      * @internal
      */
-    d(this, "allEventSubscribers", /* @__PURE__ */ new Map());
+    p(this, "allEventSubscribers", /* @__PURE__ */ new Map());
     /**
      * Track reducerBus unsubs per slice for HMR/register/unregister.
      *
      * @internal
      */
-    d(this, "sliceUnsubs", /* @__PURE__ */ new Map());
+    p(this, "sliceUnsubs", /* @__PURE__ */ new Map());
     /**
      * Pattern-based reducers that need runtime matching.
      * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
@@ -583,39 +760,60 @@ class v {
      *
      * @internal
      */
-    d(this, "patternReducers", /* @__PURE__ */ new Map());
+    p(this, "patternReducers", /* @__PURE__ */ new Map());
     /**
      * Whether `__replayEvents()` is allowed.
      * Set from `spec.devtools.allowReplay`.
      *
      * @internal
      */
-    d(this, "replayEnabled");
+    p(this, "replayEnabled");
+    /**
+     * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
+     * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
+     *
+     * @internal
+     */
+    p(this, "idFactory");
     /**
      * Optional hook invoked when an effect throws/rejects. See
      * {@link StoreSpec.onEffectError}. `await emit()` never rejects on effect
      * failure — this is how callers observe effect errors.
      */
-    d(this, "onEffectError");
+    p(this, "onEffectError");
+    /**
+     * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
+     * failing slice is isolated rather than the event being rolled back, so this is the only
+     * signal that a reducer misbehaved.
+     */
+    p(this, "onReducerError");
+    /**
+     * `slice:channel:type` combinations already warned about for payload aliasing.
+     *
+     * @remarks
+     * Development-only diagnostics have to stay quiet enough to be read. One warning names the
+     * pattern; repeating it once per event would bury it.
+     */
+    p(this, "warnedPayloadAliases", /* @__PURE__ */ new Set());
     /**
      * Pending events awaiting the **synchronous** reduce phase (middleware +
      * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
      *
      * @internal
      */
-    d(this, "reduceQueue", []);
+    p(this, "reduceQueue", []);
     /**
      * Re-entrancy guard for the synchronous reduce phase.
      *
      * @internal
      */
-    d(this, "isReducing", !1);
+    p(this, "isReducing", !1);
     /**
      * Registered instrumentation observers (DevTools seam). See {@link instrument}.
      *
      * @internal
      */
-    d(this, "instrumentObservers", /* @__PURE__ */ new Set());
+    p(this, "instrumentObservers", /* @__PURE__ */ new Set());
     /**
      * Scratch array collecting slice-prefixed changed leaf paths during an
      * instrumented reduce. Set by {@link drainReduce} while observers are active;
@@ -623,14 +821,14 @@ class v {
      *
      * @internal
      */
-    d(this, "changedPathSink", null);
+    p(this, "changedPathSink", null);
     /**
      * Count of effect tasks currently in flight; surfaced as queue depth by
      * {@link __devtoolsIntrospect}.
      *
      * @internal
      */
-    d(this, "inFlightEffects", 0);
+    p(this, "inFlightEffects", 0);
     /**
      * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
      *
@@ -647,7 +845,7 @@ class v {
      *
      * @internal
      */
-    d(this, "processedEvents", /* @__PURE__ */ new Map());
+    p(this, "processedEvents", /* @__PURE__ */ new Map());
     /**
      * Lifetime count of events suppressed by the deduplication cache.
      * Exposed via {@link __devtoolsIntrospect} so the DevTools agent can
@@ -655,7 +853,7 @@ class v {
      *
      * @internal
      */
-    d(this, "dedupCount", 0);
+    p(this, "dedupCount", 0);
     /**
      * Store-owned metadata for registered effects, keyed by the effect function.
      * Kept **off** the caller's function object: mutating a user-owned function
@@ -664,23 +862,23 @@ class v {
      *
      * @internal
      */
-    d(this, "effectMeta", /* @__PURE__ */ new WeakMap());
+    p(this, "effectMeta", /* @__PURE__ */ new WeakMap());
     /**
      * Configuration for event deduplication.
      * @internal
      */
-    d(this, "dedupConfig");
+    p(this, "dedupConfig");
     /**
      * Timer for periodic cleanup of processed events.
      *
      * @internal
      */
-    d(this, "eventCleanupTimer", null);
-    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new O(), this.connectorBus = new k(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.onEffectError = e.onEffectError, this.dedupConfig = {
+    p(this, "eventCleanupTimer", null);
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new B(), this.connectorBus = new H(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.idFactory = e.idFactory ?? (() => crypto.randomUUID()), this.onEffectError = e.onEffectError, this.onReducerError = e.onReducerError, this.dedupConfig = {
       windowMs: e.dedupWindowMs ?? 0,
       maxCacheSize: 1e3
-    }, Object.entries(e.reducer).forEach(([t, r]) => {
-      this.mountSlice(t, r, { 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);
@@ -713,17 +911,17 @@ class v {
    *
    * @internal
    */
-  fingerprint(e, t, r) {
-    const n = `${e}::${t}`;
+  fingerprint(e, t, n) {
+    const s = `${e}::${t}`;
     try {
-      if (r == null)
-        return `${n}::null`;
-      if (typeof r != "object")
-        return `${n}::${String(r)}`;
-      const s = JSON.stringify(r);
-      return `${n}::${s}`;
+      if (n == null)
+        return `${s}::null`;
+      if (typeof n != "object")
+        return `${s}::${String(n)}`;
+      const i = JSON.stringify(n);
+      return `${s}::${i}`;
     } catch {
-      return `${n}::${Date.now()}::${Math.random()}`;
+      return `${s}::${Date.now()}::${Math.random()}`;
     }
   }
   /**
@@ -736,8 +934,8 @@ class v {
    * @internal
    */
   shouldDedupe(e, t) {
-    const r = Date.now(), n = this.processedEvents.get(e);
-    return n !== void 0 && r - n < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, r), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(r), !1);
+    const n = Date.now(), s = this.processedEvents.get(e);
+    return s !== void 0 && n - s < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, n), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(n), !1);
   }
   /**
    * Starts the periodic prune interval if it isn't already running. Called when
@@ -759,9 +957,9 @@ class v {
    * @internal
    */
   pruneProcessedEvents(e) {
-    const t = Math.max(this.dedupConfig.windowMs, w), r = e - t * 2;
-    for (const [n, s] of this.processedEvents)
-      s < r && this.processedEvents.delete(n);
+    const t = Math.max(this.dedupConfig.windowMs, x), n = e - t * 2;
+    for (const [s, i] of this.processedEvents)
+      i < n && this.processedEvents.delete(s);
     this.processedEvents.size === 0 && this.eventCleanupTimer !== null && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null);
   }
   /**
@@ -782,7 +980,7 @@ class v {
    */
   matchesWhen(e, t) {
     return !e || "any" in e && e.any === !0 ? !0 : "keys" in e ? e.keys.some(
-      ([r, n]) => t.channel === r && t.type === n
+      ([n, s]) => t.channel === n && t.type === s
     ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
   }
   /**
@@ -818,20 +1016,20 @@ class v {
    * @internal
    */
   async notifyEffects(e) {
-    const t = `${String(e.channel)}::${String(e.type)}`, r = this.effects.get(t);
-    if (r && r.size > 0)
-      for (const n of [...r])
+    const t = `${String(e.channel)}::${String(e.type)}`, n = this.effects.get(t);
+    if (n && n.size > 0)
+      for (const s of [...n])
         try {
-          await n(e, this.getState, this.emit);
-        } catch (s) {
-          console.error("Effect error:", s), this.onEffectError?.(s, e);
+          await s(e, this.getState, this.emit);
+        } catch (i) {
+          console.error("Effect error:", i), this.onEffectError?.(i, e);
         }
-    for (const { effect: n, when: s } of this.patternEffects)
-      if (this.matchesWhen(s, e))
+    for (const { effect: s, when: i } of this.patternEffects)
+      if (this.matchesWhen(i, e))
         try {
-          await n(e, this.getState, this.emit);
-        } catch (c) {
-          console.error("Effect error:", c), this.onEffectError?.(c, e);
+          await s(e, this.getState, this.emit);
+        } catch (d) {
+          console.error("Effect error:", d), this.onEffectError?.(d, e);
         }
   }
   /**
@@ -845,12 +1043,12 @@ class v {
    * @internal
    */
   notifyEventSubscribers(e, t) {
-    const r = `${String(e.channel)}::${String(e.type)}`, s = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(r);
-    if (s?.size)
-      for (const i of [...s]) this.invokeEventSubscriber(i, e, t);
-    const c = this.allEventSubscribers.get(r);
-    if (c?.size)
-      for (const i of [...c]) this.invokeEventSubscriber(i, e, t);
+    const n = `${String(e.channel)}::${String(e.type)}`, i = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(n);
+    if (i?.size)
+      for (const a of [...i]) this.invokeEventSubscriber(a, e, t);
+    const d = this.allEventSubscribers.get(n);
+    if (d?.size)
+      for (const a of [...d]) this.invokeEventSubscriber(a, e, t);
   }
   /**
    * Invokes a single event-subscription handler **fire-and-forget**: synchronous
@@ -859,12 +1057,12 @@ class v {
    *
    * @internal
    */
-  invokeEventSubscriber(e, t, r) {
+  invokeEventSubscriber(e, t, n) {
     try {
-      const n = e(t, this.getState, this.emit, r);
-      n && typeof n.then == "function" && n.catch((s) => console.error("Event subscription error:", s));
-    } catch (n) {
-      console.error("Event subscription error:", n);
+      const s = e(t, this.getState, this.emit, n);
+      s && typeof s.then == "function" && s.catch((i) => console.error("Event subscription error:", i));
+    } catch (s) {
+      console.error("Event subscription error:", s);
     }
   }
   /**
@@ -883,22 +1081,62 @@ class v {
    *
    * @internal
    */
-  forwardEvent(e, t) {
-    const r = this.state[e], n = this.reducers[e].reduce(r, t);
-    if (r === n) return !1;
-    const s = g(r, n).filter(Boolean);
-    if (s.length === 0) return !1;
-    const c = b(n);
-    if (this.state = { ...this.state, [e]: c }, this.changedPathSink)
-      for (const o of s)
-        this.changedPathSink.push(o ? `${e}.${o}` : e);
-    const i = /* @__PURE__ */ new Set();
-    for (const o of s)
-      for (const f of v.buildAncestorPaths(o)) i.add(f);
-    for (const o of i) {
-      const f = this.getAtPath(r, o), h = this.getAtPath(c, o);
-      this.connectorBus.emit(e, o, { oldValue: f, newValue: h, path: o });
+  /**
+   * Reduces one slice and contains any error it raises.
+   *
+   * @returns `true` when the slice changed.
+   *
+   * @remarks
+   * The single funnel both dispatch paths go through, which is the point. Keyed reducers run
+   * through `reducerBus`, whose handler loop caught and logged; pattern reducers were called
+   * straight from the drain, so their errors escaped to the caller instead. The same bug in the
+   * same reducer therefore produced two different outcomes depending on how the slice happened
+   * to be targeted — a keyed reducer's throw let the event commit and its effects run, while a
+   * pattern reducer's throw aborted the commit and notified nobody, not even the uncommitted
+   * subscribers a veto would have reached.
+   *
+   * The semantics are now the same either way: **the failing slice is isolated.** Its state is
+   * unchanged, every other slice still reduces, and the event still commits if anything else
+   * changed. Rolling the whole event back would be tidier in principle, but fine-grained
+   * subscribers are notified inside `forwardEvent` as each slice commits, so an event that
+   * reverted afterwards would have already told components about a value that no longer exists.
+   * Isolation keeps every notification truthful.
+   *
+   * @internal
+   */
+  forwardEventGuarded(e, t) {
+    try {
+      return this.forwardEvent(e, t);
+    } catch (n) {
+      return console.error(`Reducer error in slice "${e}":`, n), this.onReducerError?.(n, t, e), !1;
     }
+  }
+  forwardEvent(e, t) {
+    const n = this.state[e], s = this.reducers[e].reduce(n, t);
+    if (n === s) return !1;
+    const i = O(n, s).filter(Boolean);
+    if (i.length === 0) return !1;
+    const d = t.payload, a = process.env.NODE_ENV !== "production" && d !== null && typeof d == "object" ? {
+      watch: d,
+      onFound: () => {
+        const c = `${e}:${t.channel}:${t.type}`;
+        this.warnedPayloadAliases.has(c) || (this.warnedPayloadAliases.add(c), console.warn(
+          `[yoltra] Slice "${e}" stored the payload of "${t.channel}/${t.type}" by reference. It is now frozen along with the rest of the state, so the emitter mutating it later will throw in development and silently corrupt state in production. Copy the payload in the reducer instead.`
+        ));
+      }
+    } : void 0, r = k(s, a);
+    if (this.state = { ...this.state, [e]: r }, this.changedPathSink)
+      for (const c of i)
+        this.changedPathSink.push(c ? `${e}.${c}` : e);
+    const f = /* @__PURE__ */ new Set();
+    for (const c of i)
+      for (const u of $.buildAncestorPaths(c)) f.add(u);
+    for (const c of f)
+      this.connectorBus.emitWith(e, c, () => ({
+        oldValue: this.getAtPath(n, c),
+        newValue: this.getAtPath(r, c),
+        path: c
+      }));
     return !0;
   }
   /**
@@ -912,65 +1150,65 @@ class v {
    * @public
    */
   __devtoolsIntrospect() {
-    const e = Object.keys(this.reducers).map((i) => {
-      const o = this.patternReducers.get(i);
-      return { name: i, when: o };
+    const e = Object.keys(this.reducers).map((a) => {
+      const r = this.patternReducers.get(a);
+      return { name: a, when: r };
     }), t = [];
-    for (const [i, o] of this.effects) {
-      if (o.size === 0) continue;
-      const [f, h] = i.split("::");
-      for (const l of o) {
-        const u = this.effectMeta.get(l);
-        t.push({ channel: f, type: h, name: u?.name, description: u?.description });
+    for (const [a, r] of this.effects) {
+      if (r.size === 0) continue;
+      const [f, c] = a.split("::");
+      for (const u of r) {
+        const l = this.effectMeta.get(u);
+        t.push({ channel: f, type: c, name: l?.name, description: l?.description });
       }
     }
-    for (const i of this.patternEffects) {
-      const o = this.effectMeta.get(i.effect);
+    for (const a of this.patternEffects) {
+      const r = this.effectMeta.get(a.effect);
       t.push({
         channel: "*",
         type: "*",
-        name: o?.name,
-        description: o?.description
+        name: r?.name,
+        description: r?.description
       });
     }
-    const r = [];
-    for (const i of this.middleware)
-      typeof i == "function" ? r.push({ name: i.name || void 0 }) : r.push({
-        name: i.meta?.name,
-        description: i.meta?.description,
-        when: i.when
-      });
     const n = [];
-    for (const i of this.connectorBus.__introspect())
-      for (let o = 0; o < i.count; o++)
-        n.push({ reducer: i.channel, property: i.type });
+    for (const a of this.middleware)
+      typeof a == "function" ? n.push({ name: a.name || void 0 }) : n.push({
+        name: a.meta?.name,
+        description: a.meta?.description,
+        when: a.when
+      });
     const s = [];
-    for (const [i, o] of this.committedEventSubscribers) {
-      if (o.size === 0) continue;
-      const [f, h] = i.split("::");
-      for (let l = 0; l < o.size; l++)
-        s.push({ channel: f, type: h, phase: "committed" });
+    for (const a of this.connectorBus.__introspect())
+      for (let r = 0; r < a.count; r++)
+        s.push({ reducer: a.channel, property: a.type });
+    const i = [];
+    for (const [a, r] of this.committedEventSubscribers) {
+      if (r.size === 0) continue;
+      const [f, c] = a.split("::");
+      for (let u = 0; u < r.size; u++)
+        i.push({ channel: f, type: c, phase: "committed" });
     }
-    for (const [i, o] of this.uncommittedEventSubscribers) {
-      if (o.size === 0) continue;
-      const [f, h] = i.split("::");
-      for (let l = 0; l < o.size; l++)
-        s.push({ channel: f, type: h, phase: "uncommitted" });
+    for (const [a, r] of this.uncommittedEventSubscribers) {
+      if (r.size === 0) continue;
+      const [f, c] = a.split("::");
+      for (let u = 0; u < r.size; u++)
+        i.push({ channel: f, type: c, phase: "uncommitted" });
     }
-    for (const [i, o] of this.allEventSubscribers) {
-      if (o.size === 0) continue;
-      const [f, h] = i.split("::");
-      for (let l = 0; l < o.size; l++)
-        s.push({ channel: f, type: h, phase: "all" });
+    for (const [a, r] of this.allEventSubscribers) {
+      if (r.size === 0) continue;
+      const [f, c] = a.split("::");
+      for (let u = 0; u < r.size; u++)
+        i.push({ channel: f, type: c, phase: "all" });
     }
-    const c = this.listeners.size;
+    const d = this.listeners.size;
     return {
       reducers: e,
       effects: t,
-      middleware: r,
-      atomic: n,
-      event: s,
-      coarse: c,
+      middleware: n,
+      atomic: s,
+      event: i,
+      coarse: d,
       dedupHits: this.dedupCount,
       queueDepth: this.reduceQueue.length + this.inFlightEffects
     };
@@ -991,36 +1229,34 @@ class v {
    * @internal
    */
   __applyExternalState(e) {
-    if (!this.replayEnabled) {
-      console.warn(
+    if (!this.replayEnabled)
+      throw new Error(
         "[yoltra] External state apply (time-travel) is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
-      return;
-    }
-    const t = this.state, r = e, n = { ...this.state };
-    let s = !1;
-    Object.keys(this.reducers).forEach((c) => {
-      const i = t?.[c], o = r?.[c];
-      if (o === void 0) {
+    const t = this.state, n = e, s = { ...this.state };
+    let i = !1;
+    Object.keys(this.reducers).forEach((d) => {
+      const a = t?.[d], r = n?.[d];
+      if (r === void 0) {
         process.env.NODE_ENV !== "production" && console.warn(
           `[yoltra] External state is missing slice "${String(
-            c
+            d
           )}"; retaining its current value. Time-travel snapshots should contain all slices.`
         );
         return;
       }
-      if (i === o) return;
-      const f = b(o);
-      n[c] = f, s = !0;
-      const h = g(i, o).filter(Boolean);
-      if (h.length === 0) return;
-      const l = /* @__PURE__ */ new Set();
-      for (const u of h) for (const p of v.buildAncestorPaths(u)) l.add(p);
-      for (const u of l) {
-        const p = this.getAtPath(i, u), y = this.getAtPath(f, u);
-        this.connectorBus.emit(c, u, { oldValue: p, newValue: y, path: u });
+      if (a === r) return;
+      const f = k(r);
+      s[d] = f, i = !0;
+      const c = O(a, r).filter(Boolean);
+      if (c.length === 0) return;
+      const u = /* @__PURE__ */ new Set();
+      for (const l of c) for (const y of $.buildAncestorPaths(l)) u.add(y);
+      for (const l of u) {
+        const y = this.getAtPath(a, l), h = this.getAtPath(f, l);
+        this.connectorBus.emit(d, l, { oldValue: y, newValue: h, path: l });
       }
-    }), s && (this.state = n), s && this.listeners.forEach((c) => c());
+    }), i && (this.state = s), i && this.listeners.forEach((d) => d());
   }
   /**
    * Replays a sequence of events from a snapshot through reducers and event
@@ -1040,13 +1276,13 @@ class v {
         "[yoltra] Event replay is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
       );
     this.__applyExternalState(e);
-    for (const r of t) {
-      const n = r, s = this.state;
-      this.reducerBus.emit(n.channel, n.type, n.payload);
-      for (const [o, f] of this.patternReducers)
-        this.matchesWhen(f, n) && this.forwardEvent(o, n);
-      const c = this.state, i = s !== c;
-      this.notifyEventSubscribers(n, "committed"), i && this.listeners.forEach((o) => o());
+    for (const n of t) {
+      const s = n, i = this.state;
+      this.reducerBus.emit(s.channel, s.type, s.payload, s);
+      for (const [r, f] of this.patternReducers)
+        this.matchesWhen(f, s) && this.forwardEventGuarded(r, s);
+      const d = this.state, a = i !== d;
+      this.notifyEventSubscribers(s, "committed"), a && this.listeners.forEach((r) => r());
     }
   }
   /**
@@ -1092,24 +1328,25 @@ class v {
    *
    * @public
    */
-  async emit(e, t, r, n) {
-    const s = n?.dedupKey, c = this.dedupConfig.windowMs;
-    if (c > 0 || s !== void 0) {
-      const h = s !== void 0 && c <= 0 ? w : c, l = s !== void 0 ? `${e}::${t}::#${s}` : this.fingerprint(e, t, r);
-      if (this.shouldDedupe(l, h))
+  async emit(e, t, n, s) {
+    const i = s?.dedupKey, d = this.dedupConfig.windowMs;
+    if (s?.skipDedup !== !0 && (d > 0 || i !== void 0)) {
+      const c = i !== void 0 && d <= 0 ? x : d, u = i !== void 0 ? `${e}::${t}::#${i}` : this.fingerprint(e, t, n);
+      if (this.shouldDedupe(u, c))
         return;
     }
-    const i = crypto.randomUUID();
-    let o;
-    const f = new Promise((h) => {
-      o = h;
+    const a = s?.id ?? this.idFactory();
+    let r;
+    const f = new Promise((c) => {
+      r = c;
     });
     return this.reduceQueue.push({
       channel: e,
       type: t,
-      payload: r,
-      id: i,
-      resolve: o
+      payload: n,
+      id: a,
+      meta: s?.meta,
+      resolve: r
     }), this.drainReduce(), f;
   }
   /**
@@ -1127,24 +1364,30 @@ class v {
       this.isReducing = !0;
       try {
         for (; this.reduceQueue.length > 0; ) {
-          const { channel: e, type: t, payload: r, id: n, resolve: s } = this.reduceQueue.shift(), c = { channel: e, type: t, payload: r, id: n }, i = this.instrumentObservers.size > 0, o = i ? this.state : void 0, f = [];
-          i && (this.changedPathSink = f);
-          const h = i ? S() : 0;
+          const { channel: e, type: t, payload: n, id: s, meta: i, resolve: d } = this.reduceQueue.shift(), a = {
+            channel: e,
+            type: t,
+            payload: n,
+            id: s,
+            ...i !== void 0 ? { meta: i } : {}
+          }, r = this.instrumentObservers.size > 0, f = r ? this.state : void 0, c = r ? [] : void 0;
+          c !== void 0 && (this.changedPathSink = c);
+          const u = r ? z() : 0;
           let l = !1;
           try {
-            l = this.applyEventSync(c);
-          } catch (u) {
-            console.error("Emit reduce error:", u);
+            l = this.applyEventSync(a);
+          } catch (y) {
+            console.error("Emit reduce error:", y);
           } finally {
-            i && (this.changedPathSink = null);
+            r && (this.changedPathSink = null);
           }
-          i && this.emitInstrumentation(
-            c,
+          r && this.emitInstrumentation(
+            a,
             l,
+            c ?? [],
             f,
-            o,
-            S() - h
-          ), this.runEventEffects(c, l, s);
+            z() - u
+          ), this.runEventEffects(a, l, d);
         }
       } finally {
         this.isReducing = !1;
@@ -1162,25 +1405,32 @@ class v {
    * @internal
    */
   applyEventSync(e) {
-    for (const n of this.middleware) {
-      const s = this.getMiddlewareWhen(n);
-      if (!this.matchesWhen(s, e)) continue;
-      const c = this.getMiddlewareFunction(n);
-      let i;
+    for (const s of this.middleware) {
+      const i = this.getMiddlewareWhen(s);
+      if (!this.matchesWhen(i, e)) continue;
+      const d = this.getMiddlewareFunction(s);
+      let a;
       try {
-        i = c(this.state, e, this.emit);
-      } catch (o) {
-        console.error("Middleware error:", o), i = !1;
+        a = d(this.state, e, this.emit), process.env.NODE_ENV !== "production" && typeof a?.then == "function" && console.error(
+          `[yoltra] Middleware for "${e.channel}/${e.type}" returned a Promise. Middleware is synchronous: a Promise is truthy, so this event was allowed without waiting and a "return false" inside it can never veto. Do the check synchronously, and put anything that must await in an effect.`
+        );
+      } catch (r) {
+        console.error("Middleware error:", r), a = !1;
       }
-      if (!i)
+      if (!a)
         return this.notifyEventSubscribers(e, "uncommitted"), !1;
     }
     const t = this.state;
-    this.reducerBus.emit(e.channel, e.type, e.payload);
-    for (const [n, s] of this.patternReducers)
-      this.matchesWhen(s, e) && this.forwardEvent(n, e);
-    const r = t !== this.state;
-    return this.notifyEventSubscribers(e, "committed"), r && this.listeners.forEach((n) => n()), !0;
+    this.reducerBus.emit(
+      e.channel,
+      e.type,
+      e.payload,
+      e
+    );
+    for (const [s, i] of this.patternReducers)
+      this.matchesWhen(i, e) && this.forwardEventGuarded(s, e);
+    const n = t !== this.state;
+    return this.notifyEventSubscribers(e, "committed"), n && this.listeners.forEach((s) => s()), !0;
   }
   /**
    * Runs a single committed event's effects as an **independent async task**,
@@ -1190,14 +1440,14 @@ class v {
    *
    * @internal
    */
-  async runEventEffects(e, t, r) {
+  async runEventEffects(e, t, n) {
     this.inFlightEffects++;
     try {
       t && await this.notifyEffects(e);
-    } catch (n) {
-      console.error("Effect error:", n);
+    } catch (s) {
+      console.error("Effect error:", s);
     } finally {
-      this.inFlightEffects--, r();
+      this.inFlightEffects--, n();
     }
   }
   /**
@@ -1218,28 +1468,31 @@ class v {
    *
    * @internal
    */
-  emitInstrumentation(e, t, r, n, s) {
-    const c = {}, i = {};
-    for (const f of r)
-      c[f] = this.getAtPath(n, f), i[f] = this.getAtPath(this.state, f);
-    const o = {
+  emitInstrumentation(e, t, n, s, i) {
+    const d = {}, a = {};
+    for (const f of n)
+      d[f] = this.getAtPath(s, f), a[f] = this.getAtPath(this.state, f);
+    const r = {
       event: {
         id: e.id,
         channel: e.channel,
         type: e.type,
-        payload: e.payload
+        payload: e.payload,
+        // Conditional, so an event without metadata produces an observer payload
+        // byte-identical to the pre-`meta` shape.
+        ...e.meta !== void 0 ? { meta: e.meta } : {}
       },
       committed: t,
-      changedPaths: r,
-      prevValues: c,
-      nextValues: i,
-      reduceTimeMs: s
+      changedPaths: n,
+      prevValues: d,
+      nextValues: a,
+      reduceTimeMs: i
     };
     for (const f of [...this.instrumentObservers])
       try {
-        f(o);
-      } catch (h) {
-        console.error("Instrumentation observer error:", h);
+        f(r);
+      } catch (c) {
+        console.error("Instrumentation observer error:", c);
       }
   }
   /**
@@ -1319,11 +1572,11 @@ class v {
    *
    * @public
    */
-  onEvent(e, t, r, n = "committed") {
-    const s = `${e}::${String(t)}`, c = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
-    return c.has(s) || c.set(s, /* @__PURE__ */ new Set()), c.get(s).add(r), () => {
-      const i = c.get(s);
-      i && (i.delete(r), i.size === 0 && c.delete(s));
+  onEvent(e, t, n, s = "committed") {
+    const i = `${e}::${String(t)}`, d = s === "committed" ? this.committedEventSubscribers : s === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
+    return d.has(i) || d.set(i, /* @__PURE__ */ new Set()), d.get(i).add(n), () => {
+      const a = d.get(i);
+      a && (a.delete(n), a.size === 0 && d.delete(i));
     };
   }
   /**
@@ -1365,13 +1618,21 @@ class v {
   /**
    * Registers a middleware (runs **before** reducers).
    *
-   * @param mw - Middleware `(state, event, emit) => boolean|Promise<boolean>`.
-   *        Return `false` to cancel event propagation.
+   * @param mw - Middleware `(state, event, emit) => boolean`. Return `false` to cancel event
+   *        propagation.
    * @returns Unsubscribe function that removes this middleware.
    *
+   * @remarks
+   * **Synchronous, and that is the contract.** The reduce phase completes before `emit()`
+   * returns, so the commit decision has to be available in the same tick. An `async` middleware
+   * returns a Promise, every Promise is truthy, and the veto would therefore never fire — the
+   * event would commit while the middleware was still deciding. The type rejects it; this note
+   * exists because the examples here used to teach it. Do authorization and validation here, and
+   * anything that needs to await in an effect.
+   *
    * @example Logging middleware
    * ```ts
-   * const off = store.registerMiddleware(async (state, event) => {
+   * const off = store.registerMiddleware((state, event) => {
    *   console.log('Event:', event.channel, event.type, event.payload);
    *   return true; // allow
    * });
@@ -1398,7 +1659,7 @@ class v {
    * Dynamically **adds** a named slice reducer at runtime.
    *
    * @param name - New slice name (must not already exist).
-   * @param spec - Reducer spec (state, events, reducer).
+   * @param spec - Reducer spec (state, when, reducer).
    * @returns Disposer function that **removes** the slice (and its state).
    *
    * @example
@@ -1420,8 +1681,8 @@ class v {
     if (e in this.reducers) throw new Error(`Reducer ${e} already exists`);
     return this.mountSlice(e, t, {
       preserveState: !1
-    }), this.listeners.forEach((r) => r()), () => {
-      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((r) => r());
+    }), this.listeners.forEach((n) => n()), () => {
+      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((n) => n());
     };
   }
   /**
@@ -1429,7 +1690,7 @@ class v {
    *
    * Effects are **keyed** by `(channel, type)` for O(1) lookup (no scanning all effects).
    *
-   * @param spec - Effect specification with `events` (EventKeys) and `effect` (handler).
+   * @param spec - Effect specification with `when` targeting and `effect` (handler).
    * @returns Unsubscribe function.
    *
    * @example Logging effect
@@ -1457,29 +1718,29 @@ class v {
    * @public
    */
   registerEffect(e) {
-    const { effect: t, meta: r, when: n } = e, s = [];
-    if (r && this.effectMeta.set(t, r), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
-      const o = { effect: t, when: n };
-      return this.patternEffects.add(o), () => {
-        this.patternEffects.delete(o);
+    const { effect: t, meta: n, when: s } = e, i = [];
+    if (n && this.effectMeta.set(t, n), s && ("any" in s && s.any === !0 || "channel" in s || "channels" in s)) {
+      const r = { effect: t, when: s };
+      return this.patternEffects.add(r), () => {
+        this.patternEffects.delete(r);
       };
     }
-    const i = this.normalizeEventKeys(e);
-    if (i.length === 0 && !n && !e.events) {
-      const o = { effect: t, when: { any: !0 } };
-      return this.patternEffects.add(o), () => {
-        this.patternEffects.delete(o);
+    const a = this.normalizeEventKeys(e);
+    if (a.length === 0 && !s) {
+      const r = { effect: t, when: { any: !0 } };
+      return this.patternEffects.add(r), () => {
+        this.patternEffects.delete(r);
       };
     }
-    for (const [o, f] of i) {
-      const h = `${String(o)}::${String(f)}`;
-      this.effects.has(h) || this.effects.set(h, /* @__PURE__ */ new Set()), this.effects.get(h).add(t), s.push(() => {
-        const l = this.effects.get(h);
-        l && (l.delete(t), l.size === 0 && this.effects.delete(h));
+    for (const [r, f] of a) {
+      const c = `${String(r)}::${String(f)}`;
+      this.effects.has(c) || this.effects.set(c, /* @__PURE__ */ new Set()), this.effects.get(c).add(t), i.push(() => {
+        const u = this.effects.get(c);
+        u && (u.delete(t), u.size === 0 && this.effects.delete(c));
       });
     }
     return () => {
-      for (const o of s) o();
+      for (const r of i) r();
     };
   }
   /**
@@ -1503,15 +1764,15 @@ class v {
    *
    * @public
    */
-  onEffect(e, t, r) {
-    const n = async (s, c, i) => {
-      if (s.channel !== e || s.type !== t) return;
-      const o = s;
-      return r(o.payload, c, i, o);
+  onEffect(e, t, n) {
+    const s = async (i, d, a) => {
+      if (i.channel !== e || i.type !== t) return;
+      const r = i;
+      return n(r.payload, d, a, r);
     };
     return this.registerEffect({
-      events: [[e, t]],
-      effect: n
+      when: { keys: [[e, t]] },
+      effect: s
     });
   }
   /**
@@ -1573,11 +1834,11 @@ class v {
    * @public
    */
   replaceReducers(e, t = {}) {
-    const r = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), s = Object.entries(e), c = new Set(s.map(([i]) => i));
-    for (const i of n)
-      c.has(i) || this.unmountSlice(i, { deleteState: !0 });
-    for (const [i, o] of s)
-      n.has(i) ? (this.unmountSlice(i, { deleteState: !1 }), this.mountSlice(i, o, { preserveState: r })) : this.mountSlice(i, o, { preserveState: !1 });
+    const n = t.preserveState !== !1, s = new Set(Object.keys(this.reducers)), i = Object.entries(e), d = new Set(i.map(([a]) => a));
+    for (const a of s)
+      d.has(a) || this.unmountSlice(a, { deleteState: !0 });
+    for (const [a, r] of i)
+      s.has(a) ? (this.unmountSlice(a, { deleteState: !1 }), this.mountSlice(a, r, { preserveState: n })) : this.mountSlice(a, r, { preserveState: !1 });
   }
   /**
    * Convenience API to replace **any subset** of store parts (HMR patterns).
@@ -1604,31 +1865,39 @@ class v {
    * and wires `(channel, type)` listeners on the reducer bus.
    *
    * @param name - Slice name.
-   * @param rSpec - Reducer spec (state, events, reducer).
+   * @param rSpec - Reducer spec (state, when, reducer).
    * @param opts - `{ preserveState: boolean }` whether to keep existing state.
    *
    * @internal
    */
-  mountSlice(e, t, r) {
-    const n = e, { events: s, reducer: c, state: i, when: o } = t;
-    if (this.reducers[e] = new _(c), (!r.preserveState || this.state[n] === void 0) && (this.state[n] = b(structuredClone(i))), o && ("any" in o && o.any === !0 || "channel" in o || "channels" in o)) {
-      this.patternReducers.set(e, o), this.sliceUnsubs.set(n, []);
+  mountSlice(e, t, n) {
+    const s = e, { reducer: i, state: d, when: a } = t;
+    if (this.reducers[e] = new K(i), (!n.preserveState || this.state[s] === void 0) && (this.state = {
+      ...this.state,
+      [s]: k(W(s, d))
+    }), a && ("any" in a && a.any === !0 || "channel" in a || "channels" in a)) {
+      this.patternReducers.set(e, a), this.sliceUnsubs.set(s, []);
       return;
     }
-    const h = this.normalizeEventKeys(t);
-    if (h.length === 0 && !o && !s) {
-      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
+    const f = this.normalizeEventKeys(t);
+    if (f.length === 0 && !a) {
+      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(s, []);
       return;
     }
-    const l = [];
-    for (const [u, p] of h) {
-      const y = this.reducerBus.on(u, p, (m) => {
-        const M = { channel: u, type: p, payload: m, id: crypto.randomUUID() };
-        this.forwardEvent(e, M);
+    const c = [];
+    for (const [u, l] of f) {
+      const y = this.reducerBus.on(u, l, (h, m) => {
+        const g = m ?? {
+          channel: u,
+          type: l,
+          payload: h,
+          id: this.idFactory()
+        };
+        this.forwardEventGuarded(e, g);
       });
-      l.push(y);
+      c.push(y);
     }
-    this.sliceUnsubs.set(n, l);
+    this.sliceUnsubs.set(s, c);
   }
   /**
    * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
@@ -1640,24 +1909,27 @@ class v {
    * @internal
    */
   unmountSlice(e, t) {
-    const r = e;
+    const n = e;
     this.patternReducers.delete(e);
-    const n = this.sliceUnsubs.get(r);
-    if (n) {
-      for (const s of n)
+    const s = this.sliceUnsubs.get(n);
+    if (s) {
+      for (const i of s)
         try {
-          s();
-        } catch (c) {
-          console.error(`[Store error]: ${c}`);
+          i();
+        } catch (d) {
+          console.error(`[Store error]: ${d}`);
         }
-      this.sliceUnsubs.delete(r);
+      this.sliceUnsubs.delete(n);
+    }
+    if (delete this.reducers[e], t.deleteState) {
+      const { [n]: i, ...d } = this.state;
+      this.state = d;
     }
-    delete this.reducers[e], t.deleteState && delete this.state[r];
   }
   /**
-   * Normalizes event targeting from `when` or legacy `events` to an array of EventKeys.
+   * Normalizes event targeting from `when` to an array of EventKeys.
    *
-   * @param spec - Object with optional `when` and/or `events` properties.
+   * @param spec - Object with an optional `when` matcher.
    * @returns Array of `[channel, type]` pairs.
    *
    * @internal
@@ -1665,16 +1937,10 @@ class v {
   normalizeEventKeys(e) {
     if (e.when) {
       const t = e.when;
-      if ("any" in t && t.any === !0)
-        return [];
       if ("keys" in t)
         return t.keys;
-      if ("channel" in t)
-        return [];
-      if ("channels" in t)
-        return [];
     }
-    return e.events ? e.events : [];
+    return [];
   }
   /**
    * Reads a dotted path from an object (supports numeric array indices via string keys).
@@ -1687,13 +1953,13 @@ class v {
    */
   getAtPath(e, t) {
     if (!t) return e;
-    const n = (t[0] === "." ? t.slice(1) : t).split(".");
-    let s = e;
-    for (const c of n) {
-      if (s == null) return;
-      s = s[c];
+    const s = (t[0] === "." ? t.slice(1) : t).split(".");
+    let i = e;
+    for (const d of s) {
+      if (i == null) return;
+      i = i[d];
     }
-    return s;
+    return i;
   }
   /**
    * Builds ancestor paths for a dotted path.
@@ -1712,33 +1978,397 @@ class v {
    */
   static buildAncestorPaths(e) {
     if (!e) return [];
-    const r = (e[0] === "." ? e.slice(1) : e).split("."), n = [];
-    for (let s = 0; s < r.length; s++)
-      n.push(r.slice(0, s + 1).join("."));
-    return n;
+    const n = (e[0] === "." ? e.slice(1) : e).split("."), s = [];
+    for (let i = 0; i < n.length; i++)
+      s.push(n.slice(0, i + 1).join("."));
+    return s;
   }
 }
-function R(a) {
-  return new v({
-    name: a.name,
-    reducer: a.reducer ?? {},
-    middleware: a.middleware ?? [],
-    effects: a.effects ?? [],
-    dedupWindowMs: a.dedupWindowMs,
-    devtools: a.devtools,
-    onEffectError: a.onEffectError
+function L(o) {
+  return new $({
+    name: o.name,
+    reducer: o.reducer ?? {},
+    middleware: o.middleware ?? [],
+    effects: o.effects ?? [],
+    dedupWindowMs: o.dedupWindowMs,
+    idFactory: o.idFactory,
+    devtools: o.devtools,
+    onEffectError: o.onEffectError,
+    onReducerError: o.onReducerError
   });
 }
-const $ = (a) => (e, t) => t.map((r) => [e, r]), B = () => (a) => a;
+const G = (o) => (e, t) => t.map((n) => [e, n]), Q = () => (o) => o, I = /* @__PURE__ */ new Set();
+function j(o) {
+  const e = String(o);
+  I.has(e) || (I.add(e), console.warn(
+    `[yoltra] Entity id "${e}" contains a dot. Paths are dotted, so a subscription to "entities.${e}" is indistinguishable from one to a nested object of the same name. Use ids without dots.`
+  ));
+}
+function F(o, e) {
+  if (o.length !== e.length) return e;
+  for (let t = 0; t < o.length; t++)
+    if (o[t] !== e[t]) return e;
+  return o;
+}
+function J(o = {}) {
+  const e = o.selectId ?? ((r) => r.id), { sortComparer: t } = o, n = (r, f) => {
+    if (t === void 0) return f;
+    const c = [...f].sort((u, l) => {
+      const y = r.entities[u], h = r.entities[l];
+      return y === void 0 || h === void 0 ? 0 : t(y, h);
+    });
+    return F(f, c);
+  }, s = (r, f, c) => {
+    const u = { ...r, entities: f, ids: c };
+    return { ...u, ids: n(u, c) };
+  }, i = (r, f, c) => {
+    let u = null, l = null;
+    for (const y of f) {
+      const h = e(y);
+      process.env.NODE_ENV !== "production" && String(h).includes(".") && j(h);
+      const m = (u ?? r.entities)[h];
+      if (m !== void 0 && c === "add") continue;
+      const g = m !== void 0 && c === "upsert" ? { ...m, ...y } : y;
+      u ?? (u = { ...r.entities }), u[h] = g, m === void 0 && (l ?? (l = [...r.ids]), l.push(h));
+    }
+    return u === null ? r : s(r, u, l ?? r.ids);
+  }, d = (r, f) => {
+    let c = null;
+    for (const { id: u, changes: l } of f) {
+      const y = (c ?? r.entities)[u];
+      y !== void 0 && (c ?? (c = { ...r.entities }), c[u] = { ...y, ...l });
+    }
+    return c === null ? r : s(r, c, r.ids);
+  }, a = (r, f) => {
+    const c = new Set(f.filter((l) => r.entities[l] !== void 0));
+    if (c.size === 0) return r;
+    const u = { ...r.entities };
+    for (const l of c) delete u[l];
+    return s(
+      r,
+      u,
+      r.ids.filter((l) => !c.has(l))
+    );
+  };
+  return {
+    getInitialState(r) {
+      const f = { ids: [], entities: {} };
+      return r === void 0 ? f : { ...f, ...r };
+    },
+    addOne: (r, f) => i(r, [f], "add"),
+    addMany: (r, f) => i(r, f, "add"),
+    setOne: (r, f) => i(r, [f], "set"),
+    setMany: (r, f) => i(r, f, "set"),
+    setAll: (r, f) => {
+      const c = {}, u = [];
+      for (const l of f) {
+        const y = e(l);
+        c[y] === void 0 && u.push(y), c[y] = l;
+      }
+      return s(r, c, u);
+    },
+    updateOne: (r, f) => d(r, [f]),
+    updateMany: (r, f) => d(r, f),
+    upsertOne: (r, f) => i(r, [f], "upsert"),
+    upsertMany: (r, f) => i(r, f, "upsert"),
+    removeOne: (r, f) => a(r, [f]),
+    removeMany: (r, f) => a(r, f),
+    removeAll: (r) => r.ids.length === 0 ? r : s(r, {}, []),
+    selectIds: (r) => r.ids,
+    selectEntities: (r) => r.entities,
+    selectAll: (r) => r.ids.map((f) => r.entities[f]),
+    selectById: (r, f) => r.entities[f],
+    selectTotal: (r) => r.ids.length,
+    idsPath: "ids",
+    pathTo: (r, f) => f === void 0 ? `entities.${r}` : `entities.${r}.${f}`,
+    anyField: (r) => `entities.*.${r}`
+  };
+}
+const E = "$yoltra";
+function _(o, e = {}) {
+  const t = e.maxNodes ?? 1e5, n = e.sanitize, s = [], i = /* @__PURE__ */ new Map();
+  let d = 0, a = !1;
+  function r(c, u) {
+    if (n !== void 0 && (c = n(u, c)), d += 1, d > t)
+      return a = !0, { [E]: "unsupported", kind: "truncated" };
+    switch (typeof c) {
+      case "undefined":
+        return { [E]: "undefined" };
+      case "bigint":
+        return { [E]: "bigint", value: c.toString() };
+      case "number":
+        return Number.isNaN(c) ? { [E]: "nan" } : c === 1 / 0 ? { [E]: "infinity", sign: 1 } : c === -1 / 0 ? { [E]: "infinity", sign: -1 } : c;
+      case "function":
+      case "symbol":
+        return s.push(u), { [E]: "unsupported", kind: typeof c };
+      case "string":
+      case "boolean":
+        return c;
+    }
+    if (c === null) return null;
+    const l = c, y = i.get(l);
+    if (y !== void 0) return { [E]: "ref", path: y };
+    if (i.set(l, u), c instanceof Date)
+      return { [E]: "date", iso: c.toISOString() };
+    if (c instanceof RegExp)
+      return { [E]: "regexp", source: c.source, flags: c.flags };
+    if (c instanceof Error)
+      return { [E]: "error", name: c.name, message: c.message };
+    if (c instanceof Map) {
+      const m = [];
+      let g = 0;
+      for (const [w, D] of c)
+        m.push([r(w, `${u}/@k${g}`), r(D, `${u}/${g}`)]), g += 1;
+      return { [E]: "map", entries: m };
+    }
+    if (c instanceof Set) {
+      const m = [];
+      let g = 0;
+      for (const w of c)
+        m.push(r(w, `${u}/${g}`)), g += 1;
+      return { [E]: "set", values: m };
+    }
+    if (Array.isArray(c))
+      return c.map((m, g) => r(m, `${u}/${g}`));
+    const h = {};
+    for (const [m, g] of Object.entries(c))
+      h[m] = r(g, `${u}/${N(m)}`);
+    return E in h ? { [E]: "escaped", value: h } : h;
+  }
+  return { value: r(o, ""), report: { truncated: a, unsupported: s } };
+}
+function V(o) {
+  const e = /* @__PURE__ */ new Map(), t = [];
+  function n(d, a) {
+    if (d === null || typeof d != "object") return d;
+    if (Array.isArray(d)) {
+      const f = [];
+      return e.set(a, f), d.forEach((c, u) => {
+        if (R(c)) {
+          t.push({ target: f, key: u, path: c.path }), f[u] = void 0;
+          return;
+        }
+        f[u] = n(c, `${a}/${u}`);
+      }), f;
+    }
+    if (typeof d[E] == "string") {
+      const f = d;
+      switch (f[E]) {
+        case "undefined":
+          return;
+        case "nan":
+          return Number.NaN;
+        case "infinity":
+          return f.sign === 1 ? 1 / 0 : -1 / 0;
+        case "bigint":
+          return BigInt(f.value);
+        case "date":
+          return new Date(f.iso);
+        case "regexp":
+          return new RegExp(f.source, f.flags);
+        case "error": {
+          const c = new Error(f.message);
+          return c.name = f.name, c;
+        }
+        case "unsupported":
+          return;
+        case "ref":
+          return;
+        case "map": {
+          const c = /* @__PURE__ */ new Map();
+          return e.set(a, c), f.entries.forEach(([u, l], y) => {
+            c.set(n(u, `${a}/@k${y}`), n(l, `${a}/${y}`));
+          }), c;
+        }
+        case "set": {
+          const c = /* @__PURE__ */ new Set();
+          return e.set(a, c), f.values.forEach((u, l) => c.add(n(u, `${a}/${l}`))), c;
+        }
+        case "escaped":
+          return s(f.value, a);
+        default:
+          return;
+      }
+    }
+    return s(d, a);
+  }
+  function s(d, a) {
+    const r = {};
+    e.set(a, r);
+    for (const [f, c] of Object.entries(d)) {
+      const u = `${a}/${N(f)}`;
+      if (R(c)) {
+        t.push({ target: r, key: f, path: c.path }), r[f] = void 0;
+        continue;
+      }
+      r[f] = n(c, u);
+    }
+    return r;
+  }
+  const i = n(o, "");
+  e.set("", i);
+  for (const { target: d, key: a, path: r } of t)
+    d[a] = e.get(r);
+  return i;
+}
+function R(o) {
+  return o !== null && typeof o == "object" && o[E] === "ref" && typeof o.path == "string";
+}
+function N(o) {
+  return o.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function Y(o, e, t = {}) {
+  let n = t.maxNodes ?? 1e5;
+  for (let s = 0; s < 8; s += 1) {
+    const { value: i, report: d } = _(o, { ...t, maxNodes: n });
+    let a;
+    try {
+      a = JSON.stringify(i)?.length ?? 0;
+    } catch {
+      a = Number.POSITIVE_INFINITY;
+    }
+    if (a <= e)
+      return d.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 r = Math.floor(n * e * 0.8 / a);
+    if (n = Math.max(1, Math.min(r, n - 1)), n <= 1 && s > 0)
+      break;
+  }
+  return {
+    value: { [E]: "unsupported", kind: "truncated" },
+    truncated: !0,
+    note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
+  };
+}
+function b(o, e, t) {
+  o.onError?.(e, t);
+}
+async function q(o) {
+  const e = { slices: {}, restored: !1 };
+  let t;
+  try {
+    t = o.source ?? await o.adapter.read(o.key);
+  } catch (s) {
+    return b(o, s, "read"), e;
+  }
+  if (t == null || t === "") return e;
+  let n;
+  try {
+    n = V(JSON.parse(t));
+  } catch (s) {
+    return b(o, s, "decode"), e;
+  }
+  if (n === null || typeof n != "object" || typeof n.version != "number")
+    return b(o, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
+  if (n.version !== o.version) {
+    if (o.migrate === void 0)
+      return b(
+        o,
+        new Error(
+          `persisted state is version ${n.version}, this build expects ${o.version}, and no migrate was supplied`
+        ),
+        "migrate"
+      ), e;
+    try {
+      const s = o.migrate(n.slices, n.version);
+      return s === null ? e : { slices: s, restored: !0 };
+    } catch (s) {
+      return b(o, s, "migrate"), e;
+    }
+  }
+  return { slices: n.slices ?? {}, restored: !0 };
+}
+function X(o, e) {
+  if (!e.restored) return o;
+  const t = {};
+  for (const [n, s] of Object.entries(o)) {
+    const i = e.slices[n];
+    t[n] = i === void 0 ? s : { ...s, state: i };
+  }
+  return t;
+}
+function A(o, e) {
+  const t = o ?? {}, n = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((s) => s in t).map((s) => [s, t[s]]));
+  return JSON.stringify(_({ version: e.version, slices: n }).value);
+}
+function Z(o, e) {
+  const t = e.throttleMs ?? 250, n = e.slices;
+  let s = null, i = !1;
+  const d = () => {
+    if (i) {
+      i = !1;
+      try {
+        const f = e.adapter.write(e.key, A(o.getState(), e));
+        f instanceof Promise && f.catch((c) => b(e, c, "write"));
+      } catch (f) {
+        b(e, f, "write");
+      }
+    }
+  }, a = () => {
+    if (i = !0, t <= 0) {
+      d();
+      return;
+    }
+    s === null && (s = setTimeout(() => {
+      s = null, d();
+    }, t), s.unref?.());
+  }, r = o.instrument((f) => {
+    if (n === void 0) {
+      a();
+      return;
+    }
+    (f.changedPaths ?? []).some(
+      (u) => n.some((l) => u === l || u.startsWith(`${l}.`))
+    ) && a();
+  });
+  return () => {
+    r(), s !== null && (clearTimeout(s), s = null), d();
+  };
+}
+function ee(o, e) {
+  return A(o.getState(), e);
+}
+function te(o) {
+  return {
+    read: (e) => o.getItem(e),
+    write: (e, t) => o.setItem(e, t),
+    remove: (e) => o.removeItem(e)
+  };
+}
+function se(o) {
+  const e = new Map(Object.entries(o ?? {}));
+  return {
+    read: (t) => e.get(t) ?? null,
+    write: (t, n) => {
+      e.set(t, n);
+    },
+    remove: (t) => {
+      e.delete(t);
+    }
+  };
+}
 export {
-  O as EventBus,
-  k as LooseEventBus,
-  _ as Reducer,
-  v as Store,
-  R as createStore,
-  g as detectChangedProps,
-  B as eventKeys,
-  E as freezeState,
-  $ as typedEvents
+  B as EventBus,
+  H as LooseEventBus,
+  K as Reducer,
+  $ as Store,
+  J as createEntityAdapter,
+  se as createMemoryAdapter,
+  L as createStore,
+  te as createWebStorageAdapter,
+  V as decodeState,
+  ee as dehydrate,
+  O as detectChangedProps,
+  _ as encodeState,
+  Y as encodeStateBounded,
+  Q as eventKeys,
+  S as freezeState,
+  q as hydrate,
+  Z as persist,
+  G as typedEvents,
+  X as withHydration
 };
 //# sourceMappingURL=yoltra.esm.js.map