pinia-plugin-subscription 1.0.0-beta.8 → 1.0.0-beta.9

package/CHANGELOG.md

@@ -7,7 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+- `storeMutationSubscription` now supports several subscribers per store, like `storeOnActionSubscription`: a single `$subscribe` is registered per store and dispatches to every callback. A failing callback is reported through `traceError` without blocking the others, subscriber names are tracked, and the hook is unsubscribed when the store is disposed
+- `storeOnActionSubscription` now receives the Pinia plugin context; action trace labels include the invoked action name
+
 ### Added
+- Added `addScopesListener(scopes, context?)` to `createTracerRegistry()` for grouping events from selected store scopes; documented in `docs/tracing.md`
 - `traceGroups` glossary, exported from `pinia-plugin-subscription/helpers`, building the `groupId` emitted by `PluginSubscription` (`onActionAfter`, `onActionError`, `onMutation`, `reset`); documented in `docs/tracing.md`
 - `createPluginSubscriber(name, invoke, optionalProps?)` factory, exported from `pinia-plugin-subscription/helpers`, to build plain-object subscribers; documented in `docs/authoring-plugins.md` and used by the demo plugin
 - Added a dedicated tracing guide, `docs/tracing.md`; the README now only presents tracing and links to it
@@ -43,6 +48,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The `pluginsubscription` namespace prefix is now a shared constant (`pluginSubscriptionNamespace`) instead of a hard-coded string
 
 ### Fixed
+- Group listener filters receive only trace metadata, redaction safely copies own `__proto__` keys, and registry group payload factories are skipped when no listeners are registered
+- Subscriber, subscription, action and rollback tracking keys now encode store IDs and names without delimiter collisions; disposing a store removes only its own tracking entries
 - Trace groups opened by `onAction`, `$subscribe` and `$reset` are now always closed (also when the action fails or a callback throws), so grouped events no longer stay buffered forever
 - Listener definitions passed to `addListener()` are no longer mutated when their `filter` is an array of criteria
 - `TracerHandler` and `TraceRegistry` types now match the implementation (`createTracer(source, options?)`, `void` group callbacks, `addListener()` with options, `tracerHandler`); `createTracerRegistry()` is explicitly typed as `TraceRegistry`

package/README.md

@@ -63,7 +63,8 @@ app.mount('#app')
 
 ## Advanced Features
 
