@buoy-gg/redux 7.0.4 → 7.0.6

package/lib/module/index.js

@@ -29,9 +29,20 @@
  *
  * That's it! The Redux tool will auto-detect your store and capture actions.
  *
- * @example Advanced: Manual middleware (only if you need more control)
+ * HOW CAPTURE WORKS (in priority order):
+ * 1. ENHANCER — importing this package claims the official Redux DevTools
+ *    global (`__REDUX_DEVTOOLS_EXTENSION_COMPOSE__`), which RTK checks by
+ *    default. If this package loads before your store module, Buoy is inside
+ *    the store from creation: FULL capture (thunk/RTK Query actions included)
+ *    and real time travel. To guarantee this ordering, make
+ *    `import '@buoy-gg/redux';` the FIRST import of your app entry.
+ * 2. MIDDLEWARE — add `buoyReduxMiddleware` for explicit full capture.
+ * 3. PATCH — otherwise, `FloatingDevTools` binds the store at first mount by
+ *    patching store.dispatch. Top-level dispatches only (thunk-internal
+ *    actions bypass a dispatch patch — that's a Redux architecture fact).
+ *
+ * @example Advanced: Manual middleware (explicit full capture)
  * ```tsx
- * // For time-travel or custom options, you can optionally use middleware:
  * import { buoyReduxMiddleware, withBuoyDevTools } from '@buoy-gg/redux';
  *
  * const store = configureStore({
@@ -42,6 +53,11 @@
  * ```
  */
 
+// SIDE EFFECT (must stay first): claim the Redux DevTools global so stores
+// created after this module loads get the full-capture enhancer. Dev-only,
+// never overrides an existing claimant. See ./redux/utils/devtoolsHook.ts.
+import "./redux/utils/devtoolsHook";
+
 // =============================================================================
 // PRESET (Primary entry point for users)
 // =============================================================================
@@ -55,7 +71,11 @@ export { buoyReduxMiddleware, createBuoyReduxMiddleware, withBuoyDevTools, jumpT
 // =============================================================================
 // AUTO-INSTRUMENTATION (For programmatic store instrumentation)
 // =============================================================================
-export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore } from "./redux/utils/autoInstrument";
+export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore, getInstrumentationStatus, registerReduxStore } from "./redux/utils/autoInstrument";
+// Store-creation-time capture (the primary, full-capture path). Claimed as a
+// module side effect above; exported for tests/advanced hosts.
+export { buoyDevtoolsEnhancer, claimDevtoolsHook, isDevtoolsHookClaimed } from "./redux/utils/devtoolsHook";
+
 // =============================================================================
 // HISTORY ADAPTER (For universal history devtools)
 // =============================================================================
@@ -75,11 +95,16 @@ export { useAutoInstrumentRedux, useReduxAvailability } from "./redux/hooks/useA
 // =============================================================================
 // COMPONENTS (For custom UI implementations)
 // =============================================================================
-export { ReduxModal, FREE_TIER_ACTION_LIMIT } from "./redux/components/ReduxModal";
+// `ReduxToolView` is the same tool rendered inline (header bar + body + footer)
+// instead of inside a JsModal — for hosts that show tools in a panel.
+export { ReduxModal, ReduxToolView, FREE_TIER_ACTION_LIMIT } from "./redux/components/ReduxModal";
 export { ReduxActionItem } from "./redux/components/ReduxActionItem";
 export { ReduxActionDetailView } from "./redux/components/ReduxActionDetailView";
 export { ReduxActionDetailContent, ReduxActionDetailFooter } from "./redux/components/ReduxActionDetailContent";
 export { ReduxIcon } from "./redux/components/ReduxIcon";
+// Headless startup instrumentation — auto-rendered by @buoy-gg/core's
+// FloatingDevTools; exported for hosts that mount devtools their own way.
+export { ReduxAutoInstrument } from "./redux/components/ReduxAutoInstrument";
 
 // =============================================================================
 // TYPES

