@yoltra/core 0.1.0

package/dist/yoltra.esm.js

@@ -0,0 +1,1557 @@
+/*!
+ * @yoltra/core v0.1.0
+ * (c) 2026 Manu Ramirez <@pixerael>
+ * License: MIT
+ * Homepage: https://yoltra.dev
+ */
+var M = Object.defineProperty;
+var P = (a, e, t) => e in a ? M(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var u = (a, e, t) => P(a, typeof e != "symbol" ? e + "" : e, t);
+class z {
+  constructor() {
+    /**
+     * Internal registry: `channel → type → Set<handler>`.
+     * @internal
+     */
+    u(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, s) {
+    let n = this.handlers.get(e);
+    n || (n = /* @__PURE__ */ new Map(), this.handlers.set(e, n));
+    let r = n.get(t);
+    return r || (r = /* @__PURE__ */ new Set(), n.set(t, r)), r.add(s), () => this.off(e, t, s);
+  }
+  /**
+   * 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, s) {
+    const n = this.handlers.get(e);
+    if (!n) return;
+    const r = n.get(t);
+    r && (r.delete(s), r.size === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e));
+  }
+  /**
+   * 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, s) {
+    const n = this.handlers.get(e);
+    if (!n) return;
+    const r = n.get(t);
+    if (!(!r || r.size === 0))
+      for (const o of [...r])
+        try {
+          o(s);
+        } 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
+     */
+    u(this, "handlers", /* @__PURE__ */ new Map());
+    /**
+     * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
+     * @internal
+     */
+    u(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, s) {
+    const n = String(t);
+    if (this.isPattern(n)) {
+      const r = n;
+      this.patternHandlers.has(e) || this.patternHandlers.set(e, /* @__PURE__ */ new Map());
+      const o = this.patternHandlers.get(e);
+      return o.has(r) || o.set(r, []), o.get(r).push(s), () => this.offPattern(e, r, s);
+    } else {
+      const r = this.normalizeTypeKey(n);
+      this.handlers.has(e) || this.handlers.set(e, /* @__PURE__ */ new Map());
+      const o = this.handlers.get(e);
+      return o.has(r) || o.set(r, []), o.get(r).push(s), () => this.offExactNormalized(e, r, s);
+    }
+  }
+  /**
+   * 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, s) {
+    const n = this.normalizeTypeKey(String(t));
+    this.offExactNormalized(e, n, s);
+  }
+  /**
+   * 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, s) {
+    const n = this.handlers.get(e);
+    if (!n) return;
+    const r = n.get(t);
+    if (!r) return;
+    const o = r.indexOf(s);
+    o !== -1 && r.splice(o, 1), r.length === 0 && n.delete(t), n.size === 0 && this.handlers.delete(e);
+  }
+  /**
+   * 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, s) {
+    const n = this.patternHandlers.get(e);
+    if (!n) return;
+    const r = n.get(t);
+    if (!r) return;
+    const o = r.indexOf(s);
+    o !== -1 && r.splice(o, 1), r.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, s) {
+    const n = String(t), r = this.normalizeTypeKey(n), o = this.handlers.get(e)?.get(r) ?? [], i = this.patternHandlers.get(e), c = [];
+    if (i && i.size) {
+      const l = this.normalizeTypeKey(n);
+      for (const [p, d] of i.entries())
+        this.matchPattern(p, l) && c.push(d);
+    }
+    const f = /* @__PURE__ */ new Set(), h = (l) => {
+      for (const p of [...l])
+        if (!f.has(p)) {
+          f.add(p);
+          try {
+            p(s);
+          } catch (d) {
+            console.error(d);
+            continue;
+          }
+        }
+    };
+    h(o);
+    for (const l of c) 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 s = this.splitPath(e), n = this.splitPath(t);
+    let r = 0, o = 0;
+    for (; r < s.length && o < n.length; ) {
+      const i = s[r];
+      if (i === "**") {
+        if (r === s.length - 1 || s.slice(r).filter((f) => f !== "**").length === 0) return !0;
+        for (let f = o; f <= n.length; f++)
+          if (this.matchPattern(s.slice(r + 1).join("."), n.slice(f).join(".")))
+            return !0;
+        return !1;
+      }
+      if (i === "*" || i === n[o]) {
+        r++, o++;
+        continue;
+      }
+      return !1;
+    }
+    if (o === n.length) {
+      for (; r < s.length; r++)
+        if (s[r] !== "**") return !1;
+      return !0;
+    }
+    return !1;
+  }
+  /**
+   * 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, s] of this.handlers)
+      for (const [n, r] of s)
+        r.length > 0 && e.push({ channel: t, type: n, count: r.length });
+    for (const [t, s] of this.patternHandlers)
+      for (const [n, r] of s)
+        r.length > 0 && e.push({ channel: t, type: n, count: r.length });
+    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
+     */
+    u(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 b(a, e, t = "", s = /* @__PURE__ */ new WeakMap()) {
+  if (a === e) return [];
+  if (typeof a != "object" || typeof e != "object" || a === null || e === null)
+    return [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, r = e;
+  let o = s.get(n);
+  if (o) {
+    if (o.has(r)) return [];
+    o.add(r);
+  } else
+    o = /* @__PURE__ */ new WeakSet(), o.add(r), s.set(n, o);
+  const i = Array.isArray(a), c = Array.isArray(e);
+  if (i !== c) return [t];
+  const f = [];
+  if (i) {
+    const d = a, m = e;
+    if (d.length !== m.length) return [t];
+    for (let y = 0; y < d.length; y++) {
+      const g = t ? `${t}.${y}` : `${y}`, E = b(d[y], m[y], g, s);
+      f.push(...E);
+    }
+    return f.filter(Boolean);
+  }
+  const h = Object.keys(a), l = Object.keys(e), p = /* @__PURE__ */ new Set([...h, ...l]);
+  for (const d of p) {
+    const m = t ? `${t}.${d}` : d, y = Object.prototype.hasOwnProperty.call(a, d), g = Object.prototype.hasOwnProperty.call(e, d);
+    if (!y) {
+      f.push(m);
+      continue;
+    }
+    if (!g) {
+      f.push(m);
+      continue;
+    }
+    const E = b(a[d], e[d], m, s);
+    f.push(...E);
+  }
+  return f.filter(Boolean);
+}
+function w(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 s = 0; s < t.length; s++)
+      t[s] = w(t[s], e);
+    return Object.freeze(t);
+  }
+  for (const t of Object.getOwnPropertyNames(a)) {
+    const s = Object.getOwnPropertyDescriptor(a, t);
+    !s || !("value" in s) || (a[t] = w(a[t], e));
+  }
+  for (const t of Object.getOwnPropertySymbols(a)) {
+    const s = Object.getOwnPropertyDescriptor(a, t);
+    !s || !("value" in s) || (a[t] = w(a[t], e));
+  }
+  return Object.freeze(a);
+}
+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
+     */
+    u(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
+     */
+    u(this, "middleware");
+    /**
+     * Installed slice reducers keyed by slice name.
+     *
+     * @internal
+     */
+    u(this, "reducers");
+    /**
+     * Current immutable snapshot of the store state.
+     * This reference changes whenever any slice changes (shallow immutability).
+     *
+     * @internal
+     */
+    u(this, "state");
+    /**
+     * Bus for reducer wiring (emit by `(channel, type)`).
+     *
+     * @internal
+     */
+    u(this, "reducerBus");
+    /**
+     * Bus for **granular** connector events (emit by **dotted path** inside a slice).
+     *
+     * @internal
+     */
+    u(this, "connectorBus");
+    /**
+     * Coarse-grained listeners (called once per committed event, only if state changed).
+     *
+     * @internal
+     */
+    u(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
+     */
+    u(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
+     */
+    u(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
+     */
+    u(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified when middleware rejects an event.
+     *
+     * @internal
+     */
+    u(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
+     */
+    u(this, "allEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * Track reducerBus unsubs per slice for HMR/register/unregister.
+     *
+     * @internal
+     */
+    u(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
+     */
+    u(this, "patternReducers", /* @__PURE__ */ new Map());
+    /**
+     * Whether `__replayEvents()` is allowed.
+     * Set from `spec.devtools.allowReplay`.
+     *
+     * @internal
+     */
+    u(this, "replayEnabled");
+    /**
+     * FIFO event queue for serialized emission.
+     *
+     * @internal
+     */
+    u(this, "eventQueue", []);
+    /**
+     * Re-entrancy guard while draining the queue.
+     *
+     * @internal
+     */
+    u(this, "isProcessingQueue", !1);
+    /**
+     * 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
+     */
+    u(this, "processedEvents", /* @__PURE__ */ new Map());
+    /**
+     * Configuration for event deduplication.
+     * @internal
+     */
+    u(this, "dedupConfig");
+    /**
+     * Timer for periodic cleanup of processed events.
+     *
+     * @internal
+     */
+    u(this, "eventCleanupTimer", null);
+    this.name = e.name ?? "yoltra Store", this.reducerBus = new z(), this.connectorBus = new k(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1;
+    const t = process.env.NODE_ENV === "production" ? 100 : 50;
+    if (this.dedupConfig = {
+      windowMs: e.dedupWindowMs ?? t,
+      maxCacheSize: 1e3
+    }, Object.entries(e.reducer).forEach(([s, n]) => {
+      this.mountSlice(s, n, { preserveState: !1 });
+    }), e.effects?.length)
+      for (const s of e.effects)
+        this.registerEffect(s);
+    this.eventCleanupTimer = setInterval(() => {
+      this.pruneProcessedEvents(Date.now());
+    }, 5e3), 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();
+  }
+  /**
+   * 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, s) {
+    const n = `${e}::${t}`;
+    try {
+      if (s == null)
+        return `${n}::null`;
+      if (typeof s != "object")
+        return `${n}::${String(s)}`;
+      const r = JSON.stringify(s);
+      return `${n}::${r}`;
+    } catch {
+      return `${n}::${Date.now()}::${Math.random()}`;
+    }
+  }
+  /**
+   * 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) {
+    const t = Date.now(), s = this.processedEvents.get(e);
+    return s !== void 0 && t - s < this.dedupConfig.windowMs ? !0 : (this.processedEvents.set(e, t), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(t), !1);
+  }
+  /**
+   * Removes expired entries from the processed events cache.
+   *
+   * @param now - Current timestamp.
+   *
+   * @internal
+   */
+  pruneProcessedEvents(e) {
+    const t = e - this.dedupConfig.windowMs * 2;
+    for (const [s, n] of this.processedEvents)
+      n < t && this.processedEvents.delete(s);
+  }
+  /**
+   * 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(
+      ([s, n]) => t.channel === s && 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)}`, s = this.effects.get(t);
+    if (s && s.size > 0)
+      for (const n of [...s])
+        try {
+          await n(e, this.getState, this.emit);
+        } catch (r) {
+          console.error("Effect error:", r);
+        }
+    for (const { effect: n, when: r } of this.patternEffects)
+      if (this.matchesWhen(r, e))
+        try {
+          await n(e, this.getState, this.emit);
+        } catch (o) {
+          console.error("Effect error:", o);
+        }
+  }
+  /**
+   * 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
+   */
+  async notifyEventSubscribers(e, t) {
+    const s = `${String(e.channel)}::${String(e.type)}`, r = (t === "committed" ? this.committedEventSubscribers : this.uncommittedEventSubscribers).get(s);
+    if (r?.size)
+      for (const i of [...r])
+        try {
+          await i(e, this.getState, this.emit, t);
+        } catch (c) {
+          console.error("Event subscription error:", c);
+        }
+    const o = this.allEventSubscribers.get(s);
+    if (o?.size)
+      for (const i of [...o])
+        try {
+          await i(e, this.getState, this.emit, t);
+        } catch (c) {
+          console.error("Event subscription error:", c);
+        }
+  }
+  /**
+   * 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 s = this.state[e], n = this.reducers[e].reduce(s, t);
+    if (s === n) return !1;
+    const r = b(s, n).filter(Boolean);
+    if (r.length === 0) return !1;
+    const o = w(structuredClone(n));
+    this.state = { ...this.state, [e]: o };
+    const i = /* @__PURE__ */ new Set();
+    for (const c of r)
+      for (const f of v.buildAncestorPaths(c)) i.add(f);
+    for (const c of i) {
+      const f = this.getAtPath(s, c), h = this.getAtPath(o, c);
+      this.connectorBus.emit(e, c, { oldValue: f, newValue: h, 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((i) => {
+      const c = this.patternReducers.get(i);
+      return { name: i, when: c };
+    }), t = [];
+    for (const [i, c] of this.effects) {
+      if (c.size === 0) continue;
+      const [f, h] = i.split("::");
+      for (const l of c) {
+        const p = l.__quoMeta;
+        t.push({ channel: f, type: h, name: p?.name, description: p?.description });
+      }
+    }
+    for (const i of this.patternEffects) {
+      const c = i.effect.__quoMeta;
+      t.push({
+        channel: "*",
+        type: "*",
+        name: c?.name,
+        description: c?.description
+      });
+    }
+    const s = [];
+    for (const i of this.middleware)
+      typeof i == "function" ? s.push({ name: i.name || void 0 }) : s.push({
+        name: i.meta?.name,
+        description: i.meta?.description,
+        when: i.when
+      });
+    const n = [];
+    for (const i of this.connectorBus.__introspect())
+      for (let c = 0; c < i.count; c++)
+        n.push({ reducer: i.channel, property: i.type });
+    const r = [];
+    for (const [i, c] of this.committedEventSubscribers) {
+      if (c.size === 0) continue;
+      const [f, h] = i.split("::");
+      for (let l = 0; l < c.size; l++)
+        r.push({ channel: f, type: h, phase: "committed" });
+    }
+    for (const [i, c] of this.uncommittedEventSubscribers) {
+      if (c.size === 0) continue;
+      const [f, h] = i.split("::");
+      for (let l = 0; l < c.size; l++)
+        r.push({ channel: f, type: h, phase: "uncommitted" });
+    }
+    for (const [i, c] of this.allEventSubscribers) {
+      if (c.size === 0) continue;
+      const [f, h] = i.split("::");
+      for (let l = 0; l < c.size; l++)
+        r.push({ channel: f, type: h, phase: "all" });
+    }
+    const o = this.listeners.size;
+    return { reducers: e, effects: t, middleware: s, atomic: n, event: r, coarse: o };
+  }
+  /**
+   * 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}.
+   *
+   * @param nextPlain - Plain JS object to become the new state.
+   *
+   * @internal
+   */
+  __applyExternalState(e) {
+    const t = this.state, s = e;
+    let n = { ...this.state }, r = !1;
+    Object.keys(this.reducers).forEach((o) => {
+      const i = t?.[o], c = s?.[o];
+      if (i === c) return;
+      const f = w(structuredClone(c));
+      n[o] = f, r = !0;
+      const h = b(i, c).filter(Boolean);
+      if (h.length === 0) return;
+      const l = /* @__PURE__ */ new Set();
+      for (const p of h) for (const d of v.buildAncestorPaths(p)) l.add(d);
+      for (const p of l) {
+        const d = this.getAtPath(i, p), m = this.getAtPath(f, p);
+        this.connectorBus.emit(o, p, { oldValue: d, newValue: m, path: p });
+      }
+    }), r && (this.state = n), r && this.listeners.forEach((o) => o());
+  }
+  /**
+   * 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 s of t) {
+      const n = s, r = this.state;
+      this.reducerBus.emit(n.channel, n.type, n.payload);
+      for (const [c, f] of this.patternReducers)
+        this.matchesWhen(f, n) && this.forwardEvent(c, n);
+      const o = this.state, i = r !== o;
+      this.notifyEventSubscribers(n, "committed"), i && this.listeners.forEach((c) => c());
+    }
+  }
+  /**
+   * Emits a typed event `(channel, type, payload)`.
+   * Events are queued and processed **sequentially** (FIFO).
+   *
+   * **Pipeline per event:**
+   * 1. **Deduplication check** - Skip if event ID already processed (React Strict Mode safety)
+   * 2. **Middleware** - Pre-reducer hooks; may cancel by returning `false`
+   * 3. **Reducers** - Synchronous state updates via internal event bus
+   * 4. **Effects** - Async side-effects keyed by `(channel, type)` for O(1) lookup
+   * 5. **Coarse subscribers** - External store subscribers (only if state changed)
+   *
+   * **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]`.
+   * @returns A promise that resolves when the event has finished processing.
+   *
+   * @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, s) {
+    const n = this.fingerprint(e, t, s);
+    if (this.shouldDedupe(n))
+      return;
+    const r = crypto.randomUUID();
+    if (this.eventQueue.push({
+      channel: e,
+      type: t,
+      payload: s,
+      id: r
+    }), !this.isProcessingQueue) {
+      this.isProcessingQueue = !0;
+      try {
+        for (; this.eventQueue.length; ) {
+          const { channel: o, type: i, payload: c, id: f } = this.eventQueue.shift(), h = { channel: o, type: i, payload: c, id: f };
+          let l = !0;
+          for (const y of this.middleware) {
+            const g = this.getMiddlewareWhen(y);
+            if (!this.matchesWhen(g, h))
+              continue;
+            const E = this.getMiddlewareFunction(y);
+            try {
+              if (!await E(this.state, h, this.emit)) {
+                l = !1;
+                break;
+              }
+            } catch (S) {
+              console.error("Middleware error:", S), l = !1;
+              break;
+            }
+          }
+          if (!l) {
+            await this.notifyEventSubscribers(h, "uncommitted");
+            continue;
+          }
+          const p = this.state;
+          this.reducerBus.emit(o, i, c);
+          for (const [y, g] of this.patternReducers)
+            this.matchesWhen(g, h) && this.forwardEvent(y, h);
+          const d = this.state, m = p !== d;
+          await this.notifyEventSubscribers(h, "committed"), await this.notifyEffects(h), m && this.listeners.forEach((y) => y());
+        }
+      } catch (o) {
+        console.error("Emit queue error:", o);
+      } finally {
+        this.isProcessingQueue = !1;
+      }
+    }
+  }
+  /**
+   * 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, s, n = "committed") {
+    const r = `${e}::${String(t)}`, o = n === "committed" ? this.committedEventSubscribers : n === "uncommitted" ? this.uncommittedEventSubscribers : this.allEventSubscribers;
+    return o.has(r) || o.set(r, /* @__PURE__ */ new Set()), o.get(r).add(s), () => {
+      const i = o.get(r);
+      i && (i.delete(s), i.size === 0 && o.delete(r));
+    };
+  }
+  /**
+   * 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((s) => s()), () => {
+      this.unmountSlice(e, { deleteState: !0 }), this.listeners.forEach((s) => s());
+    };
+  }
+  /**
+   * 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: s, when: n } = e, r = [];
+    if (s && (t.__quoMeta = s), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
+      const c = { effect: t, when: n };
+      return this.patternEffects.add(c), () => {
+        this.patternEffects.delete(c);
+      };
+    }
+    const i = this.normalizeEventKeys(e);
+    if (i.length === 0 && !n && !e.events) {
+      const c = { effect: t, when: { any: !0 } };
+      return this.patternEffects.add(c), () => {
+        this.patternEffects.delete(c);
+      };
+    }
+    for (const [c, f] of i) {
+      const h = `${String(c)}::${String(f)}`;
+      this.effects.has(h) || this.effects.set(h, /* @__PURE__ */ new Set()), this.effects.get(h).add(t), r.push(() => {
+        const l = this.effects.get(h);
+        l && (l.delete(t), l.size === 0 && this.effects.delete(h));
+      });
+    }
+    return () => {
+      for (const c of r) c();
+    };
+  }
+  /**
+   * 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, s) {
+    const n = async (r, o, i) => {
+      if (r.channel !== e || r.type !== t) return;
+      const c = r;
+      return s(c.payload, o, i, c);
+    };
+    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 s = t.preserveState !== !1, n = new Set(Object.keys(this.reducers)), r = Object.entries(e), o = new Set(r.map(([i]) => i));
+    for (const i of n)
+      o.has(i) || this.unmountSlice(i, { deleteState: !0 });
+    for (const [i, c] of r)
+      n.has(i) ? (this.unmountSlice(i, { deleteState: !1 }), this.mountSlice(i, c, { preserveState: s })) : this.mountSlice(i, c, { 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, s) {
+    const n = e, { events: r, reducer: o, state: i, when: c } = t;
+    if (this.reducers[e] = new _(o), (!s.preserveState || this.state[n] === void 0) && (this.state[n] = w(structuredClone(i))), c && ("any" in c && c.any === !0 || "channel" in c || "channels" in c)) {
+      this.patternReducers.set(e, c), this.sliceUnsubs.set(n, []);
+      return;
+    }
+    const h = this.normalizeEventKeys(t);
+    if (h.length === 0 && !c && !r) {
+      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
+      return;
+    }
+    const l = [];
+    for (const [p, d] of h) {
+      const m = this.reducerBus.on(p, d, (y) => {
+        const g = { channel: p, type: d, payload: y, id: crypto.randomUUID() };
+        this.forwardEvent(e, g);
+      });
+      l.push(m);
+    }
+    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 s = e;
+    this.patternReducers.delete(e);
+    const n = this.sliceUnsubs.get(s);
+    if (n) {
+      for (const r of n)
+        try {
+          r();
+        } catch (o) {
+          console.error(`[Store error]: ${o}`);
+        }
+      this.sliceUnsubs.delete(s);
+    }
+    delete this.reducers[e], t.deleteState && delete this.state[s];
+  }
+  /**
+   * 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 r = e;
+    for (const o of n) {
+      if (r == null) return;
+      r = r[o];
+    }
+    return r;
+  }
+  /**
+   * 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 s = (e[0] === "." ? e.slice(1) : e).split("."), n = [];
+    for (let r = 0; r < s.length; r++)
+      n.push(s.slice(0, r + 1).join("."));
+    return n;
+  }
+}
+function x(a) {
+  return new v({
+    name: a.name,
+    reducer: a.reducer ?? {},
+    middleware: a.middleware ?? [],
+    effects: a.effects ?? [],
+    dedupWindowMs: a.dedupWindowMs,
+    devtools: a.devtools
+  });
+}
+const B = (a) => (e, t) => t.map((s) => [e, s]), $ = () => (a) => a;
+export {
+  z as EventBus,
+  k as LooseEventBus,
+  _ as Reducer,
+  v as Store,
+  x as createStore,
+  b as detectChangedProps,
+  $ as eventKeys,
+  w as freezeState,
+  B as typedEvents
+};
+//# sourceMappingURL=yoltra.esm.js.map