@yoltra/core 0.3.0 → 0.5.0

package/dist/yoltra.esm.js

@@ -1,1744 +0,0 @@
-/*!
- * @yoltra/core v0.3.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 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 {
-  constructor() {
-    /**
-     * Internal registry: `channel → type → Set<handler>`.
-     * @internal
-     */
-    d(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]`.
-   * @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();
-   * ```
-   *
-   * @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);
-  }
-  /**
-   * 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, 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));
-  }
-  /**
-   * 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]`.
-   *
-   * @example
-   * ```ts
-   * bus.emit('ui', 'toggle', false);
-   * ```
-   *
-   * @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])
-        try {
-          c(r);
-        } catch (i) {
-          console.error("EventBus handler error:", i);
-        }
-  }
-  /**
-   * 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 k {
-  constructor() {
-    /**
-     * Exact handlers: `channel → type → [handlers]`.
-     * @internal
-     */
-    d(this, "handlers", /* @__PURE__ */ new Map());
-    /**
-     * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
-     * @internal
-     */
-    d(this, "patternHandlers", /* @__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, r) {
-    const n = String(t);
-    if (this.isPattern(n)) {
-      const s = n;
-      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);
-    } else {
-      const s = this.normalizeTypeKey(n);
-      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);
-    }
-  }
-  /**
-   * 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, r) {
-    const n = this.normalizeTypeKey(String(t));
-    this.offExactNormalized(e, n, r);
-  }
-  /**
-   * 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, r) {
-    const n = this.handlers.get(e);
-    if (!n) return;
-    const s = n.get(t);
-    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);
-  }
-  /**
-   * 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, r) {
-    const n = this.patternHandlers.get(e);
-    if (!n) return;
-    const s = n.get(t);
-    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);
-  }
-  /**
-   * 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, 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);
-          try {
-            u(r);
-          } catch (p) {
-            console.error(p);
-            continue;
-          }
-        }
-    };
-    h(c);
-    for (const l of o) h(l);
-  }
-  /**
-   * 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);
-  }
-  /**
-   * Pattern matcher over dot-separated segments.
-   *
-   * 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`.
-   *
-   * @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
-   * ```
-   *
-   * @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++;
-      else if (i !== -1)
-        s = i + 1, c = ++o;
-      else
-        return !1;
-    for (; s < r.length && r[s] === "**"; ) s++;
-    return s === r.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();
-  }
-  /**
-   * 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, 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 });
-    return e;
-  }
-}
-class _ {
-  /**
-   * 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
-     */
-    d(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);
-  }
-}
-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);
-  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 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);
-        continue;
-      }
-      h.push(...g(a[u], e[u], p, r));
-    }
-    return h.filter(Boolean);
-  } finally {
-    i.delete(s), i.size === 0 && r.delete(n);
-  }
-}
-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 b(a) {
-  return process.env.NODE_ENV === "production" ? a : E(a);
-}
-const w = 100, S = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
-class v {
-  /**
-   * 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
-     */
-    d(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
-     */
-    d(this, "middleware");
-    /**
-     * Installed slice reducers keyed by slice name.
-     *
-     * @internal
-     */
-    d(this, "reducers");
-    /**
-     * Current immutable snapshot of the store state.
-     * This reference changes whenever any slice changes (shallow immutability).
-     *
-     * @internal
-     */
-    d(this, "state");
-    /**
-     * Bus for reducer wiring (emit by `(channel, type)`).
-     *
-     * @internal
-     */
-    d(this, "reducerBus");
-    /**
-     * Bus for **granular** connector events (emit by **dotted path** inside a slice).
-     *
-     * @internal
-     */
-    d(this, "connectorBus");
-    /**
-     * Coarse-grained listeners (called once per committed event, only if state changed).
-     *
-     * @internal
-     */
-    d(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.
-     *
-     * @internal
-     */
-    d(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
-     */
-    d(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());
-    /**
-     * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
-     * Notified when middleware rejects an event.
-     *
-     * @internal
-     */
-    d(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());
-    /**
-     * Track reducerBus unsubs per slice for HMR/register/unregister.
-     *
-     * @internal
-     */
-    d(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
-     */
-    d(this, "patternReducers", /* @__PURE__ */ new Map());
-    /**
-     * Whether `__replayEvents()` is allowed.
-     * Set from `spec.devtools.allowReplay`.
-     *
-     * @internal
-     */
-    d(this, "replayEnabled");
-    /**
-     * 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");
-    /**
-     * Pending events awaiting the **synchronous** reduce phase (middleware +
-     * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
-     *
-     * @internal
-     */
-    d(this, "reduceQueue", []);
-    /**
-     * Re-entrancy guard for the synchronous reduce phase.
-     *
-     * @internal
-     */
-    d(this, "isReducing", !1);
-    /**
-     * Registered instrumentation observers (DevTools seam). See {@link instrument}.
-     *
-     * @internal
-     */
-    d(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
-     */
-    d(this, "changedPathSink", null);
-    /**
-     * Count of effect tasks currently in flight; surfaced as queue depth by
-     * {@link __devtoolsIntrospect}.
-     *
-     * @internal
-     */
-    d(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
-     */
-    d(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
-     */
-    d(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
-     */
-    d(this, "effectMeta", /* @__PURE__ */ new WeakMap());
-    /**
-     * Configuration for event deduplication.
-     * @internal
-     */
-    d(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 = {
-      windowMs: e.dedupWindowMs ?? 0,
-      maxCacheSize: 1e3
-    }, Object.entries(e.reducer).forEach(([t, r]) => {
-      this.mountSlice(t, r, { 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.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, r) {
-    const n = `${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}`;
-    } catch {
-      return `${n}::${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 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);
-  }
-  /**
-   * 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, w), r = e - t * 2;
-    for (const [n, s] of this.processedEvents)
-      s < r && this.processedEvents.delete(n);
-    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(
-      ([r, n]) => t.channel === r && t.type === n
-    ) : "channel" in e ? t.channel === e.channel : "channels" in e ? e.channels.includes(t.channel) : !1;
-  }
-  /**
-   * Extracts the middleware function from a MiddlewareInput.
-   * Handles both raw functions (legacy) and MiddlewareSpec objects.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The middleware function.
-   *
-   * @internal
-   */
-  getMiddlewareFunction(e) {
-    return typeof e == "function" ? e : e.middleware;
-  }
-  /**
-   * Gets the `when` matcher from a MiddlewareInput.
-   *
-   * @param input - MiddlewareInput (function or spec).
-   * @returns The `when` matcher, or `undefined` for raw functions (match all).
-   *
-   * @internal
-   */
-  getMiddlewareWhen(e) {
-    if (typeof e != "function")
-      return e.when;
-  }
-  /**
-   * Invokes all registered **effects** for a given event.
-   * Handles both key-based effects (O(1) lookup) and pattern-based effects (runtime matching).
-   * Errors are caught and logged.
-   *
-   * @param event - The event that was reduced.
-   * @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])
-        try {
-          await n(e, this.getState, this.emit);
-        } catch (s) {
-          console.error("Effect error:", s), this.onEffectError?.(s, e);
-        }
-    for (const { effect: n, when: s } of this.patternEffects)
-      if (this.matchesWhen(s, e))
-        try {
-          await n(e, this.getState, this.emit);
-        } catch (c) {
-          console.error("Effect error:", c), this.onEffectError?.(c, 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 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);
-  }
-  /**
-   * 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, r) {
-    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);
-    }
-  }
-  /**
-   * 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"`).
-   *
-   * **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
-   */
-  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 });
-    }
-    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((i) => {
-      const o = this.patternReducers.get(i);
-      return { name: i, when: o };
-    }), 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 i of this.patternEffects) {
-      const o = this.effectMeta.get(i.effect);
-      t.push({
-        channel: "*",
-        type: "*",
-        name: o?.name,
-        description: o?.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 });
-    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 [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 [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" });
-    }
-    const c = this.listeners.size;
-    return {
-      reducers: e,
-      effects: t,
-      middleware: r,
-      atomic: n,
-      event: s,
-      coarse: c,
-      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) {
-      console.warn(
-        "[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) {
-        process.env.NODE_ENV !== "production" && console.warn(
-          `[yoltra] External state is missing slice "${String(
-            c
-          )}"; 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 });
-      }
-    }), s && (this.state = n), s && this.listeners.forEach((c) => c());
-  }
-  /**
-   * 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 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());
-    }
-  }
-  /**
-   * 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, 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))
-        return;
-    }
-    const i = crypto.randomUUID();
-    let o;
-    const f = new Promise((h) => {
-      o = h;
-    });
-    return this.reduceQueue.push({
-      channel: e,
-      type: t,
-      payload: r,
-      id: i,
-      resolve: o
-    }), 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: 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;
-          let l = !1;
-          try {
-            l = this.applyEventSync(c);
-          } catch (u) {
-            console.error("Emit reduce error:", u);
-          } finally {
-            i && (this.changedPathSink = null);
-          }
-          i && this.emitInstrumentation(
-            c,
-            l,
-            f,
-            o,
-            S() - h
-          ), this.runEventEffects(c, l, s);
-        }
-      } 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 n of this.middleware) {
-      const s = this.getMiddlewareWhen(n);
-      if (!this.matchesWhen(s, e)) continue;
-      const c = this.getMiddlewareFunction(n);
-      let i;
-      try {
-        i = c(this.state, e, this.emit);
-      } catch (o) {
-        console.error("Middleware error:", o), i = !1;
-      }
-      if (!i)
-        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;
-  }
-  /**
-   * 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, r) {
-    this.inFlightEffects++;
-    try {
-      t && await this.notifyEffects(e);
-    } catch (n) {
-      console.error("Effect error:", n);
-    } finally {
-      this.inFlightEffects--, r();
-    }
-  }
-  /**
-   * 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, 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 = {
-      event: {
-        id: e.id,
-        channel: e.channel,
-        type: e.type,
-        payload: e.payload
-      },
-      committed: t,
-      changedPaths: r,
-      prevValues: c,
-      nextValues: i,
-      reduceTimeMs: s
-    };
-    for (const f of [...this.instrumentObservers])
-      try {
-        f(o);
-      } catch (h) {
-        console.error("Instrumentation observer error:", h);
-      }
-  }
-  /**
-   * 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, 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));
-    };
-  }
-  /**
-   * 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|Promise<boolean>`.
-   *        Return `false` to cancel event propagation.
-   * @returns Unsubscribe function that removes this middleware.
-   *
-   * @example Logging middleware
-   * ```ts
-   * const off = store.registerMiddleware(async (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, events, 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 (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());
-    };
-  }
-  /**
-   * 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 `events` (EventKeys) 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: 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 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);
-      };
-    }
-    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));
-      });
-    }
-    return () => {
-      for (const o of s) o();
-    };
-  }
-  /**
-   * 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, 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);
-    };
-    return this.registerEffect({
-      events: [[e, t]],
-      effect: n
-    });
-  }
-  /**
-   * 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 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 });
-  }
-  /**
-   * 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, events, 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, []);
-      return;
-    }
-    const h = this.normalizeEventKeys(t);
-    if (h.length === 0 && !o && !s) {
-      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
-      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);
-      });
-      l.push(y);
-    }
-    this.sliceUnsubs.set(n, l);
-  }
-  /**
-   * 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 r = e;
-    this.patternReducers.delete(e);
-    const n = this.sliceUnsubs.get(r);
-    if (n) {
-      for (const s of n)
-        try {
-          s();
-        } catch (c) {
-          console.error(`[Store error]: ${c}`);
-        }
-      this.sliceUnsubs.delete(r);
-    }
-    delete this.reducers[e], t.deleteState && delete this.state[r];
-  }
-  /**
-   * Normalizes event targeting from `when` or legacy `events` to an array of EventKeys.
-   *
-   * @param spec - Object with optional `when` and/or `events` properties.
-   * @returns Array of `[channel, type]` pairs.
-   *
-   * @internal
-   */
-  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 : [];
-  }
-  /**
-   * 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 n = (t[0] === "." ? t.slice(1) : t).split(".");
-    let s = e;
-    for (const c of n) {
-      if (s == null) return;
-      s = s[c];
-    }
-    return s;
-  }
-  /**
-   * 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 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;
-  }
-}
-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
-  });
-}
-const $ = (a) => (e, t) => t.map((r) => [e, r]), B = () => (a) => a;
-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
-};
-//# sourceMappingURL=yoltra.esm.js.map