-- **Structured tracing:** Subscribe to typed trace events and filter them at runtime, per store or per namespace — see [Tracing](#tracing).
+- **Structured tracing:** Subscribe to typed trace events and filter them at runtime, per store or per namespace. Group filters receive metadata only, and the built-in registry avoids preparing group payloads when it has no listeners — see [Tracing](#tracing).
+- **Scope-based trace listeners:** Use `addScopesListener()` to group events from selected stores — see [Tracing](docs/tracing.md#filtering-events).
 - **Reset callbacks:** Define `resetStoreCallback` to run custom logic when a store is reset.
 - **SSR and hydration control:** Configure whether each subscribed plugin runs on the server, the client, or only after client hydration.
 - **Lifecycle safety:** Internal hydration ordering is now guarded so `hydrate()` completes before `afterHydration()` and disposed stores do not retain stale subscriber metadata.

package/dist/chunks/{PluginSubscription-C_a6v8oi.js → PluginSubscription-ZO5mkdvZ.js}

@@ -1,9 +1,9 @@
-var w = Object.defineProperty;
-var H = (i, s, t) => s in i ? w(i, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[s] = t;
+var M = Object.defineProperty;
+var H = (i, s, t) => s in i ? M(i, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[s] = t;
 var a = (i, s, t) => H(i, typeof s != "symbol" ? s + "" : s, t);
-import { toRaw as k } from "vue";
-import { defineStore as E } from "pinia";
-function u(i) {
+import { toRaw as $ } from "vue";
+import { defineStore as O } from "pinia";
+function d(i) {
   if (typeof structuredClone == "function")
     try {
       return structuredClone(i);
@@ -13,64 +13,64 @@ function u(i) {
     return i;
   if (i instanceof Map)
     return new Map(
-      Array.from(i.entries(), ([t, e]) => [u(t), u(e)])
+      Array.from(i.entries(), ([t, e]) => [d(t), d(e)])
     );
   if (i instanceof Set)
-    return new Set(Array.from(i.values(), (t) => u(t)));
+    return new Set(Array.from(i.values(), (t) => d(t)));
   if (Array.isArray(i))
-    return i.map((t) => u(t));
+    return i.map((t) => d(t));
   if (Object.getPrototypeOf(i) === Object.prototype || Object.getPrototypeOf(i) === null)
     return Object.fromEntries(
-      Object.entries(i).map(([t, e]) => [t, u(e)])
+      Object.entries(i).map(([t, e]) => [t, d(e)])
     );
   const s = Object.create(Object.getPrototypeOf(i));
   for (const [t, e] of Object.entries(i))
-    s[t] = u(e);
+    s[t] = d(e);
   return s;
 }
 function R(i, s = "all") {
   if (Array.isArray(s)) {
     const t = {};
     for (const e of s)
-      e in i && (t[e] = u(k(i[e])));
+      e in i && (t[e] = d($(i[e])));
     return t;
   }
   if (s !== "all")
     throw new Error(`Invalid keys parameter: ${s}`);
-  return u(k(i));
+  return d($(i));
 }
-const A = /* @__PURE__ */ new WeakMap(), b = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new WeakSet();
-function x(i, s) {
-  if ($.has(i) || typeof i.$dispose != "function")
+const A = /* @__PURE__ */ new WeakMap(), b = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new WeakSet();
+function T(i, s) {
+  if (g.has(i) || typeof i.$dispose != "function")
     return;
   const t = i.$dispose;
-  i.$dispose = (...e) => (A.delete(i), b.delete(s), t.apply(i, e)), $.add(i);
+  i.$dispose = (...e) => (A.delete(i), b.delete(s), t.apply(i, e)), g.add(i);
 }
-function N(i, s, t) {
+function q(i, s, t) {
   const e = t ? { storeOptions: t } : {};
-  return typeof s == "function" ? g(
+  return typeof s == "function" ? C(
     i,
     s,
     e
-  ) : v(
+  ) : x(
     i,
     s,
     e
   );
 }
-function q(i, s, t) {
+function z(i, s, t) {
   const e = t ? { storeOptions: { ...t, enhancedStore: !0 } } : { storeOptions: { enhancedStore: !0 } };
-  return g(
+  return C(
     i,
     s,
     e
   );
 }
-function g(i, s, t) {
+function C(i, s, t) {
   const e = {
     id: i,
     extensions: {}
-  }, r = t?.storeOptions?.enhancedStore === !0, n = E(
+  }, r = t?.storeOptions?.enhancedStore === !0, n = O(
     i,
     () => s(e),
     t
@@ -78,17 +78,17 @@ function g(i, s, t) {
   return Object.assign(((...c) => {
     r && b.set(i, e);
     const o = n(...c);
-    return r && (A.set(o, e), b.delete(i), x(o, i)), o;
+    return r && (A.set(o, e), b.delete(i), T(o, i)), o;
   }), n);
 }
-function v(i, s, t) {
-  return t && (s = { ...s, ...t ?? {} }), E(i, s);
+function x(i, s, t) {
+  return t && (s = { ...s, ...t ?? {} }), O(i, s);
 }
 const P = /* @__PURE__ */ new Set(["_", "$"]);
-function T(i) {
+function v(i) {
   return P.has(i[0]);
 }
-function z(i) {
+function U(i) {
   const s = i;
   return A.get(i) ?? (typeof s?.$id == "string" ? b.get(s.$id) : void 0);
 }
@@ -101,8 +101,15 @@ function B(i) {
 function J(i, s) {
   i.extensions.enhancedStore = s, i.extensions.extending = s;
 }
-function S(i, s) {
-  return `${i}-${s.$id}`;
+function f(i, s) {
+  return _(i, s);
+}
+function y(i) {
+  const s = String(i.$id);
+  return `${s.length}:${s}:`;
+}
+function _(i, s) {
+  return `${y(s)}${i.length}:${i}`;
 }
 class D {
   constructor() {
@@ -113,13 +120,13 @@ class D {
   addRollbackAction(s) {
     typeof s.$rollbackAfterFailure != "function" && (s.$rollbackAfterFailure = async ({ action: t, stateKeys: e }, r = []) => {
       const n = s[t];
-      if (typeof n != "function" || T(t))
+      if (typeof n != "function" || v(t))
         return;
       const c = !e || e.length === 0 ? "all" : e, o = this.saveStateSnapshot(s, t, c);
       try {
         await n.apply(s, r);
-      } catch (h) {
-        throw this.patchStore(o, s), h;
+      } catch (u) {
+        throw this.patchStore(o, s), u;
       } finally {
         this.removeStateSnapshot(o);
       }
@@ -127,7 +134,7 @@ class D {
   }
   createOnActionCallbacks(s, t) {
     const e = this._storeRollbackSnapshotsParams.get(
-      S(s, t)
+      f(s, t)
     );
     if (!e)
       return;
@@ -146,18 +153,18 @@ class D {
     e && !this._storeHasRollbackSnapshots.has(t.$id) && (Object.keys(e).forEach((r) => {
       const n = e[r];
       n && this._storeRollbackSnapshotsParams.set(
-        S(r, t),
+        f(r, t),
         n
       );
     }), this._storeHasRollbackSnapshots.add(t.$id)), this.addRollbackAction(t);
   }
   clearStoreTracking(s) {
-    const t = `-${s.$id}`;
+    const t = y(s);
     for (const e of Array.from(this._storeRollbackSnapshotsParams.keys()))
-      e.endsWith(t) && this._storeRollbackSnapshotsParams.delete(e);
+      e.startsWith(t) && this._storeRollbackSnapshotsParams.delete(e);
     this._storeHasRollbackSnapshots.delete(s.$id);
     for (const e of Array.from(this._stateSnapshots.keys()))
-      e.description?.startsWith(`${s.$id}:`) && this._stateSnapshots.delete(e);
+      e.description?.startsWith(t) && this._stateSnapshots.delete(e);
   }
   patchStore(s, t) {
     const e = this._stateSnapshots.get(s);
@@ -175,7 +182,7 @@ class D {
     const r = R(
       s.$state,
       e
-    ), n = /* @__PURE__ */ Symbol(`${s.$id}:${t}`);
+    ), n = Symbol(f(t, s));
     return this._stateSnapshots.set(n, r), n;
   }
   storeHasRollbackSnapshots(s) {
@@ -210,34 +217,38 @@ class G {
     return this.classNameAddedToTraceNamespace ? `${this._className}:${s}` : s;
   }
 }
-function O(i) {
+function E(i) {
   return i ? Array.isArray(i) ? i.length === 0 : typeof i == "object" ? Object.keys(i).length === 0 : typeof i == "string" ? i.trim() === "" : !1 : !(typeof i == "boolean" || typeof i == "number");
 }
-const j = "pinia-plugin-subscription", C = "PluginSubscription", Q = C.toLowerCase(), d = {
+const j = "pinia-plugin-subscription", m = "PluginSubscription", Q = m.toLowerCase(), l = {
   onActionAfter: (i) => `store:onAction:after:${i}`,
   onActionError: (i) => `store:onAction:onError:${i}`,
   onMutation: (i) => `store:onMutation:${i}`,
   reset: (i) => `store:reset:${i}`
-}, M = C, F = {
+}, I = m, F = {
   environment: "both",
   hydration: "immediate"
 };
-function I(i) {
+function K(i) {
   if (typeof window < "u" && typeof window.requestAnimationFrame == "function") {
     window.requestAnimationFrame(() => globalThis.setTimeout(i, 0));
     return;
   }
   globalThis.setTimeout(i, 0);
 }
-class U extends G {
+class V extends G {
   constructor(t, e) {
     super();
-    a(this, "_className", M);
+    a(this, "_className", I);
     a(this, "_hydrationScheduler");
     a(this, "_onActionSubscriptions", /* @__PURE__ */ new Map());
+    a(this, "_onActionSubscriptionsTraces", /* @__PURE__ */ new Map());
     a(this, "_onActionStores", /* @__PURE__ */ new Set());
     a(this, "_onActionAfterSubscriptions", {});
     a(this, "_onActionOnErrorSubscriptions", {});
+    a(this, "_onMutationSubscriptions", /* @__PURE__ */ new Map());
+    a(this, "_onMutationSubscriptionsTraces", /* @__PURE__ */ new Map());
+    a(this, "_onMutationUnsubscribes", /* @__PURE__ */ new Map());
     a(this, "_options");
     a(this, "_resetStoreCallback", /* @__PURE__ */ new Map());
     a(this, "_disposedStores", /* @__PURE__ */ new WeakSet());
@@ -248,21 +259,21 @@ class U extends G {
     a(this, "_subscriptions", []);
     a(this, "_subscriptionsDelivered", /* @__PURE__ */ new Set());
     a(this, "_subscriptionsScheduled", /* @__PURE__ */ new Set());
-    this._hydrationScheduler = e?.hydrationScheduler ?? I, this._options = e, this._subscribers = t, this.initializeTracer();
+    this._hydrationScheduler = e?.hydrationScheduler ?? K, this._options = e, this._subscribers = t, this.initializeTracer();
   }
   set subscribers(t) {
     this._subscribers = t;
   }
   get subscriptions() {
-    if (!O(this._subscriptions))
+    if (!E(this._subscriptions))
       return this._subscriptions;
   }
   addOnActionAfterCallback(t, e, r) {
-    const n = S(t, e);
+    const n = f(t, e);
     this._onActionAfterSubscriptions[n] || (this._onActionAfterSubscriptions[n] = []), this._onActionAfterSubscriptions[n]?.push(r);
   }
   addOnActionOnErrorCallback(t, e, r) {
-    const n = S(t, e);
+    const n = f(t, e);
     this._onActionOnErrorSubscriptions[n] || (this._onActionOnErrorSubscriptions[n] = []), this._onActionOnErrorSubscriptions[n]?.push(r);
   }
   addResetStoreCallback(t, e) {
@@ -272,20 +283,20 @@ class U extends G {
     delete this._onActionAfterSubscriptions[t], delete this._onActionOnErrorSubscriptions[t];
   }
   clearStoreTracking(t) {
-    this._onActionSubscriptions.delete(t), this._onActionStores.delete(t), this._resetStoreCallback.delete(t);
-    const e = `-${t.$id}`;
+    this._onActionSubscriptions.delete(t), this._onActionStores.delete(t), this._onMutationUnsubscribes.get(t)?.(), this._onMutationUnsubscribes.delete(t), this._onMutationSubscriptions.delete(t), this._resetStoreCallback.delete(t), this._onActionSubscriptionsTraces.delete(t.$id), this._onMutationSubscriptionsTraces.delete(t.$id);
+    const e = y(t);
     for (const r of Array.from(this._subscribersDelivered))
-      r.endsWith(e) && this._subscribersDelivered.delete(r);
+      r.startsWith(e) && this._subscribersDelivered.delete(r);
     for (const r of Array.from(this._subscribersScheduled))
-      r.endsWith(e) && this._subscribersScheduled.delete(r);
+      r.startsWith(e) && this._subscribersScheduled.delete(r);
     for (const r of Array.from(this._subscriptionsDelivered))
-      r.endsWith(e) && this._subscriptionsDelivered.delete(r);
+      r.startsWith(e) && this._subscriptionsDelivered.delete(r);
     for (const r of Array.from(this._subscriptionsScheduled))
-      r.endsWith(e) && this._subscriptionsScheduled.delete(r);
+      r.startsWith(e) && this._subscriptionsScheduled.delete(r);
     for (const r of Object.keys(this._onActionAfterSubscriptions))
-      r.endsWith(e) && delete this._onActionAfterSubscriptions[r];
+      r.startsWith(e) && delete this._onActionAfterSubscriptions[r];
     for (const r of Object.keys(this._onActionOnErrorSubscriptions))
-      r.endsWith(e) && delete this._onActionOnErrorSubscriptions[r];
+      r.startsWith(e) && delete this._onActionOnErrorSubscriptions[r];
   }
   createOnActionAfterCallbackCollector(t, e) {
     return (r) => {
@@ -322,10 +333,10 @@ class U extends G {
     return t.hydrationScheduler ?? this._hydrationScheduler;
   }
   defineSubscriberKey(t, e) {
-    return `${t.name}-${e.$id}`;
+    return _(t.name, e);
   }
   defineSubscriptionKey(t, e) {
-    return `${t}-${e.$id}`;
+    return _(t, e);
   }
   executeResetStoreCallbacks(t) {
     this._resetStoreCallback.get(t)?.forEach((e) => e(t));
@@ -334,66 +345,65 @@ class U extends G {
     if (this._onActionStores.has(t) || typeof t.$onAction != "function")
       return;
     const e = this._onActionSubscriptions.get(t), r = this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t);
-    !e?.size && !r || (this._onActionStores.add(t), t.$onAction(({ after: n, args: c, name: o, onError: h }) => {
-      const l = this._onActionSubscriptions.get(t), p = l?.size;
-      if (!p)
+    !e?.size && !r || (this._onActionStores.add(t), t.$onAction(({ after: n, args: c, name: o, onError: u }) => {
+      const h = this._onActionSubscriptions.get(t);
+      if (!h?.size)
         return;
-      this.traceGroupStart(() => ({ args: c, callbacks: p, name: o }), t.$id, "onAction");
-      let _ = !1;
-      const y = () => {
-        _ || (_ = !0, this.traceGroupEnd({}, t.$id));
+      this.traceGroupStart(() => ({ args: c }), t.$id, `store:onAction:${o}`);
+      let p = !1;
+      const k = () => {
+        p || (p = !0, this.traceGroupEnd({}, t.$id));
       };
       try {
-        const f = S(o, t);
-        this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t) && this.createRollbackSnapshot(o, t), l.forEach((m) => m({
+        const S = f(o, t);
+        this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t) && this.createRollbackSnapshot(o, t), h.forEach((w) => w({
           after: this.createOnActionAfterCallbackCollector(o, t),
           args: c,
           name: o,
           onError: this.createOnActionOnErrorCallbackCollector(o, t)
-        })), y(), this.executeStoreOnActionAfterCallbacks(n, f, t), this.executeStoreOnActionOnErrorCallbacks(h, f, t), this.clearOnActionCallbacksSubscriptions(f);
-      } catch (f) {
-        throw y(), f;
+        })), k(), this.executeStoreOnActionAfterCallbacks(n, S, t, o), this.executeStoreOnActionOnErrorCallbacks(u, S, t, o), this.clearOnActionCallbacksSubscriptions(S);
+      } catch (S) {
+        throw k(), S;
       }
     }));
   }
-  executeStoreOnActionAfterCallbacks(t, e, r) {
-    const n = this._onActionAfterSubscriptions[e], c = n?.length;
-    c && t((o) => {
+  executeStoreOnActionAfterCallbacks(t, e, r, n) {
+    const c = this._onActionAfterSubscriptions[e];
+    c?.length && t((o) => {
       this.traceGroupStart(
         () => ({
-          callbacks: c,
-          groupId: d.onActionAfter(r.$id),
+          groupId: l.onActionAfter(r.$id),
           result: o
         }),
         r.$id,
-        "store:onAction:after"
-      ), n.forEach((h) => {
+        `store:onAction:after:${n}`
+      ), c.forEach((u) => {
         try {
-          h(o);
-        } catch (l) {
-          this.traceError("storeOnActionAfterCallbacks", l, r.$id);
+          u(o);
+        } catch (h) {
+          this.traceError("storeOnActionAfterCallbacks", h, r.$id, () => ({ "action name": n }));
         }
-      }), this.traceGroupEnd(() => ({ groupId: d.onActionAfter(r.$id) }), r.$id);
+      }), this.traceGroupEnd(() => ({ groupId: l.onActionAfter(r.$id) }), r.$id);
     });
   }
-  executeStoreOnActionOnErrorCallbacks(t, e, r) {
-    const n = this._onActionOnErrorSubscriptions[e];
-    n?.length && t((c) => {
+  executeStoreOnActionOnErrorCallbacks(t, e, r, n) {
+    const c = this._onActionOnErrorSubscriptions[e];
+    c?.length && t((o) => {
       this.traceGroupStart(
         () => ({
-          callbacks: n.length,
-          error: c,
-          groupId: d.onActionError(r.$id)
+          "action name": n,
+          error: o,
+          groupId: l.onActionError(r.$id)
         }),
         r.$id,
-        "store:onAction:onError"
-      ), n.forEach((o) => {
+        `store:onAction:onError:${n}`
+      ), c.forEach((u) => {
         try {
-          o(c);
+          u(o);
         } catch (h) {
-          this.traceError("store:onAction:onError:error", h, r.$id);
+          this.traceError("store:onAction:onError:error", h, r.$id, () => ({ groupId: l.onActionError(r.$id) }));
         }
-      }), this.traceGroupEnd(() => ({ groupId: d.onActionError(r.$id) }), r.$id);
+      }), this.traceGroupEnd(() => ({ groupId: l.onActionError(r.$id) }), r.$id);
     });
   }
   executeSubscriber(t, e) {
@@ -412,13 +422,13 @@ class U extends G {
       try {
         const o = e.afterHydration?.(t);
         o && typeof o.then == "function" && o.catch(
-          (h) => this.traceError("subscriber:afterHydration", h, t.store.$id)
+          (u) => this.traceError("subscriber:afterHydration", u, t.store.$id)
         );
       } catch (o) {
         this.traceError("subscriber:afterHydration", o, t.store.$id);
       }
     };
-    n && typeof n.then == "function" ? n.then(() => c()).catch((o) => this.traceError("subscriber:hydrate", o, t.store.$id)) : c(), e.subscriptions && this.subscriptionDelivery(t, e.subscriptions), e.storeMutationSubscription && this.storeMutationSubscription(e.storeMutationSubscription), this.storeOnActionSubscription(e), e.resetStoreCallback && this.addResetStoreCallback(t.store, e.resetStoreCallback);
+    n && typeof n.then == "function" ? n.then(() => c()).catch((o) => this.traceError("subscriber:hydrate", o, t.store.$id)) : c(), e.subscriptions && this.subscriptionDelivery(t, e.subscriptions), e.storeMutationSubscription && this.storeMutationSubscription(e, e.storeMutationSubscription), this.storeOnActionSubscription(e, t), e.resetStoreCallback && this.addResetStoreCallback(t.store, e.resetStoreCallback);
   }
   executeSubscriberSafely(t, e) {
     try {
@@ -431,31 +441,39 @@ class U extends G {
     this._options?.tracerHandler && (this._tracer = this._options.tracerHandler.createTracer(j));
   }
   plugin({ store: t, options: e }) {
-    if (this._subscribers.length) {
-      this.traceGroupStart(() => ({
-        environment: this.defineCurrentEnvironment(),
-        subscribers: this._subscribers,
-        store: t,
-        options: e
-      }), t.$id);
-      try {
-        this._subscribers.forEach(
-          (r) => {
-            const n = this.defineSubscriberKey(r, t), c = this.definePluginExecution(r);
-            if (!(this._subscribersDelivered.has(n) || this._subscribersScheduled.has(n)) && this.shouldInvokePlugin(c)) {
-              if (this.shouldScheduleAfterHydration(c)) {
-                this.queueSubscriberExecution({ store: t, options: e }, r, n);
-                return;
-              }
-              this.executeSubscriber({ store: t, options: e }, r);
+    if (!this._subscribers.length)
+      return;
+    const r = {
+      $onAction: [],
+      $subscribe: []
+    };
+    this.traceGroupStart(() => ({
+      environment: {
+        current: this.defineCurrentEnvironment(),
+        ...this._options?.execution ?? {}
+      },
+      subscribers: this._subscribers,
+      "hooks subscriptions": r,
+      store: t,
+      options: e
+    }), t.$id), this._onActionSubscriptionsTraces.set(t.$id, r.$onAction), this._onMutationSubscriptionsTraces.set(t.$id, r.$subscribe);
+    try {
+      this._subscribers.forEach(
+        (n) => {
+          const c = this.defineSubscriberKey(n, t), o = this.definePluginExecution(n);
+          if (!(this._subscribersDelivered.has(c) || this._subscribersScheduled.has(c)) && this.shouldInvokePlugin(o)) {
+            if (this.shouldScheduleAfterHydration(o)) {
+              this.queueSubscriberExecution({ store: t, options: e }, n, c);
+              return;
             }
+            this.executeSubscriber({ store: t, options: e }, n);
           }
-        ), this.rewriteResetStore({ store: t }, t.$state), this._storeRollbackSnapshotsHandler.initFromPluginContext({ store: t, options: e }), this.executeStoreOnActionSubscription(t), this.registerStoreCleanup(t);
-      } catch (r) {
-        this.traceError("plugin:invoke", r, t.$id);
-      }
-      this.traceGroupEnd(() => ({}), t.$id);
+        }
+      ), this.rewriteResetStore({ store: t }, t.$state), this._storeRollbackSnapshotsHandler.initFromPluginContext({ store: t, options: e }), this.executeStoreOnActionSubscription(t), this.registerStoreCleanup(t);
+    } catch (n) {
+      this.traceError("plugin:invoke", n, t.$id);
     }
+    this.traceGroupEnd(() => ({}), t.$id);
   }
   queueSubscriberExecution(t, e, r) {
     const n = this.defineHydrationScheduler(e);
@@ -470,13 +488,13 @@ class U extends G {
     r.__piniaPluginSubscriptionDisposed || (r.__piniaPluginSubscriptionDisposed = !0, t.$dispose = () => (this._disposedStores.add(t), this.clearStoreTracking(t), this._storeRollbackSnapshotsHandler.clearStoreTracking(t), e()));
   }
   rewriteResetStore({ store: t }, e) {
-    const r = u(e);
+    const r = d(e);
     t.$reset = () => {
-      this.traceGroupStart(() => ({ initialState: r, groupId: d.reset(t.$id) }), t.$id, "store:reset");
+      this.traceGroupStart(() => ({ initialState: r, groupId: l.reset(t.$id) }), t.$id, "store:reset");
       try {
-        this.executeResetStoreCallbacks(t), t.$patch(u(r));
+        this.executeResetStoreCallbacks(t), t.$patch(d(r));
       } finally {
-        this.traceGroupEnd(() => ({ initialState: r, groupId: d.reset(t.$id) }), t.$id);
+        this.traceGroupEnd(() => ({ initialState: r, groupId: l.reset(t.$id) }), t.$id);
       }
     };
   }
@@ -487,28 +505,40 @@ class U extends G {
   shouldScheduleAfterHydration(t) {
     return this.defineCurrentEnvironment() === "client" && t.hydration === "defer";
   }
-  storeOnActionSubscription(t) {
-    const { store: e, callback: r } = t?.storeOnActionSubscription?.() ?? {};
-    !e || !r || (this._onActionSubscriptions.has(e) || this._onActionSubscriptions.set(e, /* @__PURE__ */ new Set()), this._onActionSubscriptions.get(e).add(r), this.executeStoreOnActionSubscription(e));
+  storeOnActionSubscription(t, e) {
+    const { store: r, callback: n } = t?.storeOnActionSubscription?.(e) ?? {};
+    !r || !n || (this._onActionSubscriptions.has(r) || this._onActionSubscriptions.set(r, /* @__PURE__ */ new Set()), this._onActionSubscriptions.get(r).add(n), this._onActionSubscriptionsTraces.get(r.$id)?.push(t.name));
   }
-  storeMutationSubscription(t) {
-    const { store: e, callback: r } = t();
-    e.$subscribe((n) => {
-      this.traceGroupStart(() => ({ mutation: n, groupId: d.onMutation(e.$id) }), e.$id, "store:onMutation");
-      try {
-        r(n);
-      } finally {
-        this.traceGroupEnd(() => ({ mutation: n, groupId: d.onMutation(e.$id) }), e.$id);
+  storeMutationSubscription(t, e) {
+    const { store: r, callback: n } = e();
+    if (!r || !n || (this._onMutationSubscriptions.has(r) || this._onMutationSubscriptions.set(r, /* @__PURE__ */ new Set()), this._onMutationSubscriptions.get(r).add(n), this._onMutationSubscriptionsTraces.get(r.$id)?.push(t.name), this._onMutationUnsubscribes.has(r)))
+      return;
+    const c = r.$subscribe((o) => {
+      const u = this._onMutationSubscriptions.get(r);
+      if (u?.size) {
+        this.traceGroupStart(() => ({ mutation: o, groupId: l.onMutation(r.$id) }), r.$id, "store:onMutation");
+        try {
+          u.forEach((h) => {
+            try {
+              h(o);
+            } catch (p) {
+              this.traceError("store:onMutation", p, r.$id);
+            }
+          });
+        } finally {
+          this.traceGroupEnd(() => ({ mutation: o, groupId: l.onMutation(r.$id) }), r.$id);
+        }
       }
     });
+    this._onMutationUnsubscribes.set(r, c);
   }
   subscriptionDelivery(t, e) {
     Object.entries(e).forEach(([r, n]) => {
       const c = this.defineSubscriptionKey(r, t.store), o = this.definePluginExecution(n.subscription);
       if (!(this._subscriptionsDelivered.has(c) || this._subscriptionsScheduled.has(c)) && this.shouldInvokePlugin(o)) {
         if (this.shouldScheduleAfterHydration(o)) {
-          const h = this.defineHydrationScheduler(n.subscription);
-          this._subscriptionsScheduled.add(c), h(() => {
+          const u = this.defineHydrationScheduler(n.subscription);
+          this._subscriptionsScheduled.add(c), u(() => {
             this._disposedStores.has(t.store) || (this._subscriptionsScheduled.delete(c), this.subscriptionDeliverySafely(t, r, n));
           });
           return;
@@ -521,23 +551,23 @@ class U extends G {
     try {
       if (this._subscriptionsDelivered.has(this.defineSubscriptionKey(r, t)))
         return;
-      const { subscription: c, subscriptionOptions: o, stores: h } = n;
+      const { subscription: c, subscriptionOptions: o, stores: u } = n;
       this.trace("Subscription:delivery", t.$id, () => ({
         pluginName: r,
         subscription: c,
         subscriptionOptions: o
       }));
-      const l = {
+      const h = {
         storeOptions: { ...e?.storeOptions ?? {}, ...o }
       };
       c.invoke(
-        { store: t, options: { ...e, ...l } }
-      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(r, t)), O(h) || h?.forEach(
+        { store: t, options: { ...e, ...h } }
+      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(r, t)), E(u) || u?.forEach(
         (p) => c.invoke({
           store: p,
           options: {
             ...e,
-            ...l,
+            ...h,
             ...p?.storeOptions ?? {}
           }
         })
@@ -547,30 +577,32 @@ class U extends G {
     }
   }
   traceGroupEnd(t, e) {
-    this._options?.tracerHandler && this._options.tracerHandler.closeGroup({
+    const r = this._options?.tracerHandler;
+    r && (r.hasTraceListeners?.() ?? !0) && r.closeGroup({
       ...typeof t == "function" ? t() : t ?? {},
       scope: e
     });
   }
   traceGroupStart(t, e, r) {
-    this._options?.tracerHandler && (t = typeof t == "function" ? t() : t ?? {}, this._options.tracerHandler.startGroup({
+    const n = this._options?.tracerHandler;
+    n && (n.hasTraceListeners?.() ?? !0) && (t = typeof t == "function" ? t() : t ?? {}, n.startGroup({
       ...t,
       scope: e
     }), this.trace(r ?? "context", e, t));
   }
 }
 export {
-  U as P,
+  V as P,
   G as T,
   Q as a,
-  q as b,
+  z as b,
   B as c,
-  N as d,
-  z as g,
-  T as h,
-  O as i,
+  q as d,
+  U as g,
+  v as h,
+  E as i,
   j as p,
   J as s,
-  d as t
+  l as t
 };
-//# sourceMappingURL=PluginSubscription-C_a6v8oi.js.map
+//# sourceMappingURL=PluginSubscription-ZO5mkdvZ.js.map