@yoltra/core 0.4.0 → 0.6.0

package/dist/yoltra.mjs

@@ -0,0 +1,2902 @@
+/*!
+ * @yoltra/core v0.6.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 K = Object.defineProperty;
+var F = (c, e, t) => e in c ? K(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var p = (c, e, t) => F(c, typeof e != "symbol" ? e + "" : e, t);
+class U {
+  constructor() {
+    /**
+     * Internal registry: `channel → type → Set<handler>`.
+     * @internal
+     */
+    p(this, "handlers", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribes a handler to an exact `(channel, type)`.
+   *
+   * @typeParam C - Channel key (must be a string key of `EM`).
+   * @typeParam T - Type key within channel `C` (must be a string key of `EM[C]`).
+   * @param channel - Channel name to subscribe to.
+   * @param type - Event type within the channel.
+   * @param handler - Function invoked with the payload type `EM[C][T]`. It optionally
+   * receives the **source event** as a second argument when the emitter supplies one, so
+   * subscribers can read the true `id` (and any `meta`) instead of reconstructing an event
+   * from the payload alone. Handlers that declare only `payload` remain valid.
+   * @returns An **unsubscribe** function that removes this handler.
+   *
+   * @example
+   * ```ts
+   * const off = bus.on('data', 'loaded', ({ items }) => {
+   *   console.log('Loaded', items.length, 'items');
+   * });
+   *
+   * // Later, stop listening:
+   * off();
+   * ```
+   *
+   * @example Reading the source event
+   * ```ts
+   * bus.on('data', 'loaded', (payload, event) => {
+   *   console.log('event id:', event?.id);
+   * });
+   * ```
+   *
+   * @public
+   */
+  on(e, t, 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]`.
+   * @param event - Optional **source event**, forwarded to handlers as a second argument.
+   * Supply it whenever the caller already holds the real event so subscribers observe its
+   * true `id` rather than reconstructing one; omitting it keeps the original behaviour.
+   *
+   * @example
+   * ```ts
+   * bus.emit('ui', 'toggle', false);
+   * ```
+   *
+   * @public
+   */
+  emit(e, t, s, n) {
+    const r = this.handlers.get(e);
+    if (!r) return;
+    const o = r.get(t);
+    if (!(!o || o.size === 0))
+      for (const l of [...o])
+        try {
+          l(s, n);
+        } 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 L {
+  constructor() {
+    /**
+     * Exact handlers: `channel → type → [handlers]`.
+     * @internal
+     */
+    p(this, "handlers", /* @__PURE__ */ new Map());
+    /**
+     * Pattern handlers with `*` and `**`: `channel → pattern(string) → [handlers]`.
+     * @internal
+     */
+    p(this, "patternHandlers", /* @__PURE__ */ new Map());
+    /**
+     * Patterns bucketed by their first segment, so an emit tests only what could match.
+     *
+     * @remarks
+     * Delivery used to walk every pattern registered on the channel and run the full segment
+     * matcher against each. That is linear in the number of patterns rather than in the number
+     * that match, and it re-split both the pattern and the subject on every test — for a thousand
+     * patterns, two thousand string splits to deliver one event.
+     *
+     * A subject's first segment can only be matched by a pattern whose first segment is that same
+     * literal, or is `*` or `**`. Bucketing on that turns the common shape — distinct event
+     * families like `panel.*` and `order.**` — from a scan of everything into a map lookup plus
+     * the handful that begin with a wildcard.
+     *
+     * It buys nothing for a channel where every pattern starts with `**`, since all of those must
+     * still be tested. That is the honest worst case, and it is unchanged rather than worsened.
+     */
+    p(this, "patternIndex", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribes a handler to either an **exact** type or a **pattern**.
+   *
+   * @param channel - Channel to subscribe on.
+   * @param type - Exact event type (e.g. `"a.b"`) or pattern (contains `*`/`**`).
+   * @param handler - Function invoked with the emitted payload.
+   * @returns An **unsubscribe** function that removes this handler.
+   *
+   * @remarks
+   * - Exact subscriptions are stored under a **normalized** key (leading `.` removed).
+   * - Pattern subscriptions are stored **as provided**; matching normalizes the subject.
+   *
+   * @example Exact subscription
+   * ```ts
+   * const off = bus.on('data', 'items.loaded', ({ count }) => {
+   *   console.log('Loaded', count);
+   * });
+   * // Later
+   * off();
+   * ```
+   *
+   * @example Pattern subscription
+   * ```ts
+   * // Match any single sub-event: 'panel.open', 'panel.close', etc.
+   * const offStar = bus.on('ui', 'panel.*', () => {});
+   *
+   * // Match any depth: 'panel.open', 'panel.items.add', 'panel', etc.
+   * const offGlob = bus.on('ui', 'panel.**', () => {});
+   * ```
+   *
+   * @public
+   */
+  on(e, t, 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, []), this.indexPattern(e, 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), this.unindexPattern(e, t)), n.size === 0 && (this.patternHandlers.delete(e), this.patternIndex.delete(e));
+  }
+  /**
+   * Emits an event to all exact subscribers first, then to **matching pattern** subscribers.
+   * Duplicate handler references are called **once** (de-duped).
+   *
+   * @param channel - Channel to emit on.
+   * @param type - Event type (subject). A leading dot is ignored for matching.
+   * @param payload - Payload delivered to handlers.
+   *
+   * @example
+   * ```ts
+   * // Suppose:
+   * //  - on('ui', 'panel.open', h)
+   * //  - on('ui', 'panel.*', h)       // same handler ref!
+   * //  - on('ui', 'panel.**', other)
+   * bus.emit('ui', 'panel.open', { id: 1 });
+   * // => 'h' runs once (de-duped), then 'other'
+   * ```
+   *
+   * @public
+   */
+  emit(e, t, s) {
+    const n = String(t), r = this.normalizeTypeKey(n), o = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n), i = /* @__PURE__ */ new Set(), a = (d) => {
+      for (const u of [...d])
+        if (!i.has(u)) {
+          i.add(u);
+          try {
+            u(s);
+          } catch (f) {
+            console.error(f);
+            continue;
+          }
+        }
+    };
+    a(o);
+    for (const d of l) a(d);
+  }
+  /**
+   * Emits a payload that is only built if somebody is listening.
+   *
+   * @param channel - Channel to emit on.
+   * @param type - Concrete event type.
+   * @param make - Builds the payload. Called at most once, and only when a handler matched.
+   *
+   * @remarks
+   * Same matching as {@link LooseEventBus.emit}; the difference is *when* the payload exists.
+   * The store's change notification carries the old and new value at a path, and reading those
+   * means walking the state tree twice per path. Doing that eagerly meant a slice nobody had
+   * subscribed to paid the full cost of describing changes to an audience of nobody — the
+   * matching work was already being done to discover there were no handlers.
+   *
+   * @public
+   */
+  emitWith(e, t, s) {
+    const n = String(t), r = this.normalizeTypeKey(n), o = this.handlers.get(e)?.get(r) ?? [], l = this.matchingPatternHandlers(e, n);
+    if (o.length === 0 && l.length === 0) return;
+    const i = s(), a = /* @__PURE__ */ new Set(), d = (u) => {
+      for (const f of [...u])
+        if (!a.has(f)) {
+          a.add(f);
+          try {
+            f(i);
+          } catch (m) {
+            console.error(m);
+            continue;
+          }
+        }
+    };
+    d(o);
+    for (const u of l) d(u);
+  }
+  /**
+   * Determines if a string is a **pattern** (contains `*`).
+   * @param s - Event type or pattern string.
+   * @returns `true` if it contains at least one `*`, else `false`.
+   * @internal
+   */
+  isPattern(e) {
+    return e.includes("*");
+  }
+  /**
+   * Normalizes event type keys for exact matching by stripping a **single** leading dot.
+   *
+   * @param s - Event type key.
+   * @returns Normalized key without a leading dot.
+   * @example
+   * ```ts
+   * normalizeTypeKey('.a.b') // 'a.b'
+   * normalizeTypeKey('a.b')  // 'a.b'
+   * ```
+   * @internal
+   */
+  normalizeTypeKey(e) {
+    return e.replace(/^\./, "");
+  }
+  /**
+   * Splits a path into dot-separated segments after normalization and removes empties.
+   * @param p - Event type or pattern string.
+   * @internal
+   */
+  splitPath(e) {
+    return this.normalizeTypeKey(e).split(".").filter(Boolean);
+  }
+  /**
+   * Files a pattern under the first segment that could select it.
+   * @internal
+   */
+  indexPattern(e, t) {
+    let s = this.patternIndex.get(e);
+    s === void 0 && (s = { byHead: /* @__PURE__ */ new Map(), anyHead: [] }, this.patternIndex.set(e, s));
+    const n = this.splitPath(t), r = { pattern: t, segments: n }, o = n[0];
+    if (o === void 0 || o === "*" || o === "**") {
+      s.anyHead.push(r);
+      return;
+    }
+    const l = s.byHead.get(o);
+    l === void 0 ? s.byHead.set(o, [r]) : l.push(r);
+  }
+  /**
+   * Removes a pattern from the index. Paired with {@link LooseEventBus.offPattern}.
+   * @internal
+   */
+  unindexPattern(e, t) {
+    const s = this.patternIndex.get(e);
+    if (s === void 0) return;
+    const n = this.splitPath(t)[0], r = n === void 0 || n === "*" || n === "**" ? s.anyHead : s.byHead.get(n);
+    if (r === void 0) return;
+    const o = r.findIndex((l) => l.pattern === t);
+    o !== -1 && r.splice(o, 1), r.length === 0 && r !== s.anyHead && n !== void 0 && s.byHead.delete(n);
+  }
+  /**
+   * The handler lists of every pattern matching this subject.
+   *
+   * @remarks
+   * Shared by `emit` and `emitWith` so the two cannot drift on what "matching" means — which
+   * they could, being two copies of the same walk before.
+   *
+   * The subject is split once here rather than once per pattern tested.
+   *
+   * @internal
+   */
+  matchingPatternHandlers(e, t) {
+    const s = this.patternHandlers.get(e), n = this.patternIndex.get(e);
+    if (s === void 0 || s.size === 0 || n === void 0) return [];
+    const r = this.splitPath(t), o = [], l = (a) => {
+      for (const d of a) {
+        if (!this.matchSegments(d.segments, r)) continue;
+        const u = s.get(d.pattern);
+        u !== void 0 && o.push(u);
+      }
+    }, i = r[0];
+    if (i !== void 0) {
+      const a = n.byHead.get(i);
+      a !== void 0 && l(a);
+    }
+    return l(n.anyHead), o;
+  }
+  /**
+   * Pattern matcher over dot-separated segments, which arrive already split.
+   *
+   * Rules:
+   * - **literal**: exact match.
+   * - `*`   : matches exactly **one** segment.
+   * - `**`  : matches **zero or more** remaining segments (including empty).
+   *
+   * @remarks
+   * Takes segments rather than strings so delivery can split each pattern once at registration
+   * and the subject once per emit, instead of both once per test. Re-splitting per test was most
+   * of what made wildcard delivery expensive: a thousand patterns meant two thousand string
+   * splits to deliver one event.
+   *
+   * @param pSegs - Pattern segments (may include `*`/`**`).
+   * @param sSegs - Subject segments to test.
+   * @returns `true` if the pattern matches; otherwise `false`.
+   *
+   * @example
+   * ```ts
+   * matchSegments(['a', '*'], ['a', 'b'])           // true
+   * matchSegments(['a', '*'], ['a', 'b', 'c'])      // false
+   * matchSegments(['a', '**'], ['a'])               // true
+   * matchSegments(['**', 'end'], ['x', 'y', 'end']) // true
+   * ```
+   *
+   * @internal
+   */
+  matchSegments(e, t) {
+    let s = 0, n = 0, r = -1, o = 0;
+    for (; n < t.length; )
+      if (s < e.length && (e[s] === "*" || e[s] === t[n]))
+        s++, n++;
+      else if (s < e.length && e[s] === "**")
+        r = s, o = n, s++;
+      else if (r !== -1)
+        s = r + 1, n = ++o;
+      else
+        return !1;
+    for (; s < e.length && e[s] === "**"; ) s++;
+    return s === e.length;
+  }
+  /**
+   * Removes **all** listeners (exact and pattern). Useful for tests/HMR teardown.
+   *
+   * @example
+   * ```ts
+   * afterEach(() => bus.clear());
+   * ```
+   *
+   * @public
+   */
+  clear() {
+    this.handlers.clear(), this.patternHandlers.clear(), this.patternIndex.clear();
+  }
+  /**
+   * Returns a snapshot of all registered subscriptions for DevTools introspection.
+   *
+   * @returns An array of `{ channel, type, count }` entries for each distinct
+   *          (channel, type/pattern) pair with at least one handler.
+   *
+   * @internal
+   */
+  __introspect() {
+    const e = [];
+    for (const [t, 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 V {
+  /**
+   * Creates a new {@link Reducer} from a pure reducer function.
+   *
+   * @param reduce - A function `(state, event) => nextState` that implements your update logic.
+   *
+   * @example
+   * ```ts
+   * const reducer = new Reducer<MyState, MyEM>((state, event) => {
+   *   // implement your transitions here
+   *   return state;
+   * });
+   * ```
+   *
+   * @public
+   */
+  constructor(e) {
+    /**
+     * The underlying pure reducer function.
+     * @internal
+     */
+    p(this, "_reduce");
+    this._reduce = e;
+  }
+  /**
+    * Applies the reducer to produce the next state.
+    *
+    * @param state  - Current state.
+    * @param event - An event drawn from {@link EventUnion | `EventUnion<EM>`}.
+    * @returns The next state, or a {@link Rejection} if the reducer refused the write.
+    *
+    * @example
+    * ```ts
+  * const next = reducer.reduce(curr, someEvent as EventUnion<MyEM>);
+    * ```
+    *
+    * @public
+    */
+  reduce(e, t) {
+    return this._reduce(e, t);
+  }
+}
+const T = /* @__PURE__ */ new Set();
+function O(c, e) {
+  const t = c ? `${c}.${e}` : e;
+  T.has(t) || (T.add(t), console.warn(
+    `[yoltra] State key "${e}"${c ? ` under "${c}"` : ""} contains a dot. Paths are dotted, so this key is indistinguishable from nested objects of the same name: a subscription to "${t}" may match the wrong value, and DevTools patches for it will address the wrong node. Rename the key, or nest it.`
+  ));
+}
+function I(c, e, t = "", s = /* @__PURE__ */ new Map()) {
+  const n = [];
+  return P(c, e, t, s, n), n;
+}
+function P(c, e, t, s, n) {
+  if (c === e) return;
+  if (typeof c != "object" || typeof e != "object" || c === null || e === null) {
+    if (typeof c == "number" && Number.isNaN(c) && Number.isNaN(e))
+      return;
+    n.push(t);
+    return;
+  }
+  if (c instanceof Date && e instanceof Date) {
+    c.getTime() !== e.getTime() && n.push(t);
+    return;
+  }
+  if (c instanceof RegExp && e instanceof RegExp) {
+    (c.source !== e.source || e.flags !== c.flags) && n.push(t);
+    return;
+  }
+  if (c instanceof Map || e instanceof Map) {
+    n.push(t);
+    return;
+  }
+  if (c instanceof Set || e instanceof Set) {
+    n.push(t);
+    return;
+  }
+  const r = c, o = e, l = s.get(r);
+  if (l?.has(o)) return;
+  const i = l ?? /* @__PURE__ */ new Set();
+  i.add(o), l || s.set(r, i);
+  try {
+    const a = Array.isArray(c), d = Array.isArray(e);
+    if (a !== d) {
+      n.push(t);
+      return;
+    }
+    if (a) {
+      const h = c, y = e;
+      h.length !== y.length && t && n.push(t);
+      const g = Math.min(h.length, y.length);
+      for (let w = 0; w < g; w++)
+        h[w] !== y[w] && P(h[w], y[w], t ? `${t}.${w}` : `${w}`, s, n);
+      for (let w = g; w < Math.max(h.length, y.length); w++)
+        n.push(t ? `${t}.${w}` : `${w}`);
+      return;
+    }
+    const u = Object.keys(c), f = Object.keys(e);
+    if (u.length === 0 && f.length === 0) {
+      n.push(t);
+      return;
+    }
+    let m = u.length === f.length;
+    if (m) {
+      for (let h = 0; h < f.length; h++)
+        if (!Object.prototype.hasOwnProperty.call(c, f[h])) {
+          m = !1;
+          break;
+        }
+    }
+    if (m) {
+      for (const h of f)
+        c[h] !== e[h] && (process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h), P(c[h], e[h], t ? `${t}.${h}` : h, s, n));
+      return;
+    }
+    for (const h of f) {
+      const y = Object.prototype.hasOwnProperty.call(c, h);
+      if (y && c[h] === e[h]) continue;
+      process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h);
+      const g = t ? `${t}.${h}` : h;
+      if (!y) {
+        n.push(g);
+        continue;
+      }
+      P(c[h], e[h], g, s, n);
+    }
+    for (const h of u)
+      Object.prototype.hasOwnProperty.call(e, h) || (process.env.NODE_ENV !== "production" && h.includes(".") && O(t, h), n.push(t ? `${t}.${h}` : h));
+  } finally {
+    i.delete(o), i.size === 0 && s.delete(r);
+  }
+}
+function M(c, e = /* @__PURE__ */ new WeakSet(), t) {
+  if (c === null || typeof c != "object" || e.has(c) || (t !== void 0 && c === t.watch && t.onFound(), Object.isFrozen(c))) return c;
+  if (e.add(c), Array.isArray(c)) {
+    const s = c;
+    for (let n = 0; n < s.length; n++)
+      s[n] = M(s[n], e, t);
+    return Object.freeze(s);
+  }
+  for (const s of Object.getOwnPropertyNames(c)) {
+    const n = Object.getOwnPropertyDescriptor(c, s);
+    !n || !("value" in n) || (c[s] = M(c[s], e, t));
+  }
+  for (const s of Object.getOwnPropertySymbols(c)) {
+    const n = Object.getOwnPropertyDescriptor(c, s);
+    !n || !("value" in n) || (c[s] = M(c[s], e, t));
+  }
+  return Object.freeze(c);
+}
+const N = /* @__PURE__ */ Symbol.for("yoltra.rejected");
+function le(c) {
+  return { [N]: !0, reason: c };
+}
+function Q(c) {
+  return typeof c == "object" && c !== null && c[N] === !0;
+}
+class G {
+  constructor(e) {
+    p(this, "highWaterMark");
+    p(this, "buffer", []);
+    /** Consumers parked in `take`, oldest first. */
+    p(this, "takers", []);
+    /** Producers parked in `put`, each with the item they are waiting to hand over. */
+    p(this, "putters", []);
+    p(this, "consuming", !1);
+    /** No more items will be accepted, but what is already here is still owed to the consumer. */
+    p(this, "ended", !1);
+    /** Abandoned: nothing further is owed to anybody. */
+    p(this, "closed", !1);
+    /** Items discarded because nobody was iterating and the buffer was full. */
+    p(this, "dropped", 0);
+    this.highWaterMark = e;
+  }
+  /** How many items were discarded for want of a consumer. */
+  get droppedCount() {
+    return this.dropped;
+  }
+  /**
+   * Marks that a consumer has started pulling. From here on, a full buffer parks the producer
+   * rather than dropping.
+   */
+  beginConsuming() {
+    this.consuming = !0;
+  }
+  /**
+   * Offers an item. The returned promise settles when the item has been taken — or immediately,
+   * if it fit in the buffer or was dropped.
+   */
+  put(e) {
+    if (this.closed || this.ended) return Promise.resolve();
+    const t = this.takers.shift();
+    return t !== void 0 ? (t({ value: e, done: !1 }), Promise.resolve()) : this.buffer.length < this.highWaterMark ? (this.buffer.push(e), Promise.resolve()) : this.consuming ? new Promise((s) => {
+      this.putters.push({ item: e, release: s });
+    }) : (this.dropped++, Promise.resolve());
+  }
+  /** Takes the next item, waiting if none is available. Resolves `done` once closed and drained. */
+  take() {
+    this.consuming = !0;
+    const e = this.buffer.shift();
+    if (e !== void 0) {
+      const s = this.putters.shift();
+      return s !== void 0 && (this.buffer.push(s.item), s.release()), Promise.resolve({ value: e, done: !1 });
+    }
+    const t = this.putters.shift();
+    return t !== void 0 ? (t.release(), Promise.resolve({ value: t.item, done: !1 })) : this.closed || this.ended ? Promise.resolve({ value: void 0, done: !0 }) : new Promise((s) => {
+      this.takers.push(s);
+    });
+  }
+  /**
+   * Stops accepting items, but keeps owing the consumer everything already queued.
+   *
+   * @remarks
+   * What the terminal reply does. Closing outright at that moment would throw away progress the
+   * responder had already handed over and the consumer had not yet read — which is exactly what
+   * happened before this existed: a six-step job delivered five steps, because the sixth was in
+   * the buffer when `done` arrived and the buffer was cleared. The terminal event says "no more
+   * is coming", not "forget what you were given".
+   */
+  end() {
+    if (this.ended || this.closed) return;
+    this.ended = !0;
+    let e = this.putters.shift();
+    for (; e !== void 0; )
+      this.buffer.push(e.item), e.release(), e = this.putters.shift();
+    let t = this.takers.shift();
+    for (; t !== void 0; ) {
+      const s = this.buffer.shift();
+      t(
+        s !== void 0 ? { value: s, done: !1 } : { value: void 0, done: !0 }
+      ), t = this.takers.shift();
+    }
+  }
+  /**
+   * Closes the queue: waiting consumers are told `done`, and **every parked producer is
+   * released**.
+   *
+   * @remarks
+   * Releasing producers is not tidying up. A producer parked on `put` is a pending `await emit`
+   * somewhere; leaving it parked when the call has already settled would hang the responder for
+   * good — turning a timed-out call into a wedged process, which is worse than the problem
+   * backpressure was added to solve.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = !0, this.buffer.length = 0;
+    let e = this.takers.shift();
+    for (; e !== void 0; )
+      e({ value: void 0, done: !0 }), e = this.takers.shift();
+    let t = this.putters.shift();
+    for (; t !== void 0; )
+      t.release(), t = this.putters.shift();
+  }
+}
+class J extends Error {
+  constructor(t, s, n) {
+    super(
+      `[yoltra] call to "${t}/${s}" saw no correlated reply for ${n}ms. The timeout is idle rather than total, so this means the responder went quiet, not that it was slow. Check that something handles "${t}/${s}" and that its reply is emitted through the \`emit\` it was handed — a reply emitted from an unrelated context carries no causal link, and needs an explicit correlationId instead.`
+    );
+    p(this, "channel");
+    p(this, "type");
+    p(this, "idleMs");
+    this.name = "CallTimeoutError", this.channel = t, this.type = s, this.idleMs = n;
+  }
+}
+class C extends Error {
+  constructor(e) {
+    super(`[yoltra] call aborted: ${e}`), this.name = "CallAbortedError";
+  }
+}
+function q(c) {
+  const [e, t] = c;
+  if (t === void 0) return { channel: e, isTerminal: () => !0 };
+  if (typeof t == "string") return { channel: e, isTerminal: (n) => n === t };
+  const s = new Set(t);
+  return { channel: e, isTerminal: (n) => s.has(n) };
+}
+function Y(c, e, t) {
+  return c.parentId === e ? !0 : t === void 0 ? !1 : c.meta?.correlationId === t;
+}
+function X(c, e) {
+  try {
+    return structuredClone(e);
+  } catch (t) {
+    throw new Error(
+      `[yoltra] Initial state for slice "${String(c)}" could not be copied: ${t instanceof Error ? t.message : String(t)}. State must be structured-cloneable — functions, class instances and DOM nodes are not. Keep behaviour out of state and store plain data.`
+    );
+  }
+}
+function R(c, e) {
+  return process.env.NODE_ENV === "production" ? c : M(c, /* @__PURE__ */ new WeakSet(), e);
+}
+const D = 100, Z = 64, z = 16, ee = 3e4, te = 16, $ = Object.freeze({ committed: !1, written: !1 }), ne = Object.freeze({ committed: !0, written: !1 }), se = Object.freeze({ committed: !0, written: !0 }), A = () => typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+class x {
+  /**
+   * Creates a store from a {@link StoreSpec}.
+   *
+   * @param spec - Store configuration (name, reducers, middleware, optional effects).
+   *
+   * @public
+   */
+  constructor(e) {
+    /**
+     * Store name (used by DevTools & diagnostics).
+     *
+     * @public
+     */
+    p(this, "name");
+    /**
+     * Registered middleware pipeline (run **before** reducers).
+     * Stores either raw functions (legacy) or MiddlewareSpec objects.
+     * Return `false` from the middleware function to stop propagation.
+     *
+     * @internal
+     */
+    p(this, "middleware");
+    /**
+     * Installed slice reducers keyed by slice name.
+     *
+     * @internal
+     */
+    p(this, "reducers");
+    /**
+     * Current immutable snapshot of the store state.
+     * This reference changes whenever any slice changes (shallow immutability).
+     *
+     * @internal
+     */
+    p(this, "state");
+    /**
+     * Bus for reducer wiring (emit by `(channel, type)`).
+     *
+     * @internal
+     */
+    p(this, "reducerBus");
+    /**
+     * Bus for **granular** connector events (emit by **dotted path** inside a slice).
+     *
+     * @internal
+     */
+    p(this, "connectorBus");
+    /**
+     * Coarse-grained listeners (called once per committed event, only if state changed).
+     *
+     * @internal
+     */
+    p(this, "listeners", /* @__PURE__ */ new Set());
+    /**
+     * Registered effect handlers keyed by `"channel::type"` for O(1) lookup.
+     * Used for effects with explicit `keys` targeting.
+     *
+     * @internal
+     */
+    p(this, "effects", /* @__PURE__ */ new Map());
+    /**
+     * Pattern-based effects that need runtime matching.
+     * Used for effects with `when: { any }`, `{ channel }`, or `{ channels }`.
+     * Stores tuples of [effect function, when matcher].
+     *
+     * @internal
+     */
+    p(this, "patternEffects", /* @__PURE__ */ new Set());
+    /**
+     * Committed event subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified after reducers, before effects, for events that passed middleware.
+     *
+     * @internal
+     */
+    p(this, "committedEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * Uncommitted event subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified when middleware rejects an event.
+     *
+     * @internal
+     */
+    p(this, "uncommittedEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * All-events subscribers keyed by `"channel::type"` for O(1) lookup.
+     * Notified for both committed and uncommitted events with phase parameter.
+     *
+     * @internal
+     */
+    /**
+     * Subscribers to events that actually changed state, notified after the commit.
+     *
+     * @remarks
+     * Separate from `committedEventSubscribers` rather than a filter over it, because the two
+     * answer different questions and one of them is load bearing: `committed` means "not vetoed"
+     * and fires for every event a store accepts, including every event in a store with no
+     * reducers. Narrowing it would have silently stopped toasts and analytics firing.
+     *
+     * @internal
+     */
+    p(this, "writtenEventSubscribers", /* @__PURE__ */ new Map());
+    p(this, "allEventSubscribers", /* @__PURE__ */ new Map());
+    /**
+     * Track reducerBus unsubs per slice for HMR/register/unregister.
+     *
+     * @internal
+     */
+    p(this, "sliceUnsubs", /* @__PURE__ */ new Map());
+    /**
+     * Pattern-based reducers that need runtime matching.
+     * Used for reducers with `when: { any }`, `{ channel }`, or `{ channels }`.
+     * Maps slice name to the `when` matcher.
+     *
+     * @internal
+     */
+    p(this, "patternReducers", /* @__PURE__ */ new Map());
+    /**
+     * Whether `__replayEvents()` is allowed.
+     * Set from `spec.devtools.allowReplay`.
+     *
+     * @internal
+     */
+    p(this, "replayEnabled");
+    /**
+     * Produces the `id` for each emitted event. Defaults to `crypto.randomUUID()`; overridable
+     * via {@link StoreSpec.idFactory} for runtimes lacking it or for deterministic tests.
+     *
+     * @internal
+     */
+    p(this, "idFactory");
+    /**
+     * Optional hook invoked when an effect throws/rejects. See
+     * {@link StoreSpec.onEffectError}. `await emit()` never rejects on effect
+     * failure — this is how callers observe effect errors.
+     */
+    p(this, "onEffectError");
+    /**
+     * Optional hook invoked when a reducer throws. See {@link StoreSpec.onReducerError}. The
+     * failing slice is isolated rather than the event being rolled back, so this is the only
+     * signal that a reducer misbehaved.
+     */
+    p(this, "onReducerError");
+    /**
+     * `slice:channel:type` combinations already warned about for payload aliasing.
+     *
+     * @remarks
+     * Development-only diagnostics have to stay quiet enough to be read. One warning names the
+     * pattern; repeating it once per event would bury it.
+     */
+    p(this, "warnedPayloadAliases", /* @__PURE__ */ new Set());
+    /**
+     * Pending events awaiting the **synchronous** reduce phase (middleware +
+     * reducers + subscribers + coarse listeners). Drained by {@link drainReduce}.
+     *
+     * @internal
+     */
+    p(this, "reduceQueue", []);
+    /**
+     * Re-entrancy guard for the synchronous reduce phase.
+     *
+     * @internal
+     */
+    p(this, "isReducing", !1);
+    /**
+     * The event currently being reduced, or `null` outside the drain.
+     *
+     * @remarks
+     * This is what makes causality exact rather than best-effort. The drain is synchronous — no
+     * `await` can interleave — so any `emit` that arrives while it is set is, without ambiguity, a
+     * consequence of this event. That catches the case a scoped `emit` closure cannot: a
+     * middleware or subscriber that captured the store and calls `store.emit` directly instead of
+     * using the injected one. Attribution should not depend on which reference a consumer reached
+     * for.
+     *
+     * @internal
+     */
+    p(this, "currentEvent", null);
+    /**
+     * Events processed by the drain currently in progress. Compared against
+     * `maxTransitionsPerDrain`, which is off unless configured.
+     *
+     * @internal
+     */
+    p(this, "transitionsThisDrain", 0);
+    /**
+     * Ceilings that stop a cascade from becoming a hung process. See {@link StoreSpec.maxReduceDepth}.
+     *
+     * @internal
+     */
+    p(this, "maxReduceDepth");
+    p(this, "maxTransitionsPerDrain");
+    p(this, "onCascade");
+    p(this, "onRejected");
+    /**
+     * Registered instrumentation observers (DevTools seam). See {@link instrument}.
+     *
+     * @internal
+     */
+    p(this, "instrumentObservers", /* @__PURE__ */ new Set());
+    /**
+     * Scratch array collecting slice-prefixed changed leaf paths during an
+     * instrumented reduce. Set by {@link drainReduce} while observers are active;
+     * appended to by {@link commitStaged}. `null` when not instrumenting.
+     *
+     * @internal
+     */
+    p(this, "changedPathSink", null);
+    /**
+     * Where keyed reducers put their pending writes during a reduce, and the refusal one of them
+     * returned.
+     *
+     * @remarks
+     * Keyed reducers are invoked through `reducerBus`, which delivers to handlers and has no way
+     * to hand a value back — the same reason `changedPathSink` exists. `null` outside a reduce.
+     *
+     * @internal
+     */
+    p(this, "stagingSink", null);
+    p(this, "stagedRejection", null);
+    p(this, "stagedRejectedBy", "");
+    /**
+     * Count of effect tasks currently in flight; surfaced as queue depth by
+     * {@link __devtoolsIntrospect}.
+     *
+     * @internal
+     */
+    p(this, "inFlightEffects", 0);
+    /**
+     * Tracks processed events by fingerprint with timestamps for TTL-based deduplication.
+     *
+     * **Deduplication Behavior:**
+     * - Events are fingerprinted using `channel::type::JSON(payload)`
+     * - If an identical fingerprint is seen within the dedup window, it's skipped
+     * - The window is 50ms in development, 100ms in production
+     *
+     * **Limitations:**
+     * - Non-serializable payloads (functions, symbols, circular refs) get unique
+     *   fingerprints and won't be deduplicated
+     * - Legitimate rapid-fire identical events may be incorrectly deduplicated
+     * - The cache is bounded to 1000 entries with lazy pruning
+     *
+     * @internal
+     */
+    p(this, "processedEvents", /* @__PURE__ */ new Map());
+    /**
+     * Lifetime count of events suppressed by the deduplication cache.
+     * Exposed via {@link __devtoolsIntrospect} so the DevTools agent can
+     * surface it in the STORE_METRICS response without further core changes.
+     *
+     * @internal
+     */
+    p(this, "dedupCount", 0);
+    /**
+     * Store-owned metadata for registered effects, keyed by the effect function.
+     * Kept **off** the caller's function object: mutating a user-owned function
+     * (the old `fn.__quoMeta`) bled metadata across stores that share a handler
+     * and left it attached after unregister. Cleared on {@link dispose}.
+     *
+     * @internal
+     */
+    p(this, "effectMeta", /* @__PURE__ */ new WeakMap());
+    /**
+     * Configuration for event deduplication.
+     * @internal
+     */
+    p(this, "dedupConfig");
+    /**
+     * Timer for periodic cleanup of processed events.
+     *
+     * @internal
+     */
+    p(this, "eventCleanupTimer", null);
+    if (this.name = e.name ?? "yoltra Store", this.reducerBus = new U(), this.connectorBus = new L(), this.middleware = [...e.middleware ?? []], this.reducers = {}, this.state = {}, this.replayEnabled = e.devtools?.allowReplay ?? !1, this.idFactory = e.idFactory ?? (() => crypto.randomUUID()), this.onEffectError = e.onEffectError, this.onReducerError = e.onReducerError, this.maxReduceDepth = e.maxReduceDepth ?? Z, this.maxTransitionsPerDrain = e.maxTransitionsPerDrain ?? 1 / 0, this.onCascade = e.onCascade, this.onRejected = e.onRejected, this.dedupConfig = {
+      windowMs: e.dedupWindowMs ?? 0,
+      maxCacheSize: 1e3
+    }, Object.entries(e.reducer).forEach(([t, s]) => {
+      this.mountSlice(t, s, { preserveState: !1 });
+    }), 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.__applyExternalState = this.__applyExternalState.bind(this), this.__replayEvents = this.__replayEvents.bind(this), this.__devtoolsIntrospect = this.__devtoolsIntrospect.bind(this), this.mountSlice = this.mountSlice.bind(this), this.unmountSlice = this.unmountSlice.bind(this), this.getAtPath = this.getAtPath.bind(this), this.emit = this.emit.bind(this), this.subscribe = this.subscribe.bind(this), this.connect = this.connect.bind(this), this.onEffect = this.onEffect.bind(this), this.onEvent = this.onEvent.bind(this), this.getState = this.getState.bind(this), this.registerEffect = this.registerEffect.bind(this), this.registerMiddleware = this.registerMiddleware.bind(this), this.registerReducer = this.registerReducer.bind(this), this.replaceMiddleware = this.replaceMiddleware.bind(this), this.replaceEffects = this.replaceEffects.bind(this), this.replaceReducers = this.replaceReducers.bind(this), this.hotReplace = this.hotReplace.bind(this);
+  }
+  /**
+   * Cleanup resources (timers, etc.) when disposing the store.
+   * Call this if you're dynamically creating/destroying stores.
+   *
+   * @example
+   * ```ts
+   * const store = createStore({ ... });
+   * // later
+   * store.dispose();
+   * ```
+   *
+   * @public
+   */
+  dispose() {
+    this.eventCleanupTimer && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null), this.processedEvents.clear(), this.effects.clear(), this.patternEffects.clear(), this.effectMeta = /* @__PURE__ */ new WeakMap(), this.warnedPayloadAliases.clear(), this.listeners.clear(), this.committedEventSubscribers.clear(), this.uncommittedEventSubscribers.clear(), this.writtenEventSubscribers.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, 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, t) {
+    const s = Date.now(), n = this.processedEvents.get(e);
+    return n !== void 0 && s - n < t ? (this.dedupCount++, !0) : (this.processedEvents.set(e, s), this.ensureCleanupTimer(), this.processedEvents.size > this.dedupConfig.maxCacheSize && this.pruneProcessedEvents(s), !1);
+  }
+  /**
+   * 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, D), s = e - t * 2;
+    for (const [n, r] of this.processedEvents)
+      r < s && this.processedEvents.delete(n);
+    this.processedEvents.size === 0 && this.eventCleanupTimer !== null && (clearInterval(this.eventCleanupTimer), this.eventCleanupTimer = null);
+  }
+  /**
+   * Reports a breached ceiling and refuses the emit.
+   *
+   * @remarks
+   * Console *and* hook, matching how reducer and effect errors are reported: a cascade is a
+   * wiring bug, and the console line is what a developer who has not registered a hook will
+   * actually see. Without one, refusing the emit would look exactly like the event never having
+   * been emitted at all — which is the invisibility this whole guard exists to end.
+   *
+   * @internal
+   */
+  reportCascade(e, t, s, n, r) {
+    console.error(
+      `[yoltra] Cascade stopped: "${s.channel}/${s.type}" would exceed ${e} (${t}). This event was refused and the chain ends here. A chain this long is almost always two consumers emitting into each other — check what reacts to "${s.channel}/${s.type}" and what that emits in turn.` + (r.length > 0 ? ` Recent causal chain: ${r.join(" → ")} → (refused).` : "")
+    );
+    try {
+      this.onCascade?.({ limit: e, limitValue: t, event: s, depth: n, chain: r });
+    } catch (o) {
+      console.error("onCascade handler error:", o);
+    }
+  }
+  /**
+   * 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 = this.scopedEmit(e), s = `${String(e.channel)}::${String(e.type)}`, n = this.effects.get(s);
+    if (n && n.size > 0)
+      for (const r of [...n])
+        try {
+          await r(e, this.getState, t);
+        } catch (o) {
+          console.error("Effect error:", o), this.onEffectError?.(o, e);
+        }
+    for (const { effect: r, when: o } of this.patternEffects)
+      if (this.matchesWhen(o, e))
+        try {
+          await r(e, this.getState, t);
+        } catch (l) {
+          console.error("Effect error:", l), this.onEffectError?.(l, e);
+        }
+  }
+  /**
+   * An `emit` that attributes whatever it sends to `cause`.
+   *
+   * @remarks
+   * Built per event rather than per effect: every effect reacting to one event shares a cause,
+   * and one closure is cheaper than one per handler on a path that runs for every committed
+   * event.
+   *
+   * @internal
+   */
+  scopedEmit(e) {
+    const t = {
+      id: e.id,
+      depth: e.depth ?? 0,
+      chain: [...this.currentEvent?.chain ?? [], e.id].slice(-z)
+    };
+    return ((s, n, r, o) => this.emitCaused(t, s, n, r, 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
+   */
+  notifyEventSubscribers(e, t) {
+    const s = `${String(e.channel)}::${String(e.type)}`, r = (t === "committed" ? this.committedEventSubscribers : t === "written" ? this.writtenEventSubscribers : this.uncommittedEventSubscribers).get(s);
+    if (r?.size)
+      for (const l of [...r]) this.invokeEventSubscriber(l, e, t);
+    if (t === "written") return;
+    const o = this.allEventSubscribers.get(s);
+    if (o?.size)
+      for (const l of [...o]) this.invokeEventSubscriber(l, 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, s) {
+    try {
+      const n = e(t, this.getState, this.emit, s);
+      n && typeof n.then == "function" && n.catch((r) => console.error("Event subscription error:", r));
+    } catch (n) {
+      console.error("Event subscription error:", n);
+    }
+  }
+  /**
+   * Applies a reduced event to a slice and emits **precise** connector events.
+   *
+   * For each changed **leaf path** (via {@link detectChangedProps}), emits that leaf and
+   * all of its **ancestors** once (e.g., `"data"`, `"data.123"`, `"data.123.title"`).
+   *
+   * A slice whose state **is** a single value — a primitive, a `Map`/`Set`, a `Date` — has no
+   * leaf below its root, and `detectChangedProps` reports its change as the empty path `""`.
+   * That path is emitted as-is, so `connect({ reducer, property: "" })` (and any `**` pattern)
+   * hears it. It has no ancestors to walk.
+   *
+   * **State Immutability**: When a slice changes, a new state object is created via
+   * shallow spread: `{ ...this.state, [sliceName]: newSlice }`. This ensures that
+   * `this.state` reference changes, enabling efficient change detection via `===`.
+   *
+   * @param rName - Slice name being updated.
+   * @param event - Reduced event with typed payload.
+   * @returns `true` if the slice actually changed, `false` otherwise.
+   *
+   * @internal
+   */
+  /**
+   * Reduces one slice and contains any error it raises.
+   *
+   * @returns `true` when the slice changed.
+   *
+   * @remarks
+   * The single funnel both dispatch paths go through, which is the point. Keyed reducers run
+   * through `reducerBus`, whose handler loop caught and logged; pattern reducers were called
+   * straight from the drain, so their errors escaped to the caller instead. The same bug in the
+   * same reducer therefore produced two different outcomes depending on how the slice happened
+   * to be targeted — a keyed reducer's throw let the event commit and its effects run, while a
+   * pattern reducer's throw aborted the commit and notified nobody, not even the uncommitted
+   * subscribers a veto would have reached.
+   *
+   * The semantics are the same either way: **the failing slice is isolated.** Its state is
+   * unchanged, every other slice still reduces, and the event still commits if anything else
+   * changed.
+   *
+   * That is deliberately *not* what a {@link Rejected} refusal does, which discards the whole
+   * event. A crash and a refusal are different acts: a reducer that throws has a bug and should
+   * not be able to veto its neighbours' work, while a reducer that refuses has made a decision
+   * and must be able to.
+   *
+   * This once argued that rolling back was untenable, because subscribers were notified as each
+   * slice committed and a later revert would have told them about a value that no longer
+   * existed. Staging removed that obstacle — nothing is notified until every slice is written —
+   * which is what made refusal possible at all.
+   *
+   * @internal
+   */
+  stageSliceGuarded(e, t, s) {
+    try {
+      return this.stageSlice(e, t, s);
+    } catch (n) {
+      return console.error(`Reducer error in slice "${e}":`, n), this.onReducerError?.(n, t, e), null;
+    }
+  }
+  /**
+   * Runs one slice's reducer and records what it *would* write. Writes nothing.
+   *
+   * @returns The reducer's {@link Rejection} if it refused, otherwise `null`.
+   *
+   * @remarks
+   * The staging half of the write path. Nothing here touches `this.state` or notifies anybody,
+   * which is what lets the event be refused after every reducer has had its say — a decision
+   * that has to see the whole diff cannot be made one slice at a time.
+   *
+   * Freezing happens here rather than at commit because it is where the new value is built, and
+   * the freeze is a no-op on anything already frozen; a staged slice that never commits is
+   * discarded frozen, which costs nothing and keeps the committed path free of a second walk.
+   *
+   * @internal
+   */
+  stageSlice(e, t, s) {
+    const n = this.state[e], r = this.reducers[e].reduce(n, t);
+    if (Q(r)) return r;
+    if (n === r) return null;
+    const o = I(n, r);
+    if (o.length === 0) return null;
+    const l = t.payload, i = process.env.NODE_ENV !== "production" && l !== null && typeof l == "object" ? {
+      watch: l,
+      onFound: () => {
+        const a = `${e}:${t.channel}:${t.type}`;
+        this.warnedPayloadAliases.has(a) || (this.warnedPayloadAliases.add(a), console.warn(
+          `[yoltra] Slice "${e}" stored the payload of "${t.channel}/${t.type}" by reference. It is now frozen along with the rest of the state, so the emitter mutating it later will throw in development and silently corrupt state in production. Copy the payload in the reducer instead.`
+        ));
+      }
+    } : void 0;
+    return s.push({
+      name: e,
+      prev: n,
+      frozen: R(r, i),
+      leafPaths: o
+    }), null;
+  }
+  /**
+   * Writes every staged slice, then tells the world — in that order.
+   *
+   * @remarks
+   * The commit half. Assigning all slices under a single new root before any notification goes
+   * out is what closes the window this used to leave open: notifications fired per slice as each
+   * committed, so a subscriber to slice A that read `getState()` could observe slice B of the
+   * *same event* not yet applied. In React that window is real, because the atomic hooks use a
+   * change as a bare signal and then re-read the whole store.
+   *
+   * It is also what makes refusal possible at all. The previous code documented rollback as
+   * untenable precisely because "an event that reverted afterwards would have already told
+   * components about a value that no longer exists" — true when notification and commit were the
+   * same step, and no longer true now that they are not.
+   *
+   * @returns `true` if anything was written.
+   *
+   * @internal
+   */
+  commitStaged(e, t) {
+    if (e.length === 0) return !1;
+    const s = { ...this.state };
+    for (const n of e) s[n.name] = n.frozen;
+    if (this.state = s, this.changedPathSink)
+      for (const n of e)
+        for (const r of n.leafPaths)
+          this.changedPathSink.push(r ? `${n.name}.${r}` : n.name);
+    for (const n of e) {
+      const r = /* @__PURE__ */ new Set();
+      for (const o of n.leafPaths) {
+        if (o === "") {
+          r.add("");
+          continue;
+        }
+        for (const l of x.buildAncestorPaths(o)) r.add(l);
+      }
+      for (const o of r)
+        this.connectorBus.emitWith(n.name, o, () => ({
+          oldValue: this.getAtPath(n.prev, o),
+          newValue: this.getAtPath(n.frozen, o),
+          path: o,
+          // Provenance, built inside the same lazy factory as the values: a subscriber that
+          // needs to know why a value moved no longer has to mirror the cause into state and
+          // keep it there twice.
+          eventId: t.id,
+          channel: t.channel,
+          type: t.type
+        }));
+    }
+    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((l) => {
+      const i = this.patternReducers.get(l);
+      return { name: l, when: i };
+    }), t = [];
+    for (const [l, i] of this.effects) {
+      if (i.size === 0) continue;
+      const [a, d] = l.split("::");
+      for (const u of i) {
+        const f = this.effectMeta.get(u);
+        t.push({ channel: a, type: d, name: f?.name, description: f?.description });
+      }
+    }
+    for (const l of this.patternEffects) {
+      const i = this.effectMeta.get(l.effect);
+      t.push({
+        channel: "*",
+        type: "*",
+        name: i?.name,
+        description: i?.description
+      });
+    }
+    const s = [];
+    for (const l of this.middleware)
+      typeof l == "function" ? s.push({ name: l.name || void 0 }) : s.push({
+        name: l.meta?.name,
+        description: l.meta?.description,
+        when: l.when
+      });
+    const n = [];
+    for (const l of this.connectorBus.__introspect())
+      for (let i = 0; i < l.count; i++)
+        n.push({ reducer: l.channel, property: l.type });
+    const r = [];
+    for (const [l, i] of this.committedEventSubscribers) {
+      if (i.size === 0) continue;
+      const [a, d] = l.split("::");
+      for (let u = 0; u < i.size; u++)
+        r.push({ channel: a, type: d, phase: "committed" });
+    }
+    for (const [l, i] of this.uncommittedEventSubscribers) {
+      if (i.size === 0) continue;
+      const [a, d] = l.split("::");
+      for (let u = 0; u < i.size; u++)
+        r.push({ channel: a, type: d, phase: "uncommitted" });
+    }
+    for (const [l, i] of this.allEventSubscribers) {
+      if (i.size === 0) continue;
+      const [a, d] = l.split("::");
+      for (let u = 0; u < i.size; u++)
+        r.push({ channel: a, type: d, phase: "all" });
+    }
+    const o = this.listeners.size;
+    return {
+      reducers: e,
+      effects: t,
+      middleware: s,
+      atomic: n,
+      event: r,
+      coarse: o,
+      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 commitStaged}.
+   *
+   * **Missing slices**: the snapshot should contain every slice. A slice absent
+   * from `nextPlain` is **retained at its current value** (not blanked to
+   * `undefined`, which would make `getState().<slice>` throw on next access).
+   *
+   * @param nextPlain - Plain JS object to become the new state.
+   *
+   * @internal
+   */
+  __applyExternalState(e) {
+    if (!this.replayEnabled)
+      throw new Error(
+        "[yoltra] External state apply (time-travel) is disabled. Enable it with createStore({ devtools: { allowReplay: true } })"
+      );
+    const t = this.state, s = e, n = { ...this.state };
+    let r = !1;
+    Object.keys(this.reducers).forEach((o) => {
+      const l = t?.[o], i = s?.[o];
+      if (i === void 0) {
+        process.env.NODE_ENV !== "production" && console.warn(
+          `[yoltra] External state is missing slice "${String(
+            o
+          )}"; retaining its current value. Time-travel snapshots should contain all slices.`
+        );
+        return;
+      }
+      if (l === i) return;
+      const a = R(i);
+      n[o] = a, r = !0;
+      const d = I(l, i);
+      if (d.length === 0) return;
+      const u = /* @__PURE__ */ new Set();
+      for (const f of d) {
+        if (f === "") {
+          u.add("");
+          continue;
+        }
+        for (const m of x.buildAncestorPaths(f)) u.add(m);
+      }
+      for (const f of u) {
+        const m = this.getAtPath(l, f), h = this.getAtPath(a, f);
+        this.connectorBus.emit(o, f, { oldValue: m, newValue: h, path: f });
+      }
+    }), 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.stagingSink = r;
+      let o = null;
+      try {
+        this.reducerBus.emit(n.channel, n.type, n.payload, n), o = this.stagedRejection;
+        for (const [i, a] of this.patternReducers) {
+          if (o !== null) break;
+          if (this.matchesWhen(a, n)) {
+            const d = this.stageSliceGuarded(i, n, r);
+            d !== null && (o = d);
+          }
+        }
+      } finally {
+        this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
+      }
+      const l = o === null && this.commitStaged(r, n);
+      this.notifyEventSubscribers(n, "committed"), l && (this.notifyEventSubscribers(n, "written"), this.listeners.forEach((i) => i()));
+    }
+  }
+  /**
+   * 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) - every matching slice is *staged*; nothing is written yet, so a refusal from the last reducer still stops the first one's write
+   * 4. **Commit + subscribers** (sync) - all staged slices are assigned under one new root, then event subscribers (`committed`, then `written` when state actually changed), then coarse listeners
+   * 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 the commit builds 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, s, n) {
+    return this.emitCaused(null, e, t, s, n);
+  }
+  /**
+   * The real emit, with an explicitly supplied cause.
+   *
+   * @remarks
+   * Exists so the parent can be passed without a pseudo-private field on the public
+   * {@link EmitOptions}. Two callers supply one: the public {@link emit} passes `null` and lets
+   * `currentEvent` speak for the synchronous case, and the scoped `emit` handed to effects passes
+   * the event that triggered them — effects resume after the drain has ended, so nothing else
+   * could still know what caused them.
+   *
+   * @internal
+   */
+  async emitCaused(e, t, s, n, r) {
+    const o = r?.dedupKey, l = this.dedupConfig.windowMs;
+    if (r?.skipDedup !== !0 && (l > 0 || o !== void 0)) {
+      const m = o !== void 0 && l <= 0 ? D : l, h = o !== void 0 ? `${t}::${s}::#${o}` : this.fingerprint(t, s, n);
+      if (this.shouldDedupe(h, m))
+        return $;
+    }
+    const i = r?.id ?? this.idFactory(), a = this.currentEvent ?? e, d = a === null ? 0 : a.depth + 1;
+    if (a !== null && d > this.maxReduceDepth)
+      return this.reportCascade(
+        "maxReduceDepth",
+        this.maxReduceDepth,
+        {
+          channel: t,
+          type: s,
+          payload: n,
+          id: i,
+          ...r?.meta !== void 0 ? { meta: r.meta } : {},
+          parentId: a.id,
+          depth: d
+        },
+        d,
+        a.chain
+      ), $;
+    let u;
+    const f = new Promise((m) => {
+      u = m;
+    });
+    return this.reduceQueue.push({
+      channel: t,
+      type: s,
+      payload: n,
+      id: i,
+      meta: r?.meta,
+      resolve: u,
+      // Only carried for caused events, so a root event's object stays byte-identical to one
+      // built before causality existed — the same rule `meta` follows.
+      ...a !== null ? { parentId: a.id, depth: d, chain: a.chain } : {}
+    }), 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, this.transitionsThisDrain = 0;
+      try {
+        for (; this.reduceQueue.length > 0; ) {
+          const e = this.reduceQueue.shift(), { channel: t, type: s, payload: n, id: r, meta: o, resolve: l, parentId: i, depth: a, chain: d } = e, u = {
+            channel: t,
+            type: s,
+            payload: n,
+            id: r,
+            ...o !== void 0 ? { meta: o } : {},
+            ...i !== void 0 ? { parentId: i, depth: a } : {}
+          };
+          if (i !== void 0 && ++this.transitionsThisDrain > this.maxTransitionsPerDrain) {
+            this.reportCascade(
+              "maxTransitionsPerDrain",
+              this.maxTransitionsPerDrain,
+              u,
+              a,
+              d
+            ), l($);
+            continue;
+          }
+          this.currentEvent = {
+            id: r,
+            depth: a ?? 0,
+            chain: [...d ?? [], r].slice(-z)
+          };
+          const f = this.instrumentObservers.size > 0, m = f ? this.state : void 0, h = f ? [] : void 0;
+          h !== void 0 && (this.changedPathSink = h);
+          const y = f ? A() : 0;
+          let g = $;
+          try {
+            g = this.applyEventSync(u);
+          } catch (w) {
+            console.error("Emit reduce error:", w);
+          } finally {
+            f && (this.changedPathSink = null), this.currentEvent = null;
+          }
+          f && this.emitInstrumentation(
+            u,
+            g,
+            h ?? [],
+            m,
+            A() - y
+          ), this.runEventEffects(u, g, l);
+        }
+      } 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 o of this.middleware) {
+      const l = this.getMiddlewareWhen(o);
+      if (!this.matchesWhen(l, e)) continue;
+      const i = this.getMiddlewareFunction(o);
+      let a;
+      try {
+        a = i(this.state, e, this.emit), process.env.NODE_ENV !== "production" && typeof a?.then == "function" && console.error(
+          `[yoltra] Middleware for "${e.channel}/${e.type}" returned a Promise. Middleware is synchronous: a Promise is truthy, so this event was allowed without waiting and a "return false" inside it can never veto. Do the check synchronously, and put anything that must await in an effect.`
+        );
+      } catch (d) {
+        console.error("Middleware error:", d), a = !1;
+      }
+      if (!a)
+        return this.notifyEventSubscribers(e, "uncommitted"), $;
+    }
+    const t = [];
+    this.stagingSink = t;
+    let s = null, n = "";
+    try {
+      this.reducerBus.emit(
+        e.channel,
+        e.type,
+        e.payload,
+        e
+      ), s = this.stagedRejection, n = this.stagedRejectedBy;
+      for (const [o, l] of this.patternReducers) {
+        if (s !== null) break;
+        if (this.matchesWhen(l, e)) {
+          const i = this.stageSliceGuarded(o, e, t);
+          i !== null && (s = i, n = o);
+        }
+      }
+    } finally {
+      this.stagingSink = null, this.stagedRejection = null, this.stagedRejectedBy = "";
+    }
+    if (s !== null)
+      return this.onRejected?.(s, e, n), this.notifyEventSubscribers(e, "committed"), { committed: !0, written: !1, rejected: s };
+    const r = this.commitStaged(t, e);
+    return this.notifyEventSubscribers(e, "committed"), r && (this.notifyEventSubscribers(e, "written"), this.listeners.forEach((o) => o())), r ? se : ne;
+  }
+  /**
+   * 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, s) {
+    this.inFlightEffects++;
+    try {
+      t.committed && await this.notifyEffects(e);
+    } catch (n) {
+      console.error("Effect error:", n);
+    } finally {
+      this.inFlightEffects--, s(t);
+    }
+  }
+  /**
+   * 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 commitStaged} during this reduce, so DevTools patches need no
+   * re-diff.
+   *
+   * @internal
+   */
+  emitInstrumentation(e, t, s, n, r) {
+    const o = {}, l = {};
+    for (const a of s)
+      o[a] = this.getAtPath(n, a), l[a] = this.getAtPath(this.state, a);
+    const i = {
+      event: {
+        id: e.id,
+        channel: e.channel,
+        type: e.type,
+        payload: e.payload,
+        // Conditional, so an event without metadata produces an observer payload
+        // byte-identical to the pre-`meta` shape.
+        ...e.meta !== void 0 ? { meta: e.meta } : {}
+      },
+      committed: t.committed,
+      changedPaths: s,
+      prevValues: o,
+      nextValues: l,
+      reduceTimeMs: r,
+      // Present only when a reducer refused, so an observer can tell a refusal from a veto —
+      // identical in state, entirely different in cause.
+      ...t.rejected !== void 0 ? { rejected: t.rejected } : {}
+    };
+    for (const a of [...this.instrumentObservers])
+      try {
+        a(i);
+      } catch (d) {
+        console.error("Instrumentation observer error:", d);
+      }
+  }
+  /**
+   * 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, s) {
+    const n = this.connectorBus.on(e.reducer, e.property, t);
+    if (s?.immediate === !0) {
+      const r = this.state[e.reducer], o = e.property.includes("*") ? "" : e.property;
+      t({ oldValue: void 0, newValue: this.getAtPath(r, o), path: o });
+    }
+    return n;
+  }
+  /**
+   * 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 : n === "written" ? this.writtenEventSubscribers : this.allEventSubscribers;
+    return o.has(r) || o.set(r, /* @__PURE__ */ new Set()), o.get(r).add(s), () => {
+      const l = o.get(r);
+      l && (l.delete(s), l.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`. Return `false` to cancel event
+   *        propagation.
+   * @returns Unsubscribe function that removes this middleware.
+   *
+   * @remarks
+   * **Synchronous, and that is the contract.** The reduce phase completes before `emit()`
+   * returns, so the commit decision has to be available in the same tick. An `async` middleware
+   * returns a Promise, every Promise is truthy, and the veto would therefore never fire — the
+   * event would commit while the middleware was still deciding. The type rejects it; this note
+   * exists because the examples here used to teach it. Do authorization and validation here, and
+   * anything that needs to await in an effect.
+   *
+   * @example Logging middleware
+   * ```ts
+   * const off = store.registerMiddleware((state, event) => {
+   *   console.log('Event:', event.channel, event.type, event.payload);
+   *   return true; // allow
+   * });
+   * off();
+   * ```
+   *
+   * @example Cancellation middleware
+   * ```ts
+   * store.registerMiddleware((state, event) => {
+   *   if (event.type === 'forbidden') return false; // cancel
+   *   return true;
+   * });
+   * ```
+   *
+   * @public
+   */
+  registerMiddleware(e) {
+    return this.middleware.push(e), () => {
+      const t = this.middleware.indexOf(e);
+      t !== -1 && this.middleware.splice(t, 1);
+    };
+  }
+  /**
+   * Dynamically **adds** a named slice reducer at runtime.
+   *
+   * @param name - New slice name (must not already exist).
+   * @param spec - Reducer spec (state, when, reducer).
+   * @returns Disposer function that **removes** the slice (and its state).
+   *
+   * @example
+   * ```ts
+   * const dispose = store.registerReducer('filters', {
+   *   state: { q: '' },
+   *   events: [['ui', 'setQuery']],
+   *   reducer(s, evt) {
+   *     return evt.type === 'setQuery' ? { q: evt.payload } : s;
+   *   }
+   * });
+   * // Later:
+   * dispose();
+   * ```
+   *
+   * @public
+   */
+  registerReducer(e, t) {
+    if (Object.prototype.hasOwnProperty.call(this.reducers, e))
+      throw new Error(`Reducer ${e} already exists`);
+    return this.mountSlice(e, t, {
+      preserveState: !1
+    }), this.listeners.forEach((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 `when` targeting and `effect` (handler).
+   * @returns Unsubscribe function.
+   *
+   * @example Logging effect
+   * ```ts
+   * const off = store.registerEffect({
+   *   events: [['ui', 'increment']],
+   *   effect: async (evt, getState, emit) => {
+   *     console.log('increment', evt.payload, getState().counter.value);
+   *   }
+   * });
+   * off();
+   * ```
+   *
+   * @example Multi-event effect
+   * ```ts
+   * store.registerEffect({
+   *   events: [['ui', 'increment'], ['ui', 'decrement']],
+   *   effect: async (evt, getState, emit) => {
+   *     // Runs for both increment and decrement
+   *     await saveToServer(getState());
+   *   }
+   * });
+   * ```
+   *
+   * @public
+   */
+  /**
+   * Sends a request and waits for the reply, correlating the two automatically.
+   *
+   * @typeParam C  - Request channel.
+   * @typeParam T  - Request type within `C`.
+   * @param channel - Channel to send on.
+   * @param type - Event type to send.
+   * @param payload - The **request** payload. This is what you are sending; what comes back is
+   * described by {@link CallOptions.reply}, not by this.
+   * @param opts - Which replies end the call, and how long to wait. See {@link CallOptions}.
+   * @returns A {@link CallHandle}: `await` it for the terminal reply, or `for await` it for
+   * progress events as they arrive.
+   *
+   * @remarks
+   * Every consumer of an event bus eventually writes request/reply by hand — mint an id,
+   * subscribe, match, time out, unsubscribe — and every one of them writes the same eighty lines
+   * with the same two bugs: the subscription outlives the call, and a responder that forgets to
+   * echo the id produces a timeout with nothing to point at. This is that, once.
+   *
+   * **Correlation is causal.** The store stamps `parentId` on anything emitted while an event is
+   * being handled, so a responder that replies through the `emit` it was handed is already
+   * correlated. There is no id to mint, echo, or forget:
+   *
+   * ```ts
+   * store.registerEffect({
+   *   when: { keys: [["rpc", "ask"]] },
+   *   effect: async (event, _get, emit) => {
+   *     await emit("rpc", "answer", await lookup(event.payload.q));
+   *   },
+   * });
+   * ```
+   *
+   * **The reply carries its own discriminant.** A call resolves to the *event*, not the payload,
+   * because a caller often cannot know which kind of reply it will get:
+   *
+   * ```ts
+   * const res = await store.call("rpc", "ask", { q }, { reply: ["rpc", ["answer", "error"]] });
+   * switch (res.type) {
+   *   case "answer": return res.payload;
+   *   case "error":  throw new Error(res.payload.reason);
+   * }
+   * ```
+   *
+   * **Progress streams, with backpressure.** Any correlated event that is not terminal is
+   * progress, and iterating the call consumes it. The producer genuinely waits: `emit` resolves
+   * only once its effects have run, and the collector is an effect that does not return until the
+   * consumer has taken the item. A responder writing `await emit("rpc", "progress", chunk)` is
+   * therefore paced by the reader, with nothing buffering without bound.
+   *
+   * ```ts
+   * const call = store.call("job", "start", { id }, {
+   *   reply: ["job", "done"],
+   *   highWaterMark: 4,
+   * });
+   * for await (const step of call) await render(step.payload); // producer waits on this
+   * const { payload } = await call;
+   * ```
+   *
+   * Backpressure engages **once you begin iterating**. A call that is only awaited never pulls,
+   * so blocking its producer would deadlock the call itself — progress nobody reads would stop
+   * the terminal event from ever being sent. Un-iterated progress therefore buffers to
+   * `highWaterMark` and is then counted on {@link CallHandle.dropped} rather than blocking.
+   *
+   * **This is a local primitive.** A reply cannot reach it from a federated peer: the federation
+   * envelope carries neither `meta` nor `parentId`, and ingress namespaces the channel, so
+   * neither correlation nor the reply route survives the hop. That is not an oversight to route
+   * around — federation answers cross-node request/reply with typed peer *queries*, which are
+   * gated by a responder policy that may concede or deny. A call that federated silently would
+   * turn that access decision into an accident of which channel someone named. Ask a peer with a
+   * query; use `call` within a process.
+   *
+   * @example Timeout is idle, not total
+   * ```ts
+   * // Survives a job that streams for minutes; fails a responder that goes quiet for 5s.
+   * await store.call("job", "start", { id }, { reply: ["job", "done"], timeoutMs: 5_000 });
+   * ```
+   *
+   * @example Cancelling
+   * ```ts
+   * const call = store.call("rpc", "ask", { q }, { reply: ["rpc", "answer"] });
+   * useEffect(() => () => call.cancel("unmounted"), [call]);
+   * ```
+   *
+   * @public
+   */
+  call(e, t, s, n) {
+    const { channel: r, isTerminal: o } = q(n.reply), l = n.timeoutMs ?? ee, i = new G(n.highWaterMark ?? te), a = this.idFactory();
+    let d, u, f = !1;
+    const m = new Promise((b, S) => {
+      d = b, u = S;
+    });
+    m.catch(() => {
+    });
+    let h = null, y = null;
+    const g = (b, S = !1) => {
+      f || (f = !0, h !== null && clearTimeout(h), h = null, y?.(), y = null, S ? i.end() : i.close(), n.signal?.removeEventListener("abort", w), b());
+    };
+    function w() {
+      g(() => u(new C(String(n.signal?.reason ?? "signal aborted"))));
+    }
+    const k = () => {
+      h !== null && clearTimeout(h), h = setTimeout(() => {
+        g(() => u(new J(e, t, l)));
+      }, l), h.unref?.();
+    };
+    return y = this.registerEffect({
+      // A pattern effect on the reply channel: which types are terminal is known, which are
+      // progress is not, so the filter cannot be a key list.
+      when: { channel: r },
+      effect: async (b) => {
+        if (!f && Y(b, a, n.correlationId)) {
+          if (k(), o(String(b.type))) {
+            g(() => d(b), !0);
+            return;
+          }
+          await i.put(b);
+        }
+      }
+    }), n.signal !== void 0 && (n.signal.aborted ? w() : n.signal.addEventListener("abort", w, { once: !0 })), k(), this.emit(e, t, s, {
+      id: a,
+      ...n.correlationId !== void 0 ? { meta: { correlationId: n.correlationId } } : {}
+    }), {
+      then: (b, S) => m.then(b, S),
+      catch: (b) => m.catch(b),
+      finally: (b) => m.finally(b),
+      get dropped() {
+        return i.droppedCount;
+      },
+      cancel: (b = "cancelled") => {
+        g(() => u(new C(b)));
+      },
+      [Symbol.asyncIterator]: () => (i.beginConsuming(), {
+        next: () => i.take(),
+        // Called by `for await` on `break`, `return` or a throw. Without it, abandoning the
+        // loop would leave the effect registered and the producer parked for good.
+        return: async () => (i.close(), { value: void 0, done: !0 })
+      })
+    };
+  }
+  registerEffect(e) {
+    const { effect: t, meta: s, when: n } = e, r = [];
+    if (s && this.effectMeta.set(t, s), n && ("any" in n && n.any === !0 || "channel" in n || "channels" in n)) {
+      const i = { effect: t, when: n };
+      return this.patternEffects.add(i), () => {
+        this.patternEffects.delete(i);
+      };
+    }
+    const l = this.normalizeEventKeys(e);
+    if (l.length === 0 && !n) {
+      const i = { effect: t, when: { any: !0 } };
+      return this.patternEffects.add(i), () => {
+        this.patternEffects.delete(i);
+      };
+    }
+    for (const [i, a] of l) {
+      const d = `${String(i)}::${String(a)}`;
+      this.effects.has(d) || this.effects.set(d, /* @__PURE__ */ new Set()), this.effects.get(d).add(t), r.push(() => {
+        const u = this.effects.get(d);
+        u && (u.delete(t), u.size === 0 && this.effects.delete(d));
+      });
+    }
+    return () => {
+      for (const i of r) i();
+    };
+  }
+  /**
+   * 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, l) => {
+      if (r.channel !== e || r.type !== t) return;
+      const i = r;
+      return s(i.payload, o, l, i);
+    };
+    return this.registerEffect({
+      when: { keys: [[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(([l]) => l));
+    for (const l of n)
+      o.has(l) || this.unmountSlice(l, { deleteState: !0 });
+    for (const [l, i] of r)
+      n.has(l) ? (this.unmountSlice(l, { deleteState: !1 }), this.mountSlice(l, i, { preserveState: s })) : this.mountSlice(l, i, { preserveState: !1 });
+  }
+  /**
+   * Convenience API to replace **any subset** of store parts (HMR patterns).
+   *
+   * @param partial - Partial replacement set.
+   *
+   * @example Replace everything
+   * ```ts
+   * store.hotReplace({
+   *   reducer: newReducers,
+   *   middleware: newMiddleware,
+   *   effects: newEffects,
+   *   preserveState: true
+   * });
+   * ```
+   *
+   * @public
+   */
+  hotReplace(e) {
+    e.middleware && this.replaceMiddleware(e.middleware), e.effects && this.replaceEffects(e.effects), e.reducer && this.replaceReducers(e.reducer, { preserveState: e.preserveState });
+  }
+  /**
+   * Mounts a slice: installs reducer, initializes state (unless preserved),
+   * and wires `(channel, type)` listeners on the reducer bus.
+   *
+   * @param name - Slice name.
+   * @param rSpec - Reducer spec (state, when, reducer).
+   * @param opts - `{ preserveState: boolean }` whether to keep existing state.
+   *
+   * @internal
+   */
+  mountSlice(e, t, s) {
+    const n = e, { reducer: r, state: o, when: l } = t;
+    if (this.reducers[e] = new V(r), (!s.preserveState || this.state[n] === void 0) && (this.state = {
+      ...this.state,
+      [n]: R(X(n, o))
+    }), l && ("any" in l && l.any === !0 || "channel" in l || "channels" in l)) {
+      this.patternReducers.set(e, l), this.sliceUnsubs.set(n, []);
+      return;
+    }
+    const a = this.normalizeEventKeys(t);
+    if (a.length === 0 && !l) {
+      this.patternReducers.set(e, { any: !0 }), this.sliceUnsubs.set(n, []);
+      return;
+    }
+    const d = [];
+    for (const [u, f] of a) {
+      const m = this.reducerBus.on(u, f, (h, y) => {
+        const g = y ?? {
+          channel: u,
+          type: f,
+          payload: h,
+          id: this.idFactory()
+        };
+        if (this.stagingSink === null) return;
+        const w = this.stageSliceGuarded(e, g, this.stagingSink);
+        w !== null && this.stagedRejection === null && (this.stagedRejection = w, this.stagedRejectedBy = e);
+      });
+      d.push(m);
+    }
+    this.sliceUnsubs.set(n, d);
+  }
+  /**
+   * 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);
+    }
+    if (delete this.reducers[e], t.deleteState) {
+      const { [s]: r, ...o } = this.state;
+      this.state = o;
+    }
+  }
+  /**
+   * Normalizes event targeting from `when` to an array of EventKeys.
+   *
+   * @param spec - Object with an optional `when` matcher.
+   * @returns Array of `[channel, type]` pairs.
+   *
+   * @internal
+   */
+  normalizeEventKeys(e) {
+    if (e.when) {
+      const t = e.when;
+      if ("keys" in t)
+        return t.keys;
+    }
+    return [];
+  }
+  /**
+   * Reads a dotted path from an object (supports numeric array indices via string keys).
+   *
+   * @param obj - Root object (slice or value).
+   * @param path - Dotted path; leading dot is ignored.
+   * @returns The value at the path, or `undefined`.
+   *
+   * @internal
+   */
+  getAtPath(e, t) {
+    if (!t) return e;
+    const 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 de(c) {
+  return new x({
+    ...c,
+    reducer: c.reducer ?? {},
+    middleware: c.middleware ?? [],
+    effects: c.effects ?? []
+  });
+}
+const ue = (c) => (e, t) => t.map((s) => [e, s]), fe = () => (c) => c, _ = /* @__PURE__ */ new Set();
+function re(c) {
+  const e = String(c);
+  _.has(e) || (_.add(e), console.warn(
+    `[yoltra] Entity id "${e}" contains a dot. Paths are dotted, so a subscription to "entities.${e}" is indistinguishable from one to a nested object of the same name. Use ids without dots.`
+  ));
+}
+function ie(c, e) {
+  if (c.length !== e.length) return e;
+  for (let t = 0; t < c.length; t++)
+    if (c[t] !== e[t]) return e;
+  return c;
+}
+function he(c = {}) {
+  const e = c.selectId ?? ((i) => i.id), { sortComparer: t } = c, s = (i, a) => {
+    if (t === void 0) return a;
+    const d = [...a].sort((u, f) => {
+      const m = i.entities[u], h = i.entities[f];
+      return m === void 0 || h === void 0 ? 0 : t(m, h);
+    });
+    return ie(a, d);
+  }, n = (i, a, d) => {
+    const u = { ...i, entities: a, ids: d };
+    return { ...u, ids: s(u, d) };
+  }, r = (i, a, d) => {
+    let u = null, f = null;
+    for (const m of a) {
+      const h = e(m);
+      process.env.NODE_ENV !== "production" && String(h).includes(".") && re(h);
+      const y = (u ?? i.entities)[h];
+      if (y !== void 0 && d === "add") continue;
+      const g = y !== void 0 && d === "upsert" ? { ...y, ...m } : m;
+      u ?? (u = { ...i.entities }), u[h] = g, y === void 0 && (f ?? (f = [...i.ids]), f.push(h));
+    }
+    return u === null ? i : n(i, u, f ?? i.ids);
+  }, o = (i, a) => {
+    let d = null;
+    for (const { id: u, changes: f } of a) {
+      const m = (d ?? i.entities)[u];
+      m !== void 0 && (d ?? (d = { ...i.entities }), d[u] = { ...m, ...f });
+    }
+    return d === null ? i : n(i, d, i.ids);
+  }, l = (i, a) => {
+    const d = new Set(a.filter((f) => i.entities[f] !== void 0));
+    if (d.size === 0) return i;
+    const u = { ...i.entities };
+    for (const f of d) delete u[f];
+    return n(
+      i,
+      u,
+      i.ids.filter((f) => !d.has(f))
+    );
+  };
+  return {
+    getInitialState(i) {
+      const a = { ids: [], entities: {} };
+      return i === void 0 ? a : { ...a, ...i };
+    },
+    addOne: (i, a) => r(i, [a], "add"),
+    addMany: (i, a) => r(i, a, "add"),
+    setOne: (i, a) => r(i, [a], "set"),
+    setMany: (i, a) => r(i, a, "set"),
+    setAll: (i, a) => {
+      const d = {}, u = [];
+      for (const f of a) {
+        const m = e(f);
+        d[m] === void 0 && u.push(m), d[m] = f;
+      }
+      return n(i, d, u);
+    },
+    updateOne: (i, a) => o(i, [a]),
+    updateMany: (i, a) => o(i, a),
+    upsertOne: (i, a) => r(i, [a], "upsert"),
+    upsertMany: (i, a) => r(i, a, "upsert"),
+    removeOne: (i, a) => l(i, [a]),
+    removeMany: (i, a) => l(i, a),
+    removeAll: (i) => i.ids.length === 0 ? i : n(i, {}, []),
+    selectIds: (i) => i.ids,
+    selectEntities: (i) => i.entities,
+    selectAll: (i) => i.ids.map((a) => i.entities[a]),
+    selectById: (i, a) => i.entities[a],
+    selectTotal: (i) => i.ids.length,
+    idsPath: "ids",
+    pathTo: (i, a) => a === void 0 ? `entities.${i}` : `entities.${i}.${a}`,
+    anyField: (i) => `entities.*.${i}`
+  };
+}
+const E = "$yoltra";
+function B(c, e = {}) {
+  const t = e.maxNodes ?? 1e5, s = e.sanitize, n = [], r = /* @__PURE__ */ new Map();
+  let o = 0, l = !1;
+  function i(d, u) {
+    if (s !== void 0 && (d = s(u, d)), o += 1, o > t)
+      return l = !0, { [E]: "unsupported", kind: "truncated" };
+    switch (typeof d) {
+      case "undefined":
+        return { [E]: "undefined" };
+      case "bigint":
+        return { [E]: "bigint", value: d.toString() };
+      case "number":
+        return Number.isNaN(d) ? { [E]: "nan" } : d === 1 / 0 ? { [E]: "infinity", sign: 1 } : d === -1 / 0 ? { [E]: "infinity", sign: -1 } : d;
+      case "function":
+      case "symbol":
+        return n.push(u), { [E]: "unsupported", kind: typeof d };
+      case "string":
+      case "boolean":
+        return d;
+    }
+    if (d === null) return null;
+    const f = d, m = r.get(f);
+    if (m !== void 0) return { [E]: "ref", path: m };
+    if (r.set(f, u), d instanceof Date)
+      return { [E]: "date", iso: d.toISOString() };
+    if (d instanceof RegExp)
+      return { [E]: "regexp", source: d.source, flags: d.flags };
+    if (d instanceof Error)
+      return { [E]: "error", name: d.name, message: d.message };
+    if (d instanceof Map) {
+      const y = [];
+      let g = 0;
+      for (const [w, k] of d)
+        y.push([i(w, `${u}/@k${g}`), i(k, `${u}/${g}`)]), g += 1;
+      return { [E]: "map", entries: y };
+    }
+    if (d instanceof Set) {
+      const y = [];
+      let g = 0;
+      for (const w of d)
+        y.push(i(w, `${u}/${g}`)), g += 1;
+      return { [E]: "set", values: y };
+    }
+    if (Array.isArray(d))
+      return d.map((y, g) => i(y, `${u}/${g}`));
+    const h = {};
+    for (const [y, g] of Object.entries(d))
+      h[y] = i(g, `${u}/${H(y)}`);
+    return E in h ? { [E]: "escaped", value: h } : h;
+  }
+  return { value: i(c, ""), report: { truncated: l, unsupported: n } };
+}
+function oe(c) {
+  const e = /* @__PURE__ */ new Map(), t = [];
+  function s(o, l) {
+    if (o === null || typeof o != "object") return o;
+    if (Array.isArray(o)) {
+      const a = [];
+      return e.set(l, a), o.forEach((d, u) => {
+        if (j(d)) {
+          t.push({ target: a, key: u, path: d.path }), a[u] = void 0;
+          return;
+        }
+        a[u] = s(d, `${l}/${u}`);
+      }), a;
+    }
+    if (typeof o[E] == "string") {
+      const a = o;
+      switch (a[E]) {
+        case "undefined":
+          return;
+        case "nan":
+          return Number.NaN;
+        case "infinity":
+          return a.sign === 1 ? 1 / 0 : -1 / 0;
+        case "bigint":
+          return BigInt(a.value);
+        case "date":
+          return new Date(a.iso);
+        case "regexp":
+          return new RegExp(a.source, a.flags);
+        case "error": {
+          const d = new Error(a.message);
+          return d.name = a.name, d;
+        }
+        case "unsupported":
+          return;
+        case "ref":
+          return;
+        case "map": {
+          const d = /* @__PURE__ */ new Map();
+          return e.set(l, d), a.entries.forEach(([u, f], m) => {
+            d.set(s(u, `${l}/@k${m}`), s(f, `${l}/${m}`));
+          }), d;
+        }
+        case "set": {
+          const d = /* @__PURE__ */ new Set();
+          return e.set(l, d), a.values.forEach((u, f) => d.add(s(u, `${l}/${f}`))), d;
+        }
+        case "escaped":
+          return n(a.value, l);
+        default:
+          return;
+      }
+    }
+    return n(o, l);
+  }
+  function n(o, l) {
+    const i = {};
+    e.set(l, i);
+    for (const [a, d] of Object.entries(o)) {
+      const u = `${l}/${H(a)}`;
+      if (j(d)) {
+        t.push({ target: i, key: a, path: d.path }), i[a] = void 0;
+        continue;
+      }
+      i[a] = s(d, u);
+    }
+    return i;
+  }
+  const r = s(c, "");
+  e.set("", r);
+  for (const { target: o, key: l, path: i } of t)
+    o[l] = e.get(i);
+  return r;
+}
+function j(c) {
+  return c !== null && typeof c == "object" && c[E] === "ref" && typeof c.path == "string";
+}
+function H(c) {
+  return c.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function pe(c, e, t = {}) {
+  let s = t.maxNodes ?? 1e5;
+  for (let n = 0; n < 8; n += 1) {
+    const { value: r, report: o } = B(c, { ...t, maxNodes: s });
+    let l;
+    try {
+      l = JSON.stringify(r)?.length ?? 0;
+    } catch {
+      l = Number.POSITIVE_INFINITY;
+    }
+    if (l <= e)
+      return o.truncated ? {
+        value: r,
+        truncated: !0,
+        note: `State was too large to send in full; parts beyond ${s} nodes are omitted.`
+      } : { value: r, truncated: !1 };
+    const i = Math.floor(s * e * 0.8 / l);
+    if (s = Math.max(1, Math.min(i, s - 1)), s <= 1 && n > 0)
+      break;
+  }
+  return {
+    value: { [E]: "unsupported", kind: "truncated" },
+    truncated: !0,
+    note: `State exceeds the ${e}-byte transport limit and could not be reduced to fit.`
+  };
+}
+function v(c, e, t) {
+  c.onError?.(e, t);
+}
+async function me(c) {
+  const e = { slices: {}, restored: !1 };
+  let t;
+  try {
+    t = c.source ?? await c.adapter.read(c.key);
+  } catch (n) {
+    return v(c, n, "read"), e;
+  }
+  if (t == null || t === "") return e;
+  let s;
+  try {
+    s = oe(JSON.parse(t));
+  } catch (n) {
+    return v(c, n, "decode"), e;
+  }
+  if (s === null || typeof s != "object" || typeof s.version != "number")
+    return v(c, new Error("persisted payload is not a recognisable envelope"), "decode"), e;
+  if (s.version !== c.version) {
+    if (c.migrate === void 0)
+      return v(
+        c,
+        new Error(
+          `persisted state is version ${s.version}, this build expects ${c.version}, and no migrate was supplied`
+        ),
+        "migrate"
+      ), e;
+    try {
+      const n = c.migrate(s.slices, s.version);
+      return n === null ? e : { slices: n, restored: !0 };
+    } catch (n) {
+      return v(c, n, "migrate"), e;
+    }
+  }
+  return { slices: s.slices ?? {}, restored: !0 };
+}
+function ye(c, e) {
+  if (!e.restored) return c;
+  const t = {};
+  for (const [s, n] of Object.entries(c)) {
+    const r = e.slices[s];
+    t[s] = r === void 0 ? n : { ...n, state: r };
+  }
+  return t;
+}
+function W(c, e) {
+  const t = c ?? {}, s = e.slices === void 0 ? t : Object.fromEntries(e.slices.filter((n) => n in t).map((n) => [n, t[n]]));
+  return JSON.stringify(B({ version: e.version, slices: s }).value);
+}
+function ge(c, e) {
+  const t = e.throttleMs ?? 250, s = e.slices;
+  let n = null, r = !1;
+  const o = () => {
+    if (r) {
+      r = !1;
+      try {
+        const a = e.adapter.write(e.key, W(c.getState(), e));
+        a instanceof Promise && a.catch((d) => v(e, d, "write"));
+      } catch (a) {
+        v(e, a, "write");
+      }
+    }
+  }, l = () => {
+    if (r = !0, t <= 0) {
+      o();
+      return;
+    }
+    n === null && (n = setTimeout(() => {
+      n = null, o();
+    }, t), n.unref?.());
+  }, i = c.instrument((a) => {
+    if (s === void 0) {
+      l();
+      return;
+    }
+    (a.changedPaths ?? []).some(
+      (u) => s.some((f) => u === f || u.startsWith(`${f}.`))
+    ) && l();
+  });
+  return () => {
+    i(), n !== null && (clearTimeout(n), n = null), o();
+  };
+}
+function we(c, e) {
+  return W(c.getState(), e);
+}
+function Ee(c) {
+  return {
+    read: (e) => c.getItem(e),
+    write: (e, t) => c.setItem(e, t),
+    remove: (e) => c.removeItem(e)
+  };
+}
+function be(c) {
+  const e = new Map(Object.entries(c ?? {}));
+  return {
+    read: (t) => e.get(t) ?? null,
+    write: (t, s) => {
+      e.set(t, s);
+    },
+    remove: (t) => {
+      e.delete(t);
+    }
+  };
+}
+export {
+  C as CallAbortedError,
+  J as CallTimeoutError,
+  U as EventBus,
+  L as LooseEventBus,
+  V as Reducer,
+  le as Rejected,
+  x as Store,
+  he as createEntityAdapter,
+  be as createMemoryAdapter,
+  de as createStore,
+  Ee as createWebStorageAdapter,
+  oe as decodeState,
+  we as dehydrate,
+  I as detectChangedProps,
+  B as encodeState,
+  pe as encodeStateBounded,
+  fe as eventKeys,
+  M as freezeState,
+  me as hydrate,
+  Q as isRejected,
+  ge as persist,
+  ue as typedEvents,
+  ye as withHydration
+};
+//# sourceMappingURL=yoltra.mjs.map