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

package/CHANGELOG.md

@@ -7,7 +7,13 @@ 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
 - Moved the API reference, import subpaths, development, `Store` summary and testing sections from `README.md` to `docs/authoring-plugins.md`
@@ -42,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-DPu3ft-c.js → PluginSubscription-ZO5mkdvZ.js}

@@ -1,9 +1,9 @@
-var g = Object.defineProperty;
-var w = (i, s, t) => s in i ? g(i, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[s] = t;
-var a = (i, s, t) => w(i, typeof s != "symbol" ? s + "" : s, t);
-import { toRaw as A } from "vue";
-import { defineStore as $ } from "pinia";
-function u(i) {
+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 $ } from "vue";
+import { defineStore as O } from "pinia";
+function d(i) {
   if (typeof structuredClone == "function")
     try {
       return structuredClone(i);
@@ -13,52 +13,52 @@ 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 x(i, s = "all") {
+function R(i, s = "all") {
   if (Array.isArray(s)) {
     const t = {};
     for (const e of s)
-      e in i && (t[e] = u(A(i[e])));
+      e in i && (t[e] = d($(i[e])));
     return t;
   }
   if (s !== "all")
     throw new Error(`Invalid keys parameter: ${s}`);
-  return u(A(i));
+  return d($(i));
 }
-const b = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new WeakSet();
-function H(i, s) {
-  if (k.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) => (b.delete(i), S.delete(s), t.apply(i, e)), k.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" ? C(
     i,
     s,
     e
-  ) : R(
+  ) : 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 C(
     i,
@@ -70,41 +70,48 @@ function C(i, s, t) {
   const e = {
     id: i,
     extensions: {}
-  }, r = t?.storeOptions?.enhancedStore === !0, n = $(
+  }, r = t?.storeOptions?.enhancedStore === !0, n = O(
     i,
     () => s(e),
     t
   );
   return Object.assign(((...c) => {
-    r && S.set(i, e);
+    r && b.set(i, e);
     const o = n(...c);
-    return r && (b.set(o, e), S.delete(i), H(o, i)), o;
+    return r && (A.set(o, e), b.delete(i), T(o, i)), o;
   }), n);
 }
-function R(i, s, t) {
-  return t && (s = { ...s, ...t ?? {} }), $(i, s);
+function x(i, s, t) {
+  return t && (s = { ...s, ...t ?? {} }), O(i, s);
 }
-const v = /* @__PURE__ */ new Set(["_", "$"]);
-function P(i) {
-  return v.has(i[0]);
+const P = /* @__PURE__ */ new Set(["_", "$"]);
+function v(i) {
+  return P.has(i[0]);
 }
-function I(i) {
+function U(i) {
   const s = i;
-  return b.get(i) ?? (typeof s?.$id == "string" ? S.get(s.$id) : void 0);
+  return A.get(i) ?? (typeof s?.$id == "string" ? b.get(s.$id) : void 0);
 }
-function z(i) {
+function B(i) {
   const s = i.extensions.enhancedStore ?? i.extensions.extending;
   if (!s)
     throw new Error(`${i.id}Store - getEnhancedStore - Error: enhanced store is required`);
   return s;
 }
-function B(i, s) {
+function J(i, s) {
   i.extensions.enhancedStore = s, i.extensions.extending = s;
 }
 function f(i, s) {
-  return `${i}-${s.$id}`;
+  return _(i, s);
+}
+function y(i) {
+  const s = String(i.$id);
+  return `${s.length}:${s}:`;
 }
-class T {
+function _(i, s) {
+  return `${y(s)}${i.length}:${i}`;
+}
+class D {
   constructor() {
     a(this, "_stateSnapshots", /* @__PURE__ */ new Map());
     a(this, "_storeHasRollbackSnapshots", /* @__PURE__ */ new Set());
@@ -113,13 +120,13 @@ class T {
   addRollbackAction(s) {
     typeof s.$rollbackAfterFailure != "function" && (s.$rollbackAfterFailure = async ({ action: t, stateKeys: e }, r = []) => {
       const n = s[t];
-      if (typeof n != "function" || P(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);
       }
@@ -152,12 +159,12 @@ class T {
     }), 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);
@@ -172,17 +179,17 @@ class T {
     s && this._stateSnapshots.delete(s);
   }
   saveStateSnapshot(s, t, e) {
-    const r = x(
+    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) {
     return this._storeHasRollbackSnapshots.has(s.$id);
   }
 }
-class D {
+class G {
   constructor() {
     a(this, "_tracer");
     a(this, "_traceOptions", {
@@ -210,10 +217,15 @@ class D {
     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", E = "PluginSubscription", J = E.toLowerCase(), G = E, F = {
+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}`
+}, I = m, F = {
   environment: "both",
   hydration: "immediate"
 };
@@ -224,19 +236,23 @@ function K(i) {
   }
   globalThis.setTimeout(i, 0);
 }
-class Q extends D {
+class V extends G {
   constructor(t, e) {
     super();
-    a(this, "_className", G);
+    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());
-    a(this, "_storeRollbackSnapshotsHandler", new T());
+    a(this, "_storeRollbackSnapshotsHandler", new D());
     a(this, "_subscribers", []);
     a(this, "_subscribersDelivered", /* @__PURE__ */ new Set());
     a(this, "_subscribersScheduled", /* @__PURE__ */ new Set());
@@ -249,7 +265,7 @@ class Q extends D {
     this._subscribers = t;
   }
   get subscriptions() {
-    if (!O(this._subscriptions))
+    if (!E(this._subscriptions))
       return this._subscriptions;
   }
   addOnActionAfterCallback(t, e, r) {
@@ -267,20 +283,20 @@ class Q extends D {
     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) => {
@@ -317,10 +333,10 @@ class Q extends D {
     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));
@@ -329,56 +345,65 @@ class Q extends D {
     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), d = l?.size;
-      if (!d)
+    !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: d, 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 p = f(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, p, t), this.executeStoreOnActionOnErrorCallbacks(h, p, t), this.clearOnActionCallbacksSubscriptions(p);
-      } catch (p) {
-        throw y(), p;
+        })), 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) => {
-      this.traceGroupStart(() => ({
-        callbacks: c,
-        result: o
-      }), r.$id, "execute:store:onAction:after:callbacks"), n.forEach((h) => {
+  executeStoreOnActionAfterCallbacks(t, e, r, n) {
+    const c = this._onActionAfterSubscriptions[e];
+    c?.length && t((o) => {
+      this.traceGroupStart(
+        () => ({
+          groupId: l.onActionAfter(r.$id),
+          result: o
+        }),
+        r.$id,
+        `store:onAction:after:${n}`
+      ), c.forEach((u) => {
         try {
-          h(o);
-        } catch (l) {
-          this.traceError("executeStoreOnActionAfterCallbacks", l, r.$id);
+          u(o);
+        } catch (h) {
+          this.traceError("storeOnActionAfterCallbacks", h, r.$id, () => ({ "action name": n }));
         }
-      }), this.traceGroupEnd(() => ({}), r.$id);
+      }), this.traceGroupEnd(() => ({ groupId: l.onActionAfter(r.$id) }), r.$id);
     });
   }
-  executeStoreOnActionOnErrorCallbacks(t, e, r) {
-    const n = this._onActionOnErrorSubscriptions[e];
-    n?.length && t((c) => {
-      this.traceGroupStart(() => ({
-        callbacks: n.length,
-        error: c
-      }), r.$id, "execute:store:onAction:onError:callbacks"), n.forEach((o) => {
+  executeStoreOnActionOnErrorCallbacks(t, e, r, n) {
+    const c = this._onActionOnErrorSubscriptions[e];
+    c?.length && t((o) => {
+      this.traceGroupStart(
+        () => ({
+          "action name": n,
+          error: o,
+          groupId: l.onActionError(r.$id)
+        }),
+        r.$id,
+        `store:onAction:onError:${n}`
+      ), c.forEach((u) => {
         try {
-          o(c);
+          u(o);
         } catch (h) {
-          this.traceError("execute:store:onAction:onError:callbacks:error", h, r.$id);
+          this.traceError("store:onAction:onError:error", h, r.$id, () => ({ groupId: l.onActionError(r.$id) }));
         }
-      }), this.traceGroupEnd(() => ({}), r.$id);
+      }), this.traceGroupEnd(() => ({ groupId: l.onActionError(r.$id) }), r.$id);
     });
   }
   executeSubscriber(t, e) {
@@ -397,13 +422,13 @@ class Q extends D {
       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 {
@@ -416,31 +441,39 @@ class Q extends D {
     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);
@@ -455,13 +488,13 @@ class Q extends D {
     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 }), 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 }), t.$id);
+        this.traceGroupEnd(() => ({ initialState: r, groupId: l.reset(t.$id) }), t.$id);
       }
     };
   }
@@ -472,28 +505,40 @@ class Q extends D {
   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 }), e.$id, "store:mutation");
-      try {
-        r(n);
-      } finally {
-        this.traceGroupEnd({}, 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;
@@ -506,24 +551,24 @@ class Q extends D {
     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(
-        (d) => c.invoke({
-          store: d,
+        { store: t, options: { ...e, ...h } }
+      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(r, t)), E(u) || u?.forEach(
+        (p) => c.invoke({
+          store: p,
           options: {
             ...e,
-            ...l,
-            ...d?.storeOptions ?? {}
+            ...h,
+            ...p?.storeOptions ?? {}
           }
         })
       );
@@ -532,29 +577,32 @@ class Q extends D {
     }
   }
   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 {
-  Q as P,
-  D as T,
-  J as a,
-  q as b,
-  z as c,
-  N as d,
-  I as g,
-  P as h,
-  O as i,
+  V as P,
+  G as T,
+  Q as a,
+  z as b,
+  B as c,
+  q as d,
+  U as g,
+  v as h,
+  E as i,
   j as p,
-  B as s
+  J as s,
+  l as t
 };
-//# sourceMappingURL=PluginSubscription-DPu3ft-c.js.map
+//# sourceMappingURL=PluginSubscription-ZO5mkdvZ.js.map