package/lib/module/redux/components/ReduxAutoInstrument.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { useAutoInstrumentRedux } from "../hooks/useAutoInstrumentRedux";
+
+/**
+ * Headless startup instrumentation. Auto-rendered by FloatingDevTools (same
+ * pattern as RouteTracker & the overlay tools) so the Redux store is bound
+ * from app mount — action log, MCP getState/dispatch, and desktop sync all
+ * work WITHOUT the user ever opening the Redux tool. Renders nothing.
+ *
+ * Safe anywhere: if react-redux is missing or there's no Provider above, the
+ * hook records the diagnostic and fails gracefully.
+ */
+export function ReduxAutoInstrument() {
+  useAutoInstrumentRedux();
+  return null;
+}

package/lib/module/redux/components/ReduxModal.js

@@ -41,7 +41,8 @@ export function ReduxModal({
   onClose,
   onBack,
   onMinimize,
-  enableSharedModalDimensions = false
+  enableSharedModalDimensions = false,
+  inline = false
 }) {
   const isPro = useIsPro();
   const [showProModal, setShowProModal] = useState(false);
@@ -51,7 +52,8 @@ export function ReduxModal({
     isInstrumented,
     isLoading: isInstrumentLoading,
     error: instrumentError,
-    isReactReduxAvailable
+    isReactReduxAvailable,
+    captureMechanism
   } = useAutoInstrumentRedux();
   const {
     filteredActions,
@@ -280,6 +282,95 @@ export function ReduxModal({
   // The action list owns its scrolling so FlatList virtualization works
   // (see ZustandModal — same pattern, same tool-bench evidence).
   const listOwnsScroll = selectedAction == null;
+  const body = /*#__PURE__*/_jsx(View, {
+    style: styles.container,
+    children: selectedAction && selectedActionIndex !== null ? /*#__PURE__*/_jsx(ReduxActionDetailContent, {
+      action: selectedAction,
+      actions: visibleActions,
+      selectedIndex: selectedActionIndex,
+      onIndexChange: handleIndexChange,
+      disableInternalFooter: true
+    }) : /*#__PURE__*/_jsxs(_Fragment, {
+      children: [instrumentError && !isInstrumented && !reduxActionStore.isCaptureSuppressed() && /*#__PURE__*/_jsxs(View, {
+        style: styles.errorBanner,
+        children: [/*#__PURE__*/_jsx(AlertTriangle, {
+          size: 14,
+          color: macOSColors.semantic.error
+        }), /*#__PURE__*/_jsx(Text, {
+          style: styles.errorText,
+          children: isReactReduxAvailable ? "Not inside a Redux Provider. Wrap your app with <Provider store={store}>." : "react-redux not installed. Run: npm install react-redux"
+        })]
+      }), !isEnabled && isInstrumented && /*#__PURE__*/_jsxs(View, {
+        style: styles.disabledBanner,
+        children: [/*#__PURE__*/_jsx(Power, {
+          size: 14,
+          color: macOSColors.semantic.warning
+        }), /*#__PURE__*/_jsx(Text, {
+          style: styles.disabledText,
+          children: "Action capture is disabled"
+        })]
+      }), captureMechanism === "patch" && !reduxActionStore.isCaptureSuppressed() && /*#__PURE__*/_jsxs(View, {
+        style: styles.disabledBanner,
+        children: [/*#__PURE__*/_jsx(AlertTriangle, {
+          size: 14,
+          color: macOSColors.semantic.warning
+        }), /*#__PURE__*/_jsx(Text, {
+          style: styles.disabledText,
+          children: "Top-level capture only \u2014 thunk/RTK Query internals aren't visible. Put import '@buoy-gg/redux' first in your app entry (or add buoyReduxMiddleware) for full capture."
+        })]
+      }), hasLockedActions && /*#__PURE__*/_jsxs(TouchableOpacity, {
+        style: styles.lockedBanner,
+        onPress: handleUpgradePress,
+        activeOpacity: 0.8,
+        children: [/*#__PURE__*/_jsx(Lock, {
+          size: 14,
+          color: buoyColors.primary
+        }), /*#__PURE__*/_jsxs(Text, {
+          style: styles.lockedText,
+          children: [lockedActionCount, " older ", lockedActionCount === 1 ? "action" : "actions", " locked"]
+        }), /*#__PURE__*/_jsx(View, {
+          style: styles.upgradeBadge,
+          children: /*#__PURE__*/_jsx(Text, {
+            style: styles.upgradeBadgeText,
+            children: "UPGRADE"
+          })
+        })]
+      }), visibleActions.length > 0 ? /*#__PURE__*/_jsx(FlatList, {
+        ref: flatListRef,
+        data: visibleActions,
+        renderItem: renderItem,
+        keyExtractor: keyExtractor,
+        contentContainerStyle: styles.listContent,
+        showsVerticalScrollIndicator: true,
+        removeClippedSubviews: true,
+        initialNumToRender: 12,
+        maxToRenderPerBatch: 8,
+        windowSize: 5,
+        updateCellsBatchingPeriod: 50
+      }) : /*#__PURE__*/_jsx(EmptyState, {
+        isEnabled: isEnabled
+      })]
+    })
+  });
+  const upgradeModal = /*#__PURE__*/_jsx(ProUpgradeModal, {
+    visible: showProModal,
+    onClose: () => setShowProModal(false),
+    featureName: "Full Action History"
+  });
+
+  // The ONLY difference between the phone and the desktop dashboard is which
+  // shell the header, body and footer go in. Everything above this is shared.
+  if (inline) {
+    return /*#__PURE__*/_jsxs(TickProvider, {
+      children: [/*#__PURE__*/_jsxs(View, {
+        style: styles.inlineRoot,
+        children: [/*#__PURE__*/_jsx(View, {
+          style: styles.inlineHeader,
+          children: renderHeaderContent()
+        }), body, footerNode]
+      }), upgradeModal]
+    });
+  }
   return /*#__PURE__*/_jsxs(TickProvider, {
     children: [/*#__PURE__*/_jsx(JsModal, {
       visible: visible,
@@ -298,75 +389,38 @@ export function ReduxModal({
       styles: {},
       footer: footerNode,
       footerHeight: footerHeight,
-      children: /*#__PURE__*/_jsx(View, {
-        style: styles.container,
-        children: selectedAction && selectedActionIndex !== null ? /*#__PURE__*/_jsx(ReduxActionDetailContent, {
-          action: selectedAction,
-          actions: visibleActions,
-          selectedIndex: selectedActionIndex,
-          onIndexChange: handleIndexChange,
-          disableInternalFooter: true
-        }) : /*#__PURE__*/_jsxs(_Fragment, {
-          children: [instrumentError && !isInstrumented && !reduxActionStore.isCaptureSuppressed() && /*#__PURE__*/_jsxs(View, {
-            style: styles.errorBanner,
-            children: [/*#__PURE__*/_jsx(AlertTriangle, {
-              size: 14,
-              color: macOSColors.semantic.error
-            }), /*#__PURE__*/_jsx(Text, {
-              style: styles.errorText,
-              children: isReactReduxAvailable ? "Not inside a Redux Provider. Wrap your app with <Provider store={store}>." : "react-redux not installed. Run: npm install react-redux"
-            })]
-          }), !isEnabled && isInstrumented && /*#__PURE__*/_jsxs(View, {
-            style: styles.disabledBanner,
-            children: [/*#__PURE__*/_jsx(Power, {
-              size: 14,
-              color: macOSColors.semantic.warning
-            }), /*#__PURE__*/_jsx(Text, {
-              style: styles.disabledText,
-              children: "Action capture is disabled"
-            })]
-          }), hasLockedActions && /*#__PURE__*/_jsxs(TouchableOpacity, {
-            style: styles.lockedBanner,
-            onPress: handleUpgradePress,
-            activeOpacity: 0.8,
-            children: [/*#__PURE__*/_jsx(Lock, {
-              size: 14,
-              color: buoyColors.primary
-            }), /*#__PURE__*/_jsxs(Text, {
-              style: styles.lockedText,
-              children: [lockedActionCount, " older ", lockedActionCount === 1 ? "action" : "actions", " locked"]
-            }), /*#__PURE__*/_jsx(View, {
-              style: styles.upgradeBadge,
-              children: /*#__PURE__*/_jsx(Text, {
-                style: styles.upgradeBadgeText,
-                children: "UPGRADE"
-              })
-            })]
-          }), visibleActions.length > 0 ? /*#__PURE__*/_jsx(FlatList, {
-            ref: flatListRef,
-            data: visibleActions,
-            renderItem: renderItem,
-            keyExtractor: keyExtractor,
-            contentContainerStyle: styles.listContent,
-            showsVerticalScrollIndicator: true,
-            removeClippedSubviews: true,
-            initialNumToRender: 12,
-            maxToRenderPerBatch: 8,
-            windowSize: 5,
-            updateCellsBatchingPeriod: 50
-          }) : /*#__PURE__*/_jsx(EmptyState, {
-            isEnabled: isEnabled
-          })]
-        })
-      })
-    }), /*#__PURE__*/_jsx(ProUpgradeModal, {
-      visible: showProModal,
-      onClose: () => setShowProModal(false),
-      featureName: "Full Action History"
-    })]
+      children: body
+    }), upgradeModal]
+  });
+}
+
+/**
+ * The same Redux tool as `ReduxModal`, rendered INLINE for hosts that place
+ * tools in a panel rather than a modal. Exists so there is exactly one
+ * implementation — the desktop dashboard used to ship its own copy of this
+ * component's header, action list and detail router.
+ */
+export function ReduxToolView(props = {}) {
+  return /*#__PURE__*/_jsx(ReduxModal, {
+    ...props,
+    inline: true,
+    visible: true,
+    onClose: () => {}
   });
 }
 const styles = StyleSheet.create({
+  inlineRoot: {
+    flex: 1,
+    minHeight: 0,
+    backgroundColor: macOSColors.background.base
+  },
+  inlineHeader: {
+    paddingHorizontal: 12,
+    paddingVertical: 8,
+    borderBottomWidth: 1,
+    borderBottomColor: macOSColors.border.default,
+    backgroundColor: macOSColors.background.card
+  },
   container: {
     flex: 1,
     backgroundColor: macOSColors.background.base

package/lib/module/redux/components/index.js

@@ -4,4 +4,5 @@ export { ReduxModal, FREE_TIER_ACTION_LIMIT } from "./ReduxModal";
 export { ReduxActionItem } from "./ReduxActionItem";
 export { ReduxActionDetailView } from "./ReduxActionDetailView";
 export { ReduxActionDetailContent, ReduxActionDetailFooter } from "./ReduxActionDetailContent";
-export { ReduxIcon } from "./ReduxIcon";
+export { ReduxIcon } from "./ReduxIcon";
+export { ReduxAutoInstrument } from "./ReduxAutoInstrument";

package/lib/module/redux/hooks/useAutoInstrumentRedux.js

@@ -3,30 +3,22 @@
 /**
  * React hook for auto-instrumenting Redux stores
  *
- * This hook automatically patches the Redux store when the component mounts,
- * providing zero-config action capture for the Redux DevTools.
+ * Mounted for the app's lifetime by FloatingDevTools (via ReduxAutoInstrument)
+ * and also called by the Redux modal. Binds Buoy to the store from react-redux
+ * context:
+ * - If the store was created through the devtools-hook enhancer, capture is
+ *   already live — this just keeps the registry pointed at it.
+ * - Otherwise it applies the dispatch-patch fallback (top-level-only capture).
+ * - If react-redux is missing or there's no Provider above, it fails
+ *   gracefully and records WHY (surfaced by the sync adapter / MCP).
  *
- * Usage:
- * - The hook attempts to use react-redux's useStore() to get the store
- * - If successful, it instruments the store automatically
- * - If react-redux is not available or not in a Provider, it fails gracefully
- *
- * @example
- * ```tsx
- * function ReduxDevTools() {
- *   const { isInstrumented, error } = useAutoInstrumentRedux();
- *
- *   if (error) {
- *     return <Text>Redux not available: {error}</Text>;
- *   }
- *
- *   return <ReduxActionList />;
- * }
- * ```
+ * Re-instruments when the store INSTANCE changes (hosts that rebuild their
+ * store at runtime), so the registry never pins a dead store.
  */
 
 import { useEffect, useState, useRef, useCallback } from "react";
-import { instrumentStore, uninstrumentStore, isStoreInstrumented } from "../utils/autoInstrument";
+import { instrumentStore, uninstrumentStore, getInstrumentationStatus } from "../utils/autoInstrument";
+import { setReduxDiagnostic } from "../utils/activeStoreRegistry";
 
 // ============================================
 // Safe Module Loading
@@ -55,19 +47,16 @@ function getReactReduxUseStore() {
 // Main Hook
 // ============================================
 
-/**
- * Hook to automatically instrument Redux store for DevTools
- *
- * This provides zero-config Redux action capture by:
- * 1. Using react-redux's useStore() to get the Redux store
- * 2. Automatically patching store.dispatch to capture actions
- * 3. Cleaning up when the component unmounts
- */
 export function useAutoInstrumentRedux(options = {}) {
   const {
-    autoStart = true,
-    ...instrumentOptions
+    autoStart = true
   } = options;
+
+  // Options live in a ref: this hook is app-lifetime-mounted, and a fresh
+  // `{...rest}` object every render would churn startInstrumentation's
+  // identity and re-run the effect on every render.
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
   const [isInstrumented, setIsInstrumented] = useState(false);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState(null);
@@ -82,37 +71,35 @@ export function useAutoInstrumentRedux(options = {}) {
   // This must be called unconditionally due to hooks rules
   let reduxStore = null;
   let storeError = null;
+  let storeDiagnostic = null;
   if (useStoreHook) {
     try {
       // eslint-disable-next-line react-hooks/rules-of-hooks
       reduxStore = useStoreHook();
     } catch (e) {
       // Not inside a Provider or other error
+      storeDiagnostic = "no-provider";
       storeError = e instanceof Error ? e.message : "Failed to access Redux store. Make sure your app is wrapped in a Redux Provider.";
     }
   } else {
+    storeDiagnostic = "no-react-redux";
     storeError = "react-redux is not installed or not available";
   }
 
   // Function to start instrumentation
   const startInstrumentation = useCallback(() => {
     if (!reduxStore) {
+      // Record the failure reason for non-React surfaces (sync adapter/MCP).
+      setReduxDiagnostic(storeDiagnostic);
       setError(storeError || "No Redux store available");
       setIsLoading(false);
       return;
     }
-
-    // Check if already instrumented
-    if (isStoreInstrumented(reduxStore)) {
-      setIsInstrumented(true);
-      setStore(reduxStore);
-      setIsLoading(false);
-      setError(null);
-      return;
-    }
     try {
-      // Instrument the store
-      const cleanup = instrumentStore(reduxStore, instrumentOptions);
+      // Instrument the store. Idempotent per store: enhancer-created and
+      // already-patched stores just get (re)registered, so a store SWAP at
+      // runtime re-binds the registry to the new instance.
+      const cleanup = instrumentStore(reduxStore, optionsRef.current);
       cleanupRef.current = cleanup;
       setIsInstrumented(true);
       setStore(reduxStore);
@@ -123,7 +110,8 @@ export function useAutoInstrumentRedux(options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [reduxStore, storeError, instrumentOptions]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- storeError/storeDiagnostic derive from reduxStore
+  }, [reduxStore]);
 
   // Function to stop instrumentation
   const stopInstrumentation = useCallback(() => {
@@ -138,7 +126,8 @@ export function useAutoInstrumentRedux(options = {}) {
     setStore(null);
   }, [store]);
 
-  // Auto-start instrumentation on mount
+  // Auto-start instrumentation on mount, and again whenever the store
+  // INSTANCE changes (hosts that rebuild their store re-point the registry).
   useEffect(() => {
     if (autoStart) {
       startInstrumentation();
@@ -159,6 +148,7 @@ export function useAutoInstrumentRedux(options = {}) {
     isLoading,
     error,
     isReactReduxAvailable,
+    captureMechanism: getInstrumentationStatus().mechanism,
     startInstrumentation,
     stopInstrumentation,
     store

package/lib/module/redux/sync/reduxSyncAdapter.js

@@ -1,20 +1,37 @@
 "use strict";
 
 import { reduxActionStore } from "../utils/reduxActionStore";
-import { getActiveStore } from "../utils/autoInstrument";
+import { getActiveStore, getInstrumentationStatus } from "../utils/autoInstrument";
 /** Top-level slice names of the state tree, for the compact (no-values) view. */
 function topLevelKeys(state) {
   return state && typeof state === "object" && !Array.isArray(state) ? Object.keys(state) : [];
 }
 
+/**
+ * Why there's no bound store, in a shape remote drivers (MCP/desktop) can turn
+ * into a SPECIFIC remedy instead of a generic "check your setup".
+ */
+function unavailable() {
+  const status = getInstrumentationStatus();
+  const reason = status.diagnostic ?? "not-instrumented";
+  return {
+    available: false,
+    slices: [],
+    /** 'no-react-redux' | 'no-provider' | 'not-instrumented' */
+    reason
+  };
+}
+
 /**
  * Sync adapter for the redux tool, consumed by @buoy-gg/external-sync's
  * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
  * this package doesn't need a dependency on it).
  *
- * Actions are captured by the auto-instrumentation middleware (installed when
- * FloatingDevTools mounts), independent of whether a dashboard is watching —
- * subscribing here only streams what the store already records.
+ * Actions are captured from app startup — by the store-creation enhancer or
+ * the explicit middleware (full capture), or by the dispatch-patch fallback
+ * mounted with FloatingDevTools (top-level-only) — independent of whether a
+ * dashboard is watching. Subscribing here only streams what's already
+ * recorded.
  *
  * `getState`/`dispatch` read & drive the live instrumented store (via
  * getActiveStore()) so a remote driver (MCP/LLM) can inspect current state and
@@ -39,15 +56,16 @@ export const reduxSyncAdapter = {
       } = params ?? {};
       const store = getActiveStore();
       if (!store) {
-        return {
-          available: false,
-          slices: []
-        };
+        return unavailable();
       }
       const state = store.getState();
+      const status = getInstrumentationStatus();
       return {
         available: true,
         slices: topLevelKeys(state),
+        /** 'full' | 'top-level-only' — what the live capture mechanism sees. */
+        capture: status.capture,
+        mechanism: status.mechanism,
         ...(includeValues ? {
           state
         } : {})
@@ -61,7 +79,8 @@ export const reduxSyncAdapter = {
       const store = getActiveStore();
       if (!store) {
         return {
-          dispatched: false
+          dispatched: false,
+          ...unavailable()
         };
       }
       store.dispatch(action);

package/lib/module/redux/utils/activeStoreRegistry.js

@@ -0,0 +1,63 @@
+"use strict";
+
+/**
+ * Shared registry for the one live Redux store Buoy is bound to, plus how it
+ * got bound (the capture mechanism) and why binding failed when it did.
+ *
+ * Lives in its own module so the three capture paths (devtools-hook enhancer,
+ * explicit middleware, dispatch-patch fallback) and the sync adapter can all
+ * import it without cycles.
+ */
+
+/** The minimum store surface Buoy needs (middleware storeApi satisfies this). */
+
+/**
+ * How the store got instrumented:
+ * - `enhancer`   — store-creation-time enhancer via the Redux DevTools global.
+ *                  FULL capture (thunk-internal & RTK Query actions included).
+ * - `middleware` — user-added buoyReduxMiddleware. FULL capture.
+ * - `patch`      — store.dispatch patched after creation (auto-instrumentation
+ *                  fallback). TOP-LEVEL-ONLY capture: actions dispatched from
+ *                  inside middleware/thunks bypass the patch.
+ */
+
+/** Why there is no bound store, when there isn't one. */
+
+/** Marks stores created through the Buoy devtools-hook enhancer. */
+export const ENHANCER_SYMBOL = Symbol.for("@@buoy/enhancerInstrumented");
+let activeStore = null;
+let mechanism = null;
+let diagnostic = null;
+export function registerActiveStore(store, mech) {
+  activeStore = store;
+  mechanism = mech;
+  diagnostic = null;
+}
+export function unregisterActiveStore(store) {
+  if (activeStore === store) {
+    activeStore = null;
+    mechanism = null;
+  }
+}
+export function getActiveStore() {
+  return activeStore;
+}
+export function getCaptureMechanism() {
+  return mechanism;
+}
+
+/**
+ * Recorded by the auto-instrument hook so non-React surfaces (sync adapter,
+ * MCP) can report WHY there's no store instead of a generic failure.
+ */
+export function setReduxDiagnostic(d) {
+  diagnostic = d;
+}
+export function getInstrumentationStatus() {
+  return {
+    mechanism,
+    capture: mechanism === "enhancer" || mechanism === "middleware" ? "full" : mechanism === "patch" ? "top-level-only" : "none",
+    hasStore: activeStore !== null,
+    diagnostic
+  };
+}