@yoltra/core 0.3.0 → 0.5.0

package/dist/yoltra.mjs

@@ -0,0 +1,2391 @@
+/*!
+ * @yoltra/core v0.5.0
+ * (c) 2026 Manu Ramirez <@pixerael>
+ * License: MIT
+ * Homepage: https://yoltra.dev
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree
+ */
+var 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
+     */
+    p(this, "handlers", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribes a handler to an exact `(channel, type)`.
+   *
+   * @typeParam C - Channel key (must be a string key of `EM`).
+   * @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]`. 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
+   * ```ts
+   * const off = bus.on('data', 'loaded', ({ items }) => {
+   *   console.log('Loaded', items.length, 'items');
+   * });
+   *
+   * // Later, stop listening:
+   * off();
+   * ```
+   *
+   * @example Reading the source event
+   * ```ts
+   * bus.on('data', 'loaded', (payload, event) => {
+   *   console.log('event id:', event?.id);
+   * });
+   * ```
+   *
+   * @public
+   */
+  on(e, t, n) {
+    let s = this.handlers.get(e);
+    s || (s = /* @__PURE__ */ new Map(), this.handlers.set(e, s));
+    let i = s.get(t);
+    return i || (i = /* @__PURE__ */ new Set(), s.set(t, i)), i.add(n), () => this.off(e, t, n);
+  }
+  /**
+   * Removes a specific handler previously added with {@link EventBus.on | `on`}.
+   *
+   * @typeParam C - Channel key (string key of `EM`).
+   * @typeParam T - Type key within channel `C` (string key of `EM[C]`).
+   * @param channel - Channel name of the subscription to remove.
+   * @param type - Event type of the subscription to remove.
+   * @param handler - The same handler reference that was passed to `on`.
+   *
+   * @example
+   * ```ts
+   * const h = (n: number) => console.log('inc', n);
+   * bus.on('math', 'inc', h);
+   *
+   * // Explicitly remove this handler:
+   * bus.off('math', 'inc', h);
+   * ```
+   *
+   * @public
+   */
+  off(e, t, n) {
+    const s = this.handlers.get(e);
+    if (!s) return;
+    const i = s.get(t);
+    i && (i.delete(n), i.size === 0 && s.delete(t), s.size === 0 && this.handlers.delete(e));
+  }
+  /**
+   * Emits an event to all subscribers of the exact `(channel, type)`.
+   *
+   * Handlers are invoked **synchronously**. Any exception thrown by a handler is
+   * caught and logged, and other handlers still run.
+   *
+   * @typeParam C - Channel key (string key of `EM`).
+   * @typeParam T - Type key within channel `C` (string key of `EM[C]`).
+   * @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
+   * bus.emit('ui', 'toggle', false);
+   * ```
+   *
+   * @public
+   */
+  emit(e, t, n, s) {
+    const i = this.handlers.get(e);
+    if (!i) return;
+    const d = i.get(t);
+    if (!(!d || d.size === 0))
+      for (const a of [...d])
+        try {
+          a(n, s);
+        } catch (r) {
+          console.error("EventBus handler error:", r);
+        }
+  }
+  /**
+   * Clears **all** listeners across all channels/types.
+   *
+   * Useful for tests or during HMR teardown to avoid duplicate handlers.
+   *
+   * @example
+   * ```ts
+   * // In a test teardown:
+   * afterEach(() => bus.clear());
+   * ```
+   *
+   * @public
+   */
+  clear() {
+    this.handlers.clear();
+  }
+}
+class H {
+  constructor() {
+    /**
+     * Exact handlers: `channel → type → [handlers]`.
+     * @internal
+     */
+    p(this, "handlers", /* @__PURE__ */ new Map());
+    /**
+     * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
+     * @internal
+     */
+    p(this, "patternHandlers", /* @__PURE__ */ new Map());
+    /**
+     * Patterns bucketed by their first segment, so an emit tests only what could match.
+     *
+     * @remarks
+     * Delivery used to walk every pattern registered on the channel and run the full segment
+     * matcher against each. That is linear in the number of patterns rather than in the number
+     * that match, and it re-split both the pattern and the subject on every test — for a thousand
+     * patterns, two thousand string splits to deliver one event.
+     *
+     * A subject's first segment can only be matched by a pattern whose first segment is that same
+     * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
+     * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
+     * the handful that begin with a wildcard.
+     *
+     * It buys nothing for a channel where every pattern starts with `**`, since all of those must
+     * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
+     */
+    p(this, "patternIndex", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribes a handler to either an **exact** type or a **pattern**.
+   *
+   * @param channel - Channel to subscribe on.
+   * @param type - Exact event type (e.g. `"a.b"`) or pattern (contains `*`/`**`).
+   * @param handler - Function invoked with the emitted payload.
+   * @returns An **unsubscribe** function that removes this handler.
+   *
+   * @remarks
+   * - Exact subscriptions are stored under a **normalized** key (leading `.` removed).
+   * - Pattern subscriptions are stored **as provided**; matching normalizes the subject.
+   *
+   * @example Exact subscription
+   * ```ts
+   * const off = bus.on('data', 'items.loaded', ({ count }) => {
+   *   console.log('Loaded', count);
+   * });
+   * // Later
+   * off();
+   * ```
+   *
+   * @example Pattern subscription
+   * ```ts
+   * // Match any single sub-event: 'panel.open', 'panel.close', etc.
+   * const offStar = bus.on('ui', 'panel.*', () => {});
+   *
+   * // Match any depth: 'panel.open', 'panel.items.add', 'panel', etc.
+   * const offGlob = bus.on('ui', 'panel.**', () => {});
+   * ```
+   *
+   * @public
+   */
+  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 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 i = this.normalizeTypeKey(s);
+      this.handlers.has(e) || this.handlers.set(e, /* @__PURE__ */ new Map());
+      const d = this.handlers.get(e);
+      return d.has(i) || d.set(i, []), d.get(i).push(n), () => this.offExactNormalized(e, i, n);
+    }
+  }
+  /**
+   * Unsubscribes an **exact** handler. The `type` key is normalized internally,
+   * so callers can pass `"foo"` or `".foo"` interchangeably.
+   *
+   * @param channel - Channel name.
+   * @param type - Exact event type key to remove (normalization applied).
+   * @param handler - The same handler reference previously passed to {@link LooseEventBus.on | `on`}.
+   *
+   * @example
+   * ```ts
+   * const h = () => {};
+   * bus.on('ui', 'panel.open', h);
+   * // Remove it (with or without leading dot)
+   * bus.off('ui', '.panel.open', h);
+   * ```
+   *
+   * @public
+   */
+  off(e, t, n) {
+    const s = this.normalizeTypeKey(String(t));
+    this.offExactNormalized(e, s, n);
+  }
+  /**
+   * Internal exact unsubscription using an already **normalized** type key.
+   *
+   * @param channel - Channel name.
+   * @param normalizedType - Event type key with leading dot removed.
+   * @param handler - Handler to remove.
+   * @internal
+   */
+  offExactNormalized(e, t, n) {
+    const s = this.handlers.get(e);
+    if (!s) return;
+    const i = s.get(t);
+    if (!i) return;
+    const d = i.indexOf(n);
+    d !== -1 && i.splice(d, 1), i.length === 0 && s.delete(t), s.size === 0 && this.handlers.delete(e);
+  }
+  /**
+   * Internal removal for a **pattern** subscription. No-ops if missing.
+   *
+   * @param channel - Channel name.
+   * @param pattern - Pattern string as originally subscribed.
+   * @param handler - Handler to remove.
+   * @internal
+   */
+  offPattern(e, t, n) {
+    const s = this.patternHandlers.get(e);
+    if (!s) return;
+    const i = s.get(t);
+    if (!i) return;
+    const d = i.indexOf(n);
+    d !== -1 && i.splice(d, 1), i.length === 0 && (s.delete(t), this.unindexPattern(e, t)), s.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
+  }
+  /**
+   * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
+   * Duplicate handler references are called **once** (de-duped).
+   *
+   * @param channel - Channel to emit on.
+   * @param type - Event type (subject). A leading dot is ignored for matching.
+   * @param payload - Payload delivered to handlers.
+   *
+   * @example
+   * ```ts
+   * // Suppose:
+   * //  - on('ui', 'panel.open', h)
+   * //  - on('ui', 'panel.*', h)       // same handler ref!
+   * //  - on('ui', 'panel.**', other)
+   * bus.emit('ui', 'panel.open', { id: 1 });
+   * // => 'h' runs once (de-duped), then 'other'
+   * ```
+   *
+   * @public
+   */
+  emit(e, t, n) {
+    const s = String(t), i = this.normalizeTypeKey(s), d = this.handlers.get(e)?.get(i) ?? [], a = this.matchingPatternHandlers(e, s), r = /* @__PURE__ */ new Set(), f = (c) => {
+      for (const u of [...c])
+        if (!r.has(u)) {
+          r.add(u);
+          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 {
+            l(r);
+          } catch (y) {
+            console.error(y);
+            continue;
+          }
+        }
+    };
+    c(d);
+    for (const u of a) c(u);
+  }
+  /**
+   * Determines if a string is a **pattern** (contains `*`).
+   * @param s - Event type or pattern string.
+   * @returns `true` if it contains at least one `*`, else `false`.
+   * @internal
+   */
+  isPattern(e) {
+    return e.includes("*");
+  }
+  /**
+   * Normalizes event type keys for exact matching by stripping a **single** leading dot.
+   *
+   * @param s - Event type key.
+   * @returns Normalized key without a leading dot.
+   * @example
+   * ```ts
+   * normalizeTypeKey('.a.b') // 'a.b'
+   * normalizeTypeKey('a.b')  // 'a.b'
+   * ```
+   * @internal
+   */
+  normalizeTypeKey(e) {
+    return e.replace(/^\./, "");
+  }
+  /**
+   * Splits a path into dot-separated segments after normalization and removes empties.
+   * @param p - Event type or pattern string.
+   * @internal
+   */
+  splitPath(e) {
+    return this.normalizeTypeKey(e).split(".").filter(Boolean);
+  }
+  /**
+   * 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).
+   *
+   * @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
+   * matchSegments(['a', '*'], ['a', 'b'])           // true
+   * matchSegments(['a', '*'], ['a', 'b', 'c'])      // false
+   * matchSegments(['a', '**'], ['a'])               // true
+   * matchSegments(['**', 'end'], ['x', 'y', 'end']) // true
+   * ```
+   *
+   * @internal
+   */
+  matchSegments(e, t) {
+    let n = 0, s = 0, i = -1, d = 0;
+    for (; s < t.length; )
+      if (n < e.length && (e[n] === "*" || e[n] === t[s]))
+        n++, s++;
+      else if (n < e.length && e[n] === "**")
+        i = n, d = s, n++;
+      else if (i !== -1)
+        n = i + 1, s = ++d;
+      else
+        return !1;
+    for (; n < e.length && e[n] === "**"; ) n++;
+    return n === e.length;
+  }
+  /**
+   * Removes **all** listeners (exact and pattern). Useful for tests/HMR teardown.
+   *
+   * @example
+   * ```ts
+   * afterEach(() => bus.clear());
+   * ```
+   *
+   * @public
+   */
+  clear() {
+    this.handlers.clear(), this.patternHandlers.clear(), this.patternIndex.clear();
+  }
+  /**
+   * Returns a snapshot of all registered subscriptions for DevTools introspection.
+   *
+   * @returns An array of `{ channel, type, count }` entries for each distinct
+   *          (channel, type/pattern) pair with at least one handler.
+   *
+   * @internal
+   */
+  __introspect() {
+    const e = [];
+    for (const [t, n] of this.handlers)
+      for (const [s, i] of n)
+        i.length > 0 && e.push({ channel: t, type: s, count: i.length });
+    for (const [t, n] of this.patternHandlers)
+      for (const [s, i] of n)
+        i.length > 0 && e.push({ channel: t, type: s, count: i.length });
+    return e;
+  }
+}
+class K {
+  /**
+   * Creates a new {@link Reducer} from a pure reducer function.
+   *
+   * @param reduce - A function `(state, event) => nextState` that implements your update logic.
+   *
+   * @example
+   * ```ts
+   * const reducer = new Reducer<MyState, MyEM>((state, event) => {
+   *   // implement your transitions here
+   *   return state;
+   * });
+   * ```
+   *
+   * @public
+   */
+  constructor(e) {
+    /**
+     * The underlying pure reducer function.
+     * @internal
+     */
+    p(this, "_reduce");
+    this._reduce = e;
+  }
+  /**
+    * Applies the reducer to produce the next state.
+    *
+    * @param state  - Current state.
+    * @param event - An event drawn from {@link EventUnion | `EventUnion<EM>`}.
+    * @returns The next state produced by the underlying reducer function.
+    *
+    * @example
+    * ```ts
+  * const next = reducer.reduce(curr, someEvent as EventUnion<MyEM>);
+    * ```
+    *
+    * @public
+    */
+  reduce(e, t) {
+    return this._reduce(e, t);
+  }
+}
+const k = /* @__PURE__ */ new Set();
+function M(o, e) {
+  const t = o ? `${o}.${e}` : e;
+  k.has(t) || (k.add(t), console.warn(
+    `[yoltra] State key "${e}"${o ? ` under "${o}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
+  ));
+}
+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 f = Array.isArray(o), c = Array.isArray(e);
+    if (f !== c) {
+      s.push(t);
+      return;
+    }
+    if (f) {
+      const h = o, m = e;
+      h.length !== m.length && t && s.push(t);
+      const g = Math.min(h.length, m.length);
+      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;
+      }
+      v(o[h], e[h], g, n, s);
+    }
+    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 {
+    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 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 P(o, e) {
+  return process.env.NODE_ENV === "production" ? o : S(o, /* @__PURE__ */ new WeakSet(), e);
+}
+const x = 100, z = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+class $ {
+  /**
+   * Creates a store from a {@link StoreSpec}.
+   *
+   * @param spec - Store configuration (name, reducers, middleware, optional effects).
+   *
+   * @public
+   */
+  constructor(e) {
+    /**
+     * Store name (used by DevTools & diagnostics).
+     *
+     * @public
+     */
+    p(this, "name");
+    /**
+     * Registered middleware pipeline (run **before** reducers).
+     * Stores either raw functions (legacy) or MiddlewareSpec objects.
+     * Return `false` from the middleware function to stop propagation.
+     *
+     * @internal
+     */
+    p(this, "middleware");
+    /**
+     * Installed slice reducers keyed by slice name.
+     *
+     * @internal
+     */
+    p(this, "reducers");
+    /**
+     * Current immutable snapshot of the store state.
+     * This reference changes whenever any slice changes (shallow immutability).
+     *
+     * @internal
+     */
+    p(this, "state");
+    /**
+     * Bus for reducer wiring (emit by `(channel, type)`).
+     *
+     * @internal
+     */
+    p(this, "reducerBus");
+    /**
+     * Bus for **granular** connector events (emit by **dotted path** inside a slice).
+     *
+     * @internal
+     */
+    p(this, "connectorBus");
+    /**
+     * Coarse-grained listeners (called once per committed event, only if state changed).
+     *
+     * @internal
+     */
+    p(this, "listeners", /* @__PURE__ */ new Set());
+    /**
+     * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
+     * Used for effects with explicit `keys` targeting.
+     *
+     * @internal
+     */
+    p(this, "effects", /* @__PURE__ */ new Map());
+    /**
+     * Pattern-based effects that need runtime matching.
+     * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
+     * Stores tuples of [effect function, when matcher].
+     *
+     * @internal
+     */
+    p(this, "patternEffects", /* @__PURE__ */ new Set());
+    /**
+     * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified after reducers, before effects, for events that passed middleware.
+     *
+     * @internal
+     */
+    p(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified when middleware rejects an event.
+     *
+     * @internal
+     */
+    p(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified for both committed and uncommitted events with phase parameter.
+     *
+     * @internal
+     */
+    p(this, "allEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * Track reducerBus unsubs per slice for HMR/register/unregister.
+     *
+     * @internal
+     */
+    p(this, "sliceUnsubs", /* @__PURE__ */ new Map());
+    /**
+     * Pattern-based reducers that need runtime matching.
+     * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
+     * Maps slice name to the `when` matcher.
+     *
+     * @internal
+     */
+    p(this, "patternReducers", /* @__PURE__ */ new Map());
+    /**
+     * Whether `__replayEvents()` is allowed.
+     * Set from `spec.devtools.allowReplay`.
+     *
+     * @internal
+     */
+    p(this, "replayEnabled");
+    /**
+     * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
+     * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
+     *
+     * @internal
+     */
+    p(this, "idFactory");
+    /**
+     * Optional hook invoked when an effect throws/rejects. See
+     * {@link StoreSpec.onEffectError}. `await emit()` never rejects on effect
+     * failure — this is how callers observe effect errors.
+     */
+    p(this, "onEffectError");
+    /**
+     * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
+     * failing slice is isolated rather than the event being rolled back, so this is the only
+     * signal that a reducer misbehaved.
+     */
+    p(this, "onReducerError");
+    /**
+     * `slice:channel:type` combinations already warned about for payload aliasing.
+     *
+     * @remarks
+     * Development-only diagnostics have to stay quiet enough to be read. One warning names the
+     * pattern; repeating it once per event would bury it.
+     */
+    p(this, "warnedPayloadAliases", /* @__PURE__ */ new Set());
+    /**
+     * Pending events awaiting the **synchronous** reduce phase (middleware +
+     * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
+     *
+     * @internal
+     */
+    p(this, "reduceQueue", []);
+    /**
+     * Re-entrancy guard for the synchronous reduce phase.
+     *
+     * @internal
+     */
+    p(this, "isReducing", !1);
+    /**
+     * Registered instrumentation observers (DevTools seam). See {@link instrument}.
+     *
+     * @internal
+     */
+    p(this, "instrumentObservers", /* @__PURE__ */ new Set());
+    /**
+     * Scratch array collecting slice-prefixed changed leaf paths during an
+     * instrumented reduce. Set by {@link drainReduce} while observers are active;
+     * appended to by {@link forwardEvent}. `null` when not instrumenting.
+     *
+     * @internal
+     */
+    p(this, "changedPathSink", null);
+    /**
+     * Count of effect tasks currently in flight; surfaced as queue depth by
+     * {@link __devtoolsIntrospect}.
+     *
+     * @internal
+     */
+    p(this, "inFlightEffects", 0);
+    /**
+     * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
+     *
+     * **Deduplication Behavior:**
+     * - Events are fingerprinted using `channel::type::JSON(payload)`
+     * - If an identical fingerprint is seen within the dedup window, it's skipped
+     * - The window is 50ms in development, 100ms in production
+     *
+     * **Limitations:**
+     * - Non-serializable payloads (functions, symbols, circular refs) get unique
+     *   fingerprints and won't be deduplicated
+     * - Legitimate rapid-fire identical events may be incorrectly deduplicated
+     * - The cache is bounded to 1000 entries with lazy pruning
+     *
+     * @internal
+     */
+    p(this, "processedEvents", /* @__PURE__ */ new Map());
+    /**
+     * Lifetime count of events suppressed by the deduplication cache.
+     * Exposed via {@link __devtoolsIntrospect} so the DevTools agent can
+     * surface it in the STORE_METRICS response without further core changes.
+     *
+     * @internal
+     */
+    p(this, "dedupCount", 0);
+    /**
+     * Store-owned metadata for registered effects, keyed by the effect function.
+     * Kept **off** the caller's function object: mutating a user-owned function
+     * (the old `fn.__quoMeta`) bled metadata across stores that share a handler
+     * and left it attached after unregister. Cleared on {@link dispose}.
+     *
+     * @internal
+     */
+    p(this, "effectMeta", /* @__PURE__ */ new WeakMap());
+    /**
+     * Configuration for event deduplication.
+     * @internal
+     */
+    p(this, "dedupConfig");
+    /**
+     * Timer for periodic cleanup of processed events.
+     *
+     * @internal
+     */
+    p(this, "eventCleanupTimer", null);
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new 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, n]) => {
+      this.mountSlice(t, n, { preserveState: !1 });
+    }), e.effects?.length)
+      for (const t of e.effects)
+        this.registerEffect(t);
+    this.dispose = this.dispose.bind(this), this.notifyEffects = this.notifyEffects.bind(this), this.forwardEvent = this.forwardEvent.bind(this), this.__applyExternalState = this.__applyExternalState.bind(this), this.__replayEvents = this.__replayEvents.bind(this), this.__devtoolsIntrospect = this.__devtoolsIntrospect.bind(this), this.mountSlice = this.mountSlice.bind(this), this.unmountSlice = this.unmountSlice.bind(this), this.getAtPath = this.getAtPath.bind(this), this.emit = this.emit.bind(this), this.subscribe = this.subscribe.bind(this), this.connect = this.connect.bind(this), this.onEffect = this.onEffect.bind(this), this.onEvent = this.onEvent.bind(this), this.getState = this.getState.bind(this), this.registerEffect = this.registerEffect.bind(this), this.registerMiddleware = this.registerMiddleware.bind(this), this.registerReducer = this.registerReducer.bind(this), this.replaceMiddleware = this.replaceMiddleware.bind(this), this.replaceEffects = this.replaceEffects.bind(this), this.replaceReducers = this.replaceReducers.bind(this), this.hotReplace = this.hotReplace.bind(this);
+  }
+  /**
+   * Cleanup resources (timers, etc.) when disposing the store.
+   * Call this if you're dynamically creating/destroying stores.
+   *
+   * @example
+   * ```ts
+   * const store = createStore({ ... });
+   * // later
+   * store.dispose();
+   * ```
+   *
+   * @public
+   */
+  dispose() {
+    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.allEventSubscribers.clear(), this.instrumentObservers.clear(), this.connectorBus.clear(), this.reducerBus.clear(), this.patternReducers.clear(), this.sliceUnsubs.clear(), this.changedPathSink = null;
+  }
+  /**
+   * Generates a fingerprint for an event for deduplication purposes.
+   * Falls back gracefully for non-serializable payloads.
+   *
+   * @param channel - Event channel.
+   * @param type - Event type.
+   * @param payload - Event payload.
+   * @returns A string fingerprint for the event.
+   *
+   * @internal
+   */
+  fingerprint(e, t, n) {
+    const s = `${e}::${t}`;
+    try {
+      if (n == null)
+        return `${s}::null`;
+      if (typeof n != "object")
+        return `${s}::${String(n)}`;
+      const i = JSON.stringify(n);
+      return `${s}::${i}`;
+    } catch {
+      return `${s}::${Date.now()}::${Math.random()}`;
+    }
+  }
+  /**
+   * Checks if an event should be deduplicated.
+   * Returns true if this is a duplicate that should be skipped.
+   *
+   * @param fp - Event fingerprint.
+   * @returns `true` if duplicate (should skip), `false` otherwise.
+   *
+   * @internal
+   */
+  shouldDedupe(e, t) {
+    const n = Date.now(), 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
+   * the first entry is cached so the timer's lifetime tracks actual dedup use
+   * (content window or identity `dedupKey`), independent of `dedupWindowMs`.
+   *
+   * @internal
+   */
+  ensureCleanupTimer() {
+    this.eventCleanupTimer === null && (this.eventCleanupTimer = setInterval(() => {
+      this.pruneProcessedEvents(Date.now());
+    }, 5e3), this.eventCleanupTimer.unref?.());
+  }
+  /**
+   * Removes expired entries from the processed events cache.
+   *
+   * @param now - Current timestamp.
+   *
+   * @internal
+   */
+  pruneProcessedEvents(e) {
+    const t = Math.max(this.dedupConfig.windowMs, 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);
+  }
+  /**
+   * Checks if an event matches a `When` matcher.
+   *
+   * @param when - The When matcher (or undefined for "all events").
+   * @param event - The event to check.
+   * @returns `true` if the event matches, `false` otherwise.
+   *
+   * @remarks
+   * - `undefined` or missing `when` matches ALL events.
+   * - `{ any: true }` matches ALL events.
+   * - `{ keys: [...] }` matches if event's `[channel, type]` is in the array.
+   * - `{ channel: 'x' }` matches if event's channel equals 'x'.
+   * - `{ channels: ['x', 'y'] }` matches if event's channel is in the array.
+   *
+   * @internal
+   */
+  matchesWhen(e, t) {
+    return !e || "any" in e && e.any === !0 ? !0 : "keys" in e ? e.keys.some(
+      ([n, s]) => t.channel === n && t.type === s
+    ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
+  }
+  /**
+   * Extracts the middleware function from a MiddlewareInput.
+   * Handles both raw functions (legacy) and MiddlewareSpec objects.
+   *
+   * @param input - MiddlewareInput (function or spec).
+   * @returns The middleware function.
+   *
+   * @internal
+   */
+  getMiddlewareFunction(e) {
+    return typeof e == "function" ? e : e.middleware;
+  }
+  /**
+   * Gets the `when` matcher from a MiddlewareInput.
+   *
+   * @param input - MiddlewareInput (function or spec).
+   * @returns The `when` matcher, or `undefined` for raw functions (match all).
+   *
+   * @internal
+   */
+  getMiddlewareWhen(e) {
+    if (typeof e != "function")
+      return e.when;
+  }
+  /**
+   * Invokes all registered **effects** for a given event.
+   * Handles both key-based effects (O(1) lookup) and pattern-based effects (runtime matching).
+   * Errors are caught and logged.
+   *
+   * @param event - The event that was reduced.
+   * @internal
+   */
+  async notifyEffects(e) {
+    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 s(e, this.getState, this.emit);
+        } catch (i) {
+          console.error("Effect error:", i), this.onEffectError?.(i, e);
+        }
+    for (const { effect: s, when: i } of this.patternEffects)
+      if (this.matchesWhen(i, e))
+        try {
+          await s(e, this.getState, this.emit);
+        } catch (d) {
+          console.error("Effect error:", d), this.onEffectError?.(d, e);
+        }
+  }
+  /**
+   * Notifies event subscribers for a specific phase.
+   *
+   * Calls both phase-specific subscribers and 'all' subscribers.
+   * Errors are caught and logged, allowing other subscribers to continue.
+   *
+   * @param event - The event to notify about.
+   * @param phase - The phase ('committed' or 'uncommitted').
+   * @internal
+   */
+  notifyEventSubscribers(e, t) {
+    const n = `${String(e.channel)}::${String(e.type)}`, i = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(n);
+    if (i?.size)
+      for (const a of [...i]) this.invokeEventSubscriber(a, e, t);
+    const d = this.allEventSubscribers.get(n);
+    if (d?.size)
+      for (const a of [...d]) this.invokeEventSubscriber(a, e, t);
+  }
+  /**
+   * Invokes a single event-subscription handler **fire-and-forget**: synchronous
+   * throws and async rejections are logged but never block the emit pipeline.
+   * Event subscribers are notifications, not part of the committed reduce result.
+   *
+   * @internal
+   */
+  invokeEventSubscriber(e, t, n) {
+    try {
+      const s = e(t, this.getState, this.emit, n);
+      s && typeof s.then == "function" && s.catch((i) => console.error("Event subscription error:", i));
+    } catch (s) {
+      console.error("Event subscription error:", s);
+    }
+  }
+  /**
+   * Applies a reduced event to a slice and emits **precise** connector events.
+   *
+   * For each changed **leaf path** (via {@link detectChangedProps}), emits that leaf and
+   * all of its **ancestors** once (e.g., `"data"`, `"data.123"`, `"data.123.title"`).
+   *
+   * A slice whose state **is** a single value — a primitive, a `Map`/`Set`, a `Date` — has no
+   * leaf below its root, and `detectChangedProps` reports its change as the empty path `""`.
+   * That path is emitted as-is, so `connect({ reducer, property: "" })` (and any `**` pattern)
+   * hears it. It has no ancestors to walk.
+   *
+   * **State Immutability**: When a slice changes, a new state object is created via
+   * shallow spread: `{ ...this.state, [sliceName]: newSlice }`. This ensures that
+   * `this.state` reference changes, enabling efficient change detection via `===`.
+   *
+   * @param rName - Slice name being updated.
+   * @param event - Reduced event with typed payload.
+   * @returns `true` if the slice actually changed, `false` otherwise.
+   *
+   * @internal
+   */
+  /**
+   * 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);
+    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 = P(s, a);
+    if (this.state = { ...this.state, [e]: r }, this.changedPathSink)
+      for (const c of i)
+        this.changedPathSink.push(c ? `${e}.${c}` : e);
+    const f = /* @__PURE__ */ new Set();
+    for (const c of i) {
+      if (c === "") {
+        f.add("");
+        continue;
+      }
+      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;
+  }
+  /**
+   * Returns a structured introspection snapshot for DevTools UIs.
+   *
+   * @remarks
+   * Reads the internal middleware, effects, reducers, and subscriber
+   * registries and returns a plain-object summary matching the
+   * `STORE_SUBSCRIPTIONS` protocol message shape.
+   *
+   * @public
+   */
+  __devtoolsIntrospect() {
+    const e = Object.keys(this.reducers).map((a) => {
+      const r = this.patternReducers.get(a);
+      return { name: a, when: r };
+    }), t = [];
+    for (const [a, r] of this.effects) {
+      if (r.size === 0) continue;
+      const [f, c] = a.split("::");
+      for (const u of r) {
+        const l = this.effectMeta.get(u);
+        t.push({ channel: f, type: c, name: l?.name, description: l?.description });
+      }
+    }
+    for (const a of this.patternEffects) {
+      const r = this.effectMeta.get(a.effect);
+      t.push({
+        channel: "*",
+        type: "*",
+        name: r?.name,
+        description: r?.description
+      });
+    }
+    const n = [];
+    for (const a of this.middleware)
+      typeof a == "function" ? n.push({ name: a.name || void 0 }) : n.push({
+        name: a.meta?.name,
+        description: a.meta?.description,
+        when: a.when
+      });
+    const s = [];
+    for (const a of this.connectorBus.__introspect())
+      for (let r = 0; r < a.count; r++)
+        s.push({ reducer: a.channel, property: a.type });
+    const i = [];
+    for (const [a, r] of this.committedEventSubscribers) {
+      if (r.size === 0) continue;
+      const [f, c] = a.split("::");
+      for (let u = 0; u < r.size; u++)
+        i.push({ channel: f, type: c, phase: "committed" });
+    }
+    for (const [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 [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 d = this.listeners.size;
+    return {
+      reducers: e,
+      effects: t,
+      middleware: n,
+      atomic: s,
+      event: i,
+      coarse: d,
+      dedupHits: this.dedupCount,
+      queueDepth: this.reduceQueue.length + this.inFlightEffects
+    };
+  }
+  /**
+   * Applies an externally provided **whole-state** (e.g., DevTools time travel) and emits
+   * fine-grained path changes for each slice.
+   *
+   * **State Immutability**: If any slices change, a new state object is created via
+   * shallow spread. This ensures consistent immutability with {@link forwardEvent}.
+   *
+   * **Missing slices**: the snapshot should contain every slice. A slice absent
+   * from `nextPlain` is **retained at its current value** (not blanked to
+   * `undefined`, which would make `getState().<slice>` throw on next access).
+   *
+   * @param nextPlain - Plain JS object to become the new state.
+   *
+   * @internal
+   */
+  __applyExternalState(e) {
+    if (!this.replayEnabled)
+      throw new Error(
+        "[yoltra] External state apply (time-travel) is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
+      );
+    const t = this.state, n = e, s = { ...this.state };
+    let i = !1;
+    Object.keys(this.reducers).forEach((d) => {
+      const a = t?.[d], r = n?.[d];
+      if (r === void 0) {
+        process.env.NODE_ENV !== "production" && console.warn(
+          `[yoltra] External state is missing slice "${String(
+            d
+          )}"; retaining its current value. Time-travel snapshots should contain all slices.`
+        );
+        return;
+      }
+      if (a === r) return;
+      const f = P(r);
+      s[d] = f, i = !0;
+      const c = O(a, r);
+      if (c.length === 0) return;
+      const u = /* @__PURE__ */ new Set();
+      for (const l of c) {
+        if (l === "") {
+          u.add("");
+          continue;
+        }
+        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 });
+      }
+    }), i && (this.state = s), i && this.listeners.forEach((d) => d());
+  }
+  /**
+   * Replays a sequence of events from a snapshot through reducers and event
+   * subscribers ONLY. Skips dedup, middleware, and effects.
+   *
+   * This method is gated by the `devtools.allowReplay` runtime config.
+   * If replay is not enabled, this method throws.
+   *
+   * @param snapshot - The state snapshot to restore before replaying.
+   * @param events - Array of events to replay (in order).
+   *
+   * @internal
+   */
+  __replayEvents(e, t) {
+    if (!this.replayEnabled)
+      throw new Error(
+        "[yoltra] Event replay is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
+      );
+    this.__applyExternalState(e);
+    for (const n of t) {
+      const s = n, i = this.state;
+      this.reducerBus.emit(s.channel, s.type, s.payload, s);
+      for (const [r, f] of this.patternReducers)
+        this.matchesWhen(f, s) && this.forwardEventGuarded(r, s);
+      const d = this.state, a = i !== d;
+      this.notifyEventSubscribers(s, "committed"), a && this.listeners.forEach((r) => r());
+    }
+  }
+  /**
+   * Emits a typed event `(channel, type, payload)`.
+   * Events are queued and processed **sequentially** (FIFO).
+   *
+   * **Pipeline per event:** the *reduce phase* (steps 1-4) runs **synchronously**,
+   * so `getState()` reflects the change as soon as `emit()` returns; the *effect
+   * phase* (step 5) runs afterwards, asynchronously.
+   * 1. **Deduplication** (opt-in) - Skip when content-dedup is enabled (`dedupWindowMs > 0`) or a matching `dedupKey` recurs; off by default
+   * 2. **Middleware** (sync) - Pre-reducer hooks; may cancel by returning `false`
+   * 3. **Reducers** (sync) - state updates + fine-grained path notifications
+   * 4. **Subscribers + coarse** (sync) - event subscribers (fire-and-forget) then coarse listeners (only if state changed)
+   * 5. **Effects** (async) - side-effects keyed by `(channel, type)`; the returned promise resolves once they complete
+   *
+   * **Change Detection**: Uses reference equality (`===`) on `this.state` to determine
+   * if any slice changed. Works because {@link forwardEvent} creates a new state reference
+   * via shallow spread when any slice changes.
+   *
+   * @typeParam C - Channel key in `EM`.
+   * @typeParam T - Type key within channel `C`.
+   * @param channel - Channel name.
+   * @param type - Event type name.
+   * @param payload - Payload typed as `EM[C][T]`.
+   * @param opts - Optional per-emit options (e.g. `dedupKey` for identity-based dedup).
+   * @returns A promise that resolves once this event's effects have finished.
+   * State is already updated synchronously before `emit()` returns.
+   *
+   * @example Basic usage
+   * ```ts
+   * await store.emit('ui', 'increment', 1);
+   * ```
+   *
+   * @example With middleware cancellation
+   * ```ts
+   * store.registerMiddleware((state, event) => {
+   *   if (event.type === 'dangerous') return false; // cancel
+   *   return true; // allow
+   * });
+   *
+   * await store.emit('ui', 'dangerous', null); // cancelled, no state change
+   * ```
+   *
+   * @public
+   */
+  async emit(e, t, n, s) {
+    const i = s?.dedupKey, d = this.dedupConfig.windowMs;
+    if (s?.skipDedup !== !0 && (d > 0 || i !== void 0)) {
+      const c = i !== void 0 && d <= 0 ? x : d, u = i !== void 0 ? `${e}::${t}::#${i}` : this.fingerprint(e, t, n);
+      if (this.shouldDedupe(u, c))
+        return;
+    }
+    const a = s?.id ?? this.idFactory();
+    let r;
+    const f = new Promise((c) => {
+      r = c;
+    });
+    return this.reduceQueue.push({
+      channel: e,
+      type: t,
+      payload: n,
+      id: a,
+      meta: s?.meta,
+      resolve: r
+    }), this.drainReduce(), f;
+  }
+  /**
+   * Drains the reduce queue **synchronously**. For each event it runs middleware,
+   * reducers, event subscribers, and coarse listeners in the same tick, so
+   * `getState()` reflects the change the moment {@link emit} returns. Re-entrant
+   * emits (from middleware or subscribers) are appended and drained in the same
+   * pass — preserving FIFO order without interleaving reducers. Each committed
+   * event's effects then run in an independent task (see {@link runEventEffects}).
+   *
+   * @internal
+   */
+  drainReduce() {
+    if (!this.isReducing) {
+      this.isReducing = !0;
+      try {
+        for (; this.reduceQueue.length > 0; ) {
+          const { channel: e, type: t, payload: n, id: s, meta: i, resolve: d } = this.reduceQueue.shift(), a = {
+            channel: e,
+            type: t,
+            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(a);
+          } catch (y) {
+            console.error("Emit reduce error:", y);
+          } finally {
+            r && (this.changedPathSink = null);
+          }
+          r && this.emitInstrumentation(
+            a,
+            l,
+            c ?? [],
+            f,
+            z() - u
+          ), this.runEventEffects(a, l, d);
+        }
+      } finally {
+        this.isReducing = !1;
+      }
+    }
+  }
+  /**
+   * Runs the **synchronous** part of the pipeline for a single event: middleware
+   * (may veto), key- and pattern-based reducers, committed/uncommitted event
+   * subscribers (fire-and-forget), and coarse listeners.
+   *
+   * @returns `true` if the event was committed (passed middleware), `false` if a
+   * middleware vetoed it.
+   *
+   * @internal
+   */
+  applyEventSync(e) {
+    for (const s of this.middleware) {
+      const i = this.getMiddlewareWhen(s);
+      if (!this.matchesWhen(i, e)) continue;
+      const d = this.getMiddlewareFunction(s);
+      let a;
+      try {
+        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 (!a)
+        return this.notifyEventSubscribers(e, "uncommitted"), !1;
+    }
+    const t = this.state;
+    this.reducerBus.emit(
+      e.channel,
+      e.type,
+      e.payload,
+      e
+    );
+    for (const [s, i] of this.patternReducers)
+      this.matchesWhen(i, e) && this.forwardEventGuarded(s, e);
+    const n = t !== this.state;
+    return this.notifyEventSubscribers(e, "committed"), n && this.listeners.forEach((s) => s()), !0;
+  }
+  /**
+   * Runs a single committed event's effects as an **independent async task**,
+   * then resolves that event's completion deferred so `await emit(...)` settles
+   * once its effects finish. Per-event tasks (rather than one shared serialized
+   * loop) let an effect `await` a re-entrant emit without deadlocking.
+   *
+   * @internal
+   */
+  async runEventEffects(e, t, n) {
+    this.inFlightEffects++;
+    try {
+      t && await this.notifyEffects(e);
+    } catch (s) {
+      console.error("Effect error:", s);
+    } finally {
+      this.inFlightEffects--, n();
+    }
+  }
+  /**
+   * Registers an instrumentation observer. See {@link StoreInstance.instrument}.
+   *
+   * @public
+   */
+  instrument(e) {
+    return this.instrumentObservers.add(e), () => {
+      this.instrumentObservers.delete(e);
+    };
+  }
+  /**
+   * Builds an {@link InstrumentedEvent} from the reduce result and notifies
+   * observers. `changedPaths` are the exact slice-prefixed leaf paths recorded
+   * by {@link forwardEvent} during this reduce, so DevTools patches need no
+   * re-diff.
+   *
+   * @internal
+   */
+  emitInstrumentation(e, t, n, s, i) {
+    const d = {}, a = {};
+    for (const f of n)
+      d[f] = this.getAtPath(s, f), a[f] = this.getAtPath(this.state, f);
+    const r = {
+      event: {
+        id: e.id,
+        channel: e.channel,
+        type: e.type,
+        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: n,
+      prevValues: d,
+      nextValues: a,
+      reduceTimeMs: i
+    };
+    for (const f of [...this.instrumentObservers])
+      try {
+        f(r);
+      } catch (c) {
+        console.error("Instrumentation observer error:", c);
+      }
+  }
+  /**
+   * Connects a **fine-grained** listener to a dotted path under a slice.
+   *
+   * @param spec - `{ reducer, property }` where `property` is a dotted path (e.g., `"items.0.title"`).
+   *        Supports wildcards: `*` (one segment) and `**` (zero or more segments).
+   * @param h - Handler receiving a {@link Change} with `{ oldValue, newValue, path }`.
+   * @returns Unsubscribe function.
+   *
+   * @example Exact path
+   * ```ts
+   * const off = store.connect(
+   *   { reducer: 'todos', property: 'items.0.title' },
+   *   (chg) => console.log('title changed:', chg.newValue)
+   * );
+   * off();
+   * ```
+   *
+   * @example Wildcard pattern
+   * ```ts
+   * // Listen to any item title change
+   * const off = store.connect(
+   *   { reducer: 'todos', property: 'items.*.title' },
+   *   (chg) => console.log('some title changed')
+   * );
+   * ```
+   *
+   * @public
+   */
+  connect(e, t) {
+    return this.connectorBus.on(e.reducer, e.property, t);
+  }
+  /**
+   * Subscribe to events by channel and type.
+   *
+   * Event subscriptions are intended for the View layer (e.g., React components)
+   * to react to events without affecting the event flow. They are fire-and-forget
+   * and cannot cancel event propagation.
+   *
+   * **Phases:**
+   * - `'committed'` (default): Events that passed middleware and reached reducers.
+   *   Notified after reducers, before effects.
+   * - `'uncommitted'`: Events rejected by middleware. Notified immediately after rejection.
+   * - `'all'`: Both committed and uncommitted events. Handler receives the phase parameter
+   *   to distinguish between the two.
+   *
+   * @typeParam C - Channel key within `EM`.
+   * @typeParam T - Event type key within channel `C`.
+   * @param channel - Channel to subscribe to.
+   * @param type - Event type to subscribe to.
+   * @param handler - Handler function `(event, getState, emit, phase)`.
+   * @param phase - Event phase to subscribe to (default: `'committed'`).
+   * @returns Unsubscribe function.
+   *
+   * @example Committed events (default)
+   * ```ts
+   * const off = store.onEvent('ui', 'save', (event, getState, emit, phase) => {
+   *   console.log('Save committed:', event.payload);
+   * });
+   * off();
+   * ```
+   *
+   * @example Uncommitted (rejected) events
+   * ```ts
+   * store.onEvent('ui', 'delete', (event, getState, emit, phase) => {
+   *   console.log('Delete was rejected by middleware');
+   * }, 'uncommitted');
+   * ```
+   *
+   * @example All events
+   * ```ts
+   * store.onEvent('ui', 'action', (event, getState, emit, phase) => {
+   *   console.log('Action:', phase); // 'committed' or 'uncommitted'
+   * }, 'all');
+   * ```
+   *
+   * @public
+   */
+  onEvent(e, t, n, s = "committed") {
+    const i = `${e}::${String(t)}`, d = s === "committed" ? this.committedEventSubscribers : s === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
+    return d.has(i) || d.set(i, /* @__PURE__ */ new Set()), d.get(i).add(n), () => {
+      const a = d.get(i);
+      a && (a.delete(n), a.size === 0 && d.delete(i));
+    };
+  }
+  /**
+   * Subscribes to **coarse-grained** commits (called once per successful event, only if state changed).
+   *
+   * **Use Case**: React's `useSyncExternalStore` or similar external store integrations.
+   *
+   * @param fn - Listener invoked after reducers/effects have run and state has changed.
+   * @returns Unsubscribe function.
+   *
+   * @example
+   * ```ts
+   * const off = store.subscribe(() => console.log('state committed'));
+   * // Later:
+   * off();
+   * ```
+   *
+   * @public
+   */
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  /**
+   * Returns the current immutable state snapshot.
+   *
+   * @returns Deep-readonly state object.
+   *
+   * @example
+   * ```ts
+   * const state = store.getState();
+   * console.log(state.counter.value);
+   * ```
+   *
+   * @public
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Registers a middleware (runs **before** reducers).
+   *
+   * @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((state, event) => {
+   *   console.log('Event:', event.channel, event.type, event.payload);
+   *   return true; // allow
+   * });
+   * off();
+   * ```
+   *
+   * @example Cancellation middleware
+   * ```ts
+   * store.registerMiddleware((state, event) => {
+   *   if (event.type === 'forbidden') return false; // cancel
+   *   return true;
+   * });
+   * ```
+   *
+   * @public
+   */
+  registerMiddleware(e) {
+    return this.middleware.push(e), () => {
+      const t = this.middleware.indexOf(e);
+      t !== -1 && this.middleware.splice(t, 1);
+    };
+  }
+  /**
+   * Dynamically **adds** a named slice reducer at runtime.
+   *
+   * @param name - New slice name (must not already exist).
+   * @param spec - Reducer spec (state, when, reducer).
+   * @returns Disposer function that **removes** the slice (and its state).
+   *
+   * @example
+   * ```ts
+   * const dispose = store.registerReducer('filters', {
+   *   state: { q: '' },
+   *   events: [['ui', 'setQuery']],
+   *   reducer(s, evt) {
+   *     return evt.type === 'setQuery' ? { q: evt.payload } : s;
+   *   }
+   * });
+   * // Later:
+   * dispose();
+   * ```
+   *
+   * @public
+   */
+  registerReducer(e, t) {
+    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((n) => n()), () => {
+      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((n) => n());
+    };
+  }
+  /**
+   * Registers an **effect** (stateless async event consumer) that runs after reducers.
+   *
+   * Effects are **keyed** by `(channel, type)` for O(1) lookup (no scanning all effects).
+   *
+   * @param spec - Effect specification with `when` targeting and `effect` (handler).
+   * @returns Unsubscribe function.
+   *
+   * @example Logging effect
+   * ```ts
+   * const off = store.registerEffect({
+   *   events: [['ui', 'increment']],
+   *   effect: async (evt, getState, emit) => {
+   *     console.log('increment', evt.payload, getState().counter.value);
+   *   }
+   * });
+   * off();
+   * ```
+   *
+   * @example Multi-event effect
+   * ```ts
+   * store.registerEffect({
+   *   events: [['ui', 'increment'], ['ui', 'decrement']],
+   *   effect: async (evt, getState, emit) => {
+   *     // Runs for both increment and decrement
+   *     await saveToServer(getState());
+   *   }
+   * });
+   * ```
+   *
+   * @public
+   */
+  registerEffect(e) {
+    const { effect: t, meta: n, when: s } = e, i = [];
+    if (n && this.effectMeta.set(t, n), s && ("any" in s && s.any === !0 || "channel" in s || "channels" in s)) {
+      const r = { effect: t, when: s };
+      return this.patternEffects.add(r), () => {
+        this.patternEffects.delete(r);
+      };
+    }
+    const 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 [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 r of i) r();
+    };
+  }
+  /**
+   * Convenience helper to register an **effect** filtered by a single `(channel, type)` pair.
+   *
+   * @typeParam C - Channel key within `EM`.
+   * @typeParam T - Event type key within channel `C`.
+   * @param channel - Channel to filter.
+   * @param type - Event type to filter.
+   * @param handler - Effect handler `(payload, getState, emit, event)`.
+   * @returns Unsubscribe/teardown function.
+   *
+   * @example
+   * ```ts
+   * const off = store.onEffect('ui', 'increment', async (n, get, emit) => {
+   *   if (n > 10) await emit('ui', 'increment', -10);
+   * });
+   * // later
+   * off();
+   * ```
+   *
+   * @public
+   */
+  onEffect(e, t, n) {
+    const s = async (i, d, a) => {
+      if (i.channel !== e || i.type !== t) return;
+      const r = i;
+      return n(r.payload, d, a, r);
+    };
+    return this.registerEffect({
+      when: { keys: [[e, t]] },
+      effect: s
+    });
+  }
+  /**
+   * Replaces the **entire** middleware pipeline (HMR-friendly).
+   *
+   * @param next - New middleware array.
+   *
+   * @example Hot module replacement
+   * ```ts
+   * if (import.meta.hot) {
+   *   import.meta.hot.accept('./middleware', (newModule) => {
+   *     store.replaceMiddleware(newModule.middleware);
+   *   });
+   * }
+   * ```
+   *
+   * @public
+   */
+  replaceMiddleware(e) {
+    this.middleware.length = 0;
+    for (const t of e) this.middleware.push(t);
+  }
+  /**
+   * Replaces all registered **effects** (HMR-friendly).
+   *
+   * @param next - New effects array (as EffectSpecs).
+   *
+   * @example Hot module replacement
+   * ```ts
+   * if (import.meta.hot) {
+   *   import.meta.hot.accept('./effects', (newModule) => {
+   *     store.replaceEffects(newModule.effects);
+   *   });
+   * }
+   * ```
+   *
+   * @public
+   */
+  replaceEffects(e) {
+    this.effects.clear(), this.patternEffects.clear();
+    for (const t of e)
+      this.registerEffect(t);
+  }
+  /**
+   * Replaces the entire **reducer set** (HMR-friendly).
+   *
+   * @param next - Map of slice specs keyed by slice name.
+   * @param opts - `{ preserveState?: boolean }` (default `true`).
+   *
+   * @example Hot module replacement
+   * ```ts
+   * if (import.meta.hot) {
+   *   import.meta.hot.accept('./reducers', (newModule) => {
+   *     store.replaceReducers(newModule.reducers, { preserveState: true });
+   *   });
+   * }
+   * ```
+   *
+   * @public
+   */
+  replaceReducers(e, t = {}) {
+    const n = t.preserveState !== !1, s = new Set(Object.keys(this.reducers)), i = Object.entries(e), d = new Set(i.map(([a]) => a));
+    for (const a of s)
+      d.has(a) || this.unmountSlice(a, { deleteState: !0 });
+    for (const [a, r] of i)
+      s.has(a) ? (this.unmountSlice(a, { deleteState: !1 }), this.mountSlice(a, r, { preserveState: n })) : this.mountSlice(a, r, { preserveState: !1 });
+  }
+  /**
+   * Convenience API to replace **any subset** of store parts (HMR patterns).
+   *
+   * @param partial - Partial replacement set.
+   *
+   * @example Replace everything
+   * ```ts
+   * store.hotReplace({
+   *   reducer: newReducers,
+   *   middleware: newMiddleware,
+   *   effects: newEffects,
+   *   preserveState: true
+   * });
+   * ```
+   *
+   * @public
+   */
+  hotReplace(e) {
+    e.middleware && this.replaceMiddleware(e.middleware), e.effects && this.replaceEffects(e.effects), e.reducer && this.replaceReducers(e.reducer, { preserveState: e.preserveState });
+  }
+  /**
+   * Mounts a slice: installs reducer, initializes state (unless preserved),
+   * and wires `(channel, type)` listeners on the reducer bus.
+   *
+   * @param name - Slice name.
+   * @param rSpec - Reducer spec (state, when, reducer).
+   * @param opts - `{ preserveState: boolean }` whether to keep existing state.
+   *
+   * @internal
+   */
+  mountSlice(e, t, n) {
+    const s = e, { reducer: i, state: d, when: a } = t;
+    if (this.reducers[e] = new K(i), (!n.preserveState || this.state[s] === void 0) && (this.state = {
+      ...this.state,
+      [s]: P(W(s, d))
+    }), a && ("any" in a && a.any === !0 || "channel" in a || "channels" in a)) {
+      this.patternReducers.set(e, a), this.sliceUnsubs.set(s, []);
+      return;
+    }
+    const f = this.normalizeEventKeys(t);
+    if (f.length === 0 && !a) {
+      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(s, []);
+      return;
+    }
+    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);
+      });
+      c.push(y);
+    }
+    this.sliceUnsubs.set(s, c);
+  }
+  /**
+   * Unmounts a slice: disposes reducer-bus listeners, removes reducer,
+   * and optionally deletes the slice state.
+   *
+   * @param name - Slice name.
+   * @param opts - `{ deleteState: boolean }`.
+   *
+   * @internal
+   */
+  unmountSlice(e, t) {
+    const n = e;
+    this.patternReducers.delete(e);
+    const s = this.sliceUnsubs.get(n);
+    if (s) {
+      for (const i of s)
+        try {
+          i();
+        } catch (d) {
+          console.error(`[Store error]: ${d}`);
+        }
+      this.sliceUnsubs.delete(n);
+    }
+    if (delete this.reducers[e], t.deleteState) {
+      const { [n]: i, ...d } = this.state;
+      this.state = d;
+    }
+  }
+  /**
+   * Normalizes event targeting from `when` to an array of EventKeys.
+   *
+   * @param spec - Object with an optional `when` matcher.
+   * @returns Array of `[channel, type]` pairs.
+   *
+   * @internal
+   */
+  normalizeEventKeys(e) {
+    if (e.when) {
+      const t = e.when;
+      if ("keys" in t)
+        return t.keys;
+    }
+    return [];
+  }
+  /**
+   * Reads a dotted path from an object (supports numeric array indices via string keys).
+   *
+   * @param obj - Root object (slice or value).
+   * @param path - Dotted path; leading dot is ignored.
+   * @returns The value at the path, or `undefined`.
+   *
+   * @internal
+   */
+  getAtPath(e, t) {
+    if (!t) return e;
+    const s = (t[0] === "." ? t.slice(1) : t).split(".");
+    let i = e;
+    for (const d of s) {
+      if (i == null) return;
+      i = i[d];
+    }
+    return i;
+  }
+  /**
+   * Builds ancestor paths for a dotted path.
+   *
+   * For `"a.b.c"`, returns `["a", "a.b", "a.b.c"]`. Leading dots are trimmed.
+   *
+   * @param path - Dotted path string.
+   * @returns Array of ancestor paths.
+   *
+   * @example
+   * ```ts
+   * Store.buildAncestorPaths('x.y.z'); // ['x','x.y','x.y.z']
+   * ```
+   *
+   * @public
+   */
+  static buildAncestorPaths(e) {
+    if (!e) return [];
+    const n = (e[0] === "." ? e.slice(1) : e).split("."), s = [];
+    for (let i = 0; i < n.length; i++)
+      s.push(n.slice(0, i + 1).join("."));
+    return s;
+  }
+}
+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 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}/${A(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}/${A(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 A(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 N(o, e) {
+  const t = o ?? {}, n = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((s) => s in t).map((s) => [s, t[s]]));
+  return JSON.stringify(_({ version: e.version, slices: n }).value);
+}
+function 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, N(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 N(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 {
+  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.mjs.map