@buoy-gg/redux 7.0.29 → 7.0.31

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

@@ -16,27 +16,40 @@ import { reduxActionStore } from "../utils/reduxActionStore";
 import { useAutoInstrumentRedux } from "../hooks/useAutoInstrumentRedux";
 import { ReduxActionItem } from "./ReduxActionItem";
 import { ReduxActionDetailContent, ReduxActionDetailFooter } from "./ReduxActionDetailContent";
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { REDUX_TEST_ID, buildActionRowTestIDs } from "../utils/testIDs";
+
 /**
  * @deprecated Read the live limit with `useLimit("redux.actions")` — this
  * constant only ever reports the FREE tier's value and is blind to the
  * anonymous tier. Kept because it is part of the package's public exports.
  */
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 export const FREE_TIER_ACTION_LIMIT = TIER_LIMITS["redux.actions"].free;
+/**
+ * Why this takes the query as well as the enabled flag: "nothing was captured"
+ * and "nothing matched what you typed" are different problems, and an empty
+ * list under a live search reads as a dead tool. Naming the query back is what
+ * makes the difference legible without clearing the field to find out.
+ */
 function EmptyState({
-  isEnabled
+  isEnabled,
+  query
 }) {
+  const isFiltered = query.length > 0;
   return /*#__PURE__*/_jsxs(View, {
     style: styles.emptyState,
+    testID: `${REDUX_TEST_ID}-empty`,
     children: [/*#__PURE__*/_jsx(Zap, {
       size: 32,
       color: night.color.textTertiary
     }), /*#__PURE__*/_jsx(Text, {
       style: styles.emptyTitle,
-      children: "No Redux actions"
+      testID: `${REDUX_TEST_ID}-empty-title`,
+      children: isFiltered ? "No Matches" : "No Redux actions"
     }), /*#__PURE__*/_jsx(Text, {
       style: styles.emptyText,
-      children: isEnabled ? "Actions will appear here as they are dispatched" : "Enable capture to start recording actions"
+      testID: `${REDUX_TEST_ID}-empty-text`,
+      children: isFiltered ? `No action type contains "${query}"` : isEnabled ? "Actions will appear here as they are dispatched" : "Enable capture to start recording actions"
     })]
   });
 }
@@ -79,14 +92,27 @@ export function ReduxModal({
   const lockedActionCount = useMemo(() => Math.max(0, filteredActions.length - actionLimit), [filteredActions.length, actionLimit]);
   const hasLockedActions = lockedActionCount > 0;
 
-  // Selection state - track index for navigation
-  const [selectedActionIndex, setSelectedActionIndex] = useState(null);
-  const actionsRef = useRef([]);
-
-  // Keep actions ref in sync (using visible actions for navigation)
-  actionsRef.current = visibleActions;
-
-  // Get selected action from index
+  // Selection state, held as an action ID rather than as a list position.
+  //
+  // This list grows at the HEAD: every dispatch prepends a row and pushes
+  // everything below it down one. An index therefore names a different action
+  // a moment after it is taken — so a detail page opened while the app was
+  // still dispatching silently became a detail page for some OTHER action,
+  // with no transition and nothing to say it had happened. A devtool that
+  // quietly swaps what it is showing you is worse than one that shows nothing.
+  //
+  // The index is still what the stepper and the diff's "previous action" are
+  // expressed in — both are genuinely about position — so it is derived here
+  // and re-derived whenever the list moves.
+  const [selectedActionId, setSelectedActionId] = useState(null);
+  const selectedActionIndex = useMemo(() => {
+    if (selectedActionId === null) return null;
+    const index = visibleActions.findIndex(a => a.id === selectedActionId);
+    // Below zero means the action is gone — cleared, or aged out past the tier
+    // cap. Falling back to the list is the honest outcome; the alternative is
+    // showing whatever moved into its place.
+    return index >= 0 ? index : null;
+  }, [selectedActionId, visibleActions]);
   const selectedAction = selectedActionIndex !== null ? visibleActions[selectedActionIndex] : null;
 
   // Notify the host on selection (keyed by action id so re-renders with the
@@ -110,7 +136,7 @@ export function ReduxModal({
     const index = visibleActions.findIndex(a => a.id === initialSelectedActionId);
     if (index < 0) return;
     appliedInitialSelectionRef.current = initialSelectedActionId;
-    setSelectedActionIndex(index);
+    setSelectedActionId(initialSelectedActionId);
   }, [initialSelectedActionId, visibleActions]);
   const [searchText, setSearchText] = useState("");
   const [isSearchActive, setIsSearchActive] = useState(false);
@@ -126,19 +152,33 @@ export function ReduxModal({
       searchText: text
     }));
   };
+
+  /** Drop the query AND put the header back — the ✕ means "stop filtering". */
+  const closeSearch = useCallback(() => {
+    setSearchText("");
+    setFilter(prev => ({
+      ...prev,
+      searchText: ""
+    }));
+    setIsSearchActive(false);
+  }, [setFilter]);
   const handleActionPress = useCallback(action => {
-    const index = actionsRef.current.findIndex(a => a.id === action.id);
-    setSelectedActionIndex(index >= 0 ? index : 0);
+    setSelectedActionId(action.id);
   }, []);
   const handleUpgradePress = useCallback(() => {
     setShowProModal(true);
   }, []);
   const handleBack = useCallback(() => {
-    setSelectedActionIndex(null);
+    setSelectedActionId(null);
   }, []);
+
+  // The stepper and the async timeline both navigate by POSITION; the
+  // selection is kept by identity, so the position is resolved to an id here,
+  // once, at the moment of the tap.
   const handleIndexChange = useCallback(newIndex => {
-    setSelectedActionIndex(newIndex);
-  }, []);
+    const next = visibleActions[newIndex];
+    if (next) setSelectedActionId(next.id);
+  }, [visibleActions]);
   const handleCopyAll = async () => {
     if (!isPro) {
       setShowProModal(true);
@@ -160,14 +200,49 @@ export function ReduxModal({
 
   // FlatList optimization
   const keyExtractor = useCallback(item => item.id, []);
+
+  // An action row's handle carries an ordinal among rows of the SAME type, and
+  // an ordinal is a fact about the list rather than about the row — see
+  // ../utils/testIDs.ts for why a type alone cannot address a redux row.
+  const rowTestIDs = useMemo(() => buildActionRowTestIDs(visibleActions), [visibleActions]);
+
+  // How many captured actions share each requestId, i.e. how far along each
+  // async operation is.
+  //
+  // Computed HERE rather than in the row, and passed down, because a row's
+  // async badge is a fact about OTHER rows. `pending` is captured and drawn
+  // while it is still alone in the world; `fulfilled` arrives a moment later
+  // and makes the earlier row's badge wrong. `ReduxActionItem` is memoized on
+  // its props and the action object it holds never changes identity, so
+  // nothing about that second arrival reached the first row — the pending half
+  // of every settled thunk permanently showed no flow badge, which is exactly
+  // backwards from what the badge is for.
+  //
+  // One pass over the store instead of a per-row scan: the previous shape was
+  // O(rows x actions) at 200 actions, on a list that re-renders on every
+  // dispatch.
+  const linkedCounts = useMemo(() => {
+    const counts = new Map();
+    for (const action of reduxActionStore.getActions()) {
+      const requestId = action.meta?.requestId;
+      if (!requestId) continue;
+      counts.set(requestId, (counts.get(requestId) ?? 0) + 1);
+    }
+    return counts;
+    // `filteredActions` takes a new identity whenever the store notifies, which
+    // is the only moment these counts can change.
+  }, [filteredActions]);
   const renderItem = useCallback(({
     item
   }) => {
+    const requestId = item.meta?.requestId;
     return /*#__PURE__*/_jsx(ReduxActionItem, {
       action: item,
-      onPress: handleActionPress
+      onPress: handleActionPress,
+      linkedCount: requestId ? linkedCounts.get(requestId) ?? 0 : 0,
+      testID: rowTestIDs.get(item.id)
     });
-  }, [handleActionPress]);
+  }, [handleActionPress, rowTestIDs, linkedCounts]);
   const renderHeaderContent = () => {
     // Detail view header - show action type
     if (selectedAction) {
@@ -176,7 +251,8 @@ export function ReduxModal({
           onBack: handleBack
         }), /*#__PURE__*/_jsx(ModalHeader.Content, {
           title: selectedAction.type,
-          centered: true
+          centered: true,
+          testID: `${REDUX_TEST_ID}-detail-title`
         })]
       });
     }
@@ -189,27 +265,42 @@ export function ReduxModal({
         title: "",
         children: isSearchActive ? /*#__PURE__*/_jsxs(View, {
           style: styles.headerSearchContainer,
+          testID: `${REDUX_TEST_ID}-search`,
           children: [/*#__PURE__*/_jsx(Search, {
             size: 14,
             color: night.color.textSecondary
           }), /*#__PURE__*/_jsx(TextInput, {
             ref: searchInputRef,
+            testID: `${REDUX_TEST_ID}-search-field`,
             style: styles.headerSearchInput,
             placeholder: "Search action types...",
             placeholderTextColor: night.color.textTertiary,
             value: searchText,
             onChangeText: handleSearch,
-            onSubmitEditing: () => setIsSearchActive(false),
-            onBlur: () => setIsSearchActive(false),
+            onSubmitEditing: () => searchInputRef.current?.blur()
+            // Stay open while the query still filters the list.
+            //
+            // Collapsing it on blur hid the reason rows were missing: the
+            // header went back to its chips — which count the WHOLE
+            // capture, not the filtered list — while the list stayed
+            // narrowed, so the tool showed "4 actions" above a single row
+            // and offered nothing to explain the gap. The only way back
+            // was to reopen a field the user had no reason to think was
+            // still armed.
+            ,
+            onBlur: () => {
+              if (searchText.length === 0) setIsSearchActive(false);
+            },
+            accessibilityLabel: "Search action types",
             autoCapitalize: "none",
             autoCorrect: false,
             returnKeyType: "search"
-          }), searchText.length > 0 && /*#__PURE__*/_jsx(TouchableOpacity, {
-            onPress: () => {
-              handleSearch("");
-              setIsSearchActive(false);
-            },
+          }), /*#__PURE__*/_jsx(TouchableOpacity, {
+            onPress: closeSearch,
             style: styles.headerSearchClear,
+            testID: `${REDUX_TEST_ID}-search-clear`,
+            accessibilityRole: "button",
+            accessibilityLabel: "Close search",
             children: /*#__PURE__*/_jsx(X, {
               size: 14,
               color: night.color.textSecondary
@@ -223,6 +314,12 @@ export function ReduxModal({
               ...prev,
               onlyWithChanges: false
             })),
+            testID: `${REDUX_TEST_ID}-chip-all`,
+            accessibilityRole: "button",
+            accessibilityLabel: `Show all actions, ${stats.totalActions} captured`,
+            accessibilityState: {
+              selected: !filter.onlyWithChanges
+            },
             children: [/*#__PURE__*/_jsx(Text, {
               style: styles.headerChipLabel,
               children: "ALL"
@@ -230,6 +327,7 @@ export function ReduxModal({
               style: [styles.headerChipValue, {
                 color: night.color.text
               }],
+              testID: `${REDUX_TEST_ID}-chip-all-value`,
               children: stats.totalActions
             })]
           }), /*#__PURE__*/_jsxs(TouchableOpacity, {
@@ -238,6 +336,12 @@ export function ReduxModal({
               ...prev,
               onlyWithChanges: true
             })),
+            testID: `${REDUX_TEST_ID}-chip-changed`,
+            accessibilityRole: "button",
+            accessibilityLabel: `Show only actions that changed state, ${stats.actionsWithChanges} of them`,
+            accessibilityState: {
+              selected: !!filter.onlyWithChanges
+            },
             children: [/*#__PURE__*/_jsx(Zap, {
               size: 12,
               color: macOSColors.semantic.warning
@@ -245,10 +349,13 @@ export function ReduxModal({
               style: [styles.headerChipValue, {
                 color: macOSColors.semantic.warning
               }],
+              testID: `${REDUX_TEST_ID}-chip-changed-value`,
               children: stats.actionsWithChanges
             })]
           }), /*#__PURE__*/_jsxs(View, {
             style: styles.headerChip,
+            testID: `${REDUX_TEST_ID}-chip-types`,
+            accessibilityLabel: `${stats.uniqueActionTypes} distinct action types`,
             children: [/*#__PURE__*/_jsx(CheckCircle, {
               size: 12,
               color: macOSColors.semantic.success
@@ -256,22 +363,32 @@ export function ReduxModal({
               style: [styles.headerChipValue, {
                 color: macOSColors.semantic.success
               }],
+              testID: `${REDUX_TEST_ID}-chip-types-value`,
               children: stats.uniqueActionTypes
             })]
           })]
         })
       }), /*#__PURE__*/_jsxs(ModalHeader.Actions, {
-        children: [/*#__PURE__*/_jsx(TouchableOpacity, {
+        children: [!isSearchActive && /*#__PURE__*/_jsx(TouchableOpacity, {
           onPress: () => setIsSearchActive(true),
-          style: styles.headerActionButton,
+          style: [styles.headerActionButton, searchText.length > 0 && styles.headerActionButtonActive],
+          testID: `${REDUX_TEST_ID}-search-open`,
+          accessibilityRole: "button",
+          accessibilityLabel: "Search action types",
           children: /*#__PURE__*/_jsx(Search, {
             size: 14,
-            color: night.color.textSecondary
+            color: searchText.length > 0 ? night.color.accent : night.color.textSecondary
           })
         }), /*#__PURE__*/_jsx(TouchableOpacity, {
           onPress: handleCopyAll,
           style: [styles.headerActionButton, filteredActions.length === 0 && styles.headerActionButtonDisabled],
           disabled: filteredActions.length === 0,
+          testID: `${REDUX_TEST_ID}-copy`,
+          accessibilityRole: "button",
+          accessibilityLabel: "Copy all actions",
+          accessibilityState: {
+            disabled: filteredActions.length === 0
+          },
           children: /*#__PURE__*/_jsx(Copy, {
             size: 14,
             color: filteredActions.length > 0 ? night.color.textSecondary : night.color.textTertiary
@@ -279,11 +396,18 @@ export function ReduxModal({
         }), /*#__PURE__*/_jsx(PowerToggleButton, {
           isEnabled: isEnabled,
           onToggle: toggleCapture,
-          accessibilityLabel: "Toggle Redux action capture"
+          accessibilityLabel: "Toggle Redux action capture",
+          testID: `${REDUX_TEST_ID}-power`
         }), /*#__PURE__*/_jsx(TouchableOpacity, {
           onPress: clearActions,
           style: [styles.headerActionButton, filteredActions.length === 0 && styles.headerActionButtonDisabled],
           disabled: filteredActions.length === 0,
+          testID: `${REDUX_TEST_ID}-clear`,
+          accessibilityRole: "button",
+          accessibilityLabel: "Clear actions",
+          accessibilityState: {
+            disabled: filteredActions.length === 0
+          },
           children: /*#__PURE__*/_jsx(Trash2, {
             size: 14,
             color: filteredActions.length > 0 ? night.color.textTertiary : night.color.textTertiary
@@ -319,6 +443,7 @@ export function ReduxModal({
     }) : /*#__PURE__*/_jsxs(_Fragment, {
       children: [instrumentError && !isInstrumented && !reduxActionStore.isCaptureSuppressed() && /*#__PURE__*/_jsxs(View, {
         style: styles.errorBanner,
+        testID: `${REDUX_TEST_ID}-banner-error`,
         children: [/*#__PURE__*/_jsx(AlertTriangle, {
           size: 14,
           color: night.color.danger
@@ -328,6 +453,7 @@ export function ReduxModal({
         })]
       }), !isEnabled && isInstrumented && /*#__PURE__*/_jsxs(View, {
         style: styles.disabledBanner,
+        testID: `${REDUX_TEST_ID}-banner-disabled`,
         children: [/*#__PURE__*/_jsx(Power, {
           size: 14,
           color: night.color.warning
@@ -337,6 +463,7 @@ export function ReduxModal({
         })]
       }), captureMechanism === "patch" && !reduxActionStore.isCaptureSuppressed() && /*#__PURE__*/_jsxs(View, {
         style: styles.disabledBanner,
+        testID: `${REDUX_TEST_ID}-banner-patch`,
         children: [/*#__PURE__*/_jsx(AlertTriangle, {
           size: 14,
           color: night.color.warning
@@ -348,11 +475,15 @@ export function ReduxModal({
         style: styles.lockedBanner,
         onPress: handleUpgradePress,
         activeOpacity: 0.8,
+        testID: `${REDUX_TEST_ID}-locked`,
+        accessibilityRole: "button",
+        accessibilityLabel: `${lockedActionCount} older ${lockedActionCount === 1 ? "action" : "actions"} locked. Upgrade to see them.`,
         children: [/*#__PURE__*/_jsx(Lock, {
           size: 14,
           color: night.color.accent
         }), /*#__PURE__*/_jsxs(Text, {
           style: styles.lockedText,
+          testID: `${REDUX_TEST_ID}-locked-text`,
           children: [lockedActionCount, " older ", lockedActionCount === 1 ? "action" : "actions", " locked"]
         }), /*#__PURE__*/_jsx(View, {
           style: styles.upgradeBadge,
@@ -363,6 +494,7 @@ export function ReduxModal({
         })]
       }), visibleActions.length > 0 ? /*#__PURE__*/_jsx(FlatList, {
         ref: flatListRef,
+        testID: `${REDUX_TEST_ID}-list`,
         data: visibleActions,
         renderItem: renderItem,
         keyExtractor: keyExtractor,
@@ -374,7 +506,8 @@ export function ReduxModal({
         windowSize: 5,
         updateCellsBatchingPeriod: 50
       }) : /*#__PURE__*/_jsx(EmptyState, {
-        isEnabled: isEnabled
+        isEnabled: isEnabled,
+        query: searchText
       })]
     })
   });
@@ -520,6 +653,10 @@ const styles = StyleSheet.create({
   headerActionButtonDisabled: {
     opacity: 0.55
   },
+  headerActionButtonActive: {
+    backgroundColor: night.color.accentSoft,
+    borderColor: night.color.accentBorderStrong
+  },
   startButton: {
     backgroundColor: macOSColors.semantic.successBackground,
     borderColor: macOSColors.semantic.success + "40"

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

@@ -28,6 +28,7 @@ export const ENHANCER_SYMBOL = Symbol.for("@@buoy/enhancerInstrumented");
 let activeStore = null;
 let mechanism = null;
 let diagnostic = null;
+let timeTravelReducer = false;
 export function registerActiveStore(store, mech) {
   activeStore = store;
   mechanism = mech;
@@ -46,6 +47,33 @@ export function getCaptureMechanism() {
   return mechanism;
 }
 
+/**
+ * Record that a reducer able to serve `BUOY_JUMP_TO_STATE` is in the store.
+ *
+ * Called by the devtools-hook enhancer and by `withBuoyDevTools` — the only
+ * two things that wrap the root reducer. Capture and time travel are separate
+ * capabilities and they are wired separately: a store can be fully captured
+ * through `buoyReduxMiddleware` and still have no way to restore a state,
+ * because middleware sits ABOVE the reducer and cannot replace what it
+ * returns.
+ */
+export function markTimeTravelReducer() {
+  timeTravelReducer = true;
+}
+
+/**
+ * Whether pressing JUMP can actually do anything.
+ *
+ * Worth a first-class answer rather than a try-and-see, because the failure is
+ * invisible: `jumpToState` dispatches into a store that simply does not
+ * recognise the action, the reducer returns the state it already had, and the
+ * screen does not move. From the outside that is indistinguishable from a
+ * devtool that is broken.
+ */
+export function isTimeTravelAvailable() {
+  return timeTravelReducer && activeStore !== null;
+}
+
 /**
  * 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.
@@ -58,6 +86,7 @@ export function getInstrumentationStatus() {
     mechanism,
     capture: mechanism === "enhancer" || mechanism === "middleware" ? "full" : mechanism === "patch" ? "top-level-only" : "none",
     hasStore: activeStore !== null,
+    timeTravel: isTimeTravelAvailable(),
     diagnostic
   };
 }

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

@@ -15,8 +15,8 @@
  * capture as "top-level-only" — see activeStoreRegistry.getInstrumentationStatus.
  */
 
-import { reduxActionStore, isEvictedState } from "./reduxActionStore";
-import { BUOY_JUMP_TO_STATE, isMiddlewareActive } from "./buoyReduxMiddleware";
+import { reduxActionStore } from "./reduxActionStore";
+import { isMiddlewareActive } from "./buoyReduxMiddleware";
 import { registerActiveStore, unregisterActiveStore, getActiveStore as getRegisteredStore, ENHANCER_SYMBOL } from "./activeStoreRegistry";
 
 // Re-exported for non-React callers (sync adapter, app code).
@@ -172,47 +172,15 @@ export function registerReduxStore(store, options = {}) {
 // Time-Travel / Introspection
 // ============================================
 
-let warnedJumpUnsupported = false;
-
 /**
- * Jump to a specific state (time-travel).
+ * Time travel lives in buoyReduxMiddleware.ts and is re-exported here.
  *
- * Real on the enhancer path (reducer is wrapped from creation) and on the
- * middleware path when the app used `withBuoyDevTools`. On the bare patch
- * path there's no reducer wrapper, so the jump action is ignored — we detect
- * that and warn once instead of pretending it worked.
- */
-export function jumpToState(state) {
-  if (isEvictedState(state)) {
-    console.warn("[BuoyRedux] Cannot jump - this action's state was evicted (raw state is retained for recent actions only)");
-    return;
-  }
-  const store = getRegisteredStore();
-  if (!store) {
-    console.warn("[BuoyRedux] Cannot jump to state - no store instrumented");
-    return;
-  }
-  store.dispatch({
-    type: BUOY_JUMP_TO_STATE,
-    payload: state
-  });
-  if (typeof __DEV__ !== "undefined" && __DEV__ && !warnedJumpUnsupported && store.getState() !== state) {
-    warnedJumpUnsupported = true;
-    console.warn("[BuoyRedux] Time-travel jump was ignored by the store. Wrap your root " + "reducer with withBuoyDevTools(), or ensure @buoy-gg/redux is imported " + "before your store is created (enhancer path) for real time travel.");
-  }
-}
-
-/**
- * Replay an action (dispatch it again)
+ * It used to be reimplemented in this file, and the two copies drifted: this
+ * one learned to notice that a jump had been ignored, the one the modal's JUMP
+ * button actually calls never did. So the detection existed and no user could
+ * ever have seen it. One implementation, one behaviour.
  */
-export function replayAction(action) {
-  const store = getRegisteredStore();
-  if (store) {
-    store.dispatch(action);
-  } else {
-    console.warn("[BuoyRedux] Cannot replay action - no store instrumented");
-  }
-}
+export { jumpToState, replayAction, isTimeTravelAvailable } from "./buoyReduxMiddleware";
 
 /**
  * Get the currently active (instrumented) store.

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

@@ -17,7 +17,7 @@
  */
 
 import { reduxActionStore, isEvictedState } from "./reduxActionStore";
-import { registerActiveStore, getActiveStore } from "./activeStoreRegistry";
+import { registerActiveStore, getActiveStore, markTimeTravelReducer, isTimeTravelAvailable } from "./activeStoreRegistry";
 
 // ============================================
 // Middleware Active Tracking
@@ -43,9 +43,18 @@ export const BUOY_REPLAY_ACTION = "@@buoy/REPLAY_ACTION";
 /**
  * Jump to a specific state (time-travel).
  *
- * Registry-backed, so it works on EVERY capture path (enhancer, middleware,
- * patch) — previously this only worked when the middleware was installed,
- * which silently broke the modal's Jump button on the zero-config path.
+ * Registry-backed, so it reaches the store on every capture path — but
+ * REACHING the store is not the same as being able to jump, and conflating the
+ * two is what made this fail invisibly. A jump is an action like any other: it
+ * only does something if a reducer handles it, and the only two things that
+ * install such a reducer are the devtools-hook enhancer and `withBuoyDevTools`.
+ * An app that captures through `buoyReduxMiddleware` alone dispatches the jump
+ * into a store that has never heard of it, gets its own state back, and shows
+ * a screen that does not move — with no error, because nothing went wrong.
+ *
+ * So the capability is checked up front and refused out loud. The UI asks the
+ * same question (`isTimeTravelAvailable`) and disables the button, which is the
+ * half a warning cannot do.
  */
 export function jumpToState(state) {
   if (isEvictedState(state)) {
@@ -53,16 +62,26 @@ export function jumpToState(state) {
     return;
   }
   const store = getActiveStore();
-  if (store) {
-    store.dispatch({
-      type: BUOY_JUMP_TO_STATE,
-      payload: state
-    });
-  } else {
+  if (!store) {
     console.warn("[BuoyRedux] Cannot jump to state - no store instrumented");
+    return;
   }
+  if (!isTimeTravelAvailable()) {
+    console.warn("[BuoyRedux] Cannot jump to state - the root reducer cannot serve a " + "state jump. Capture and time travel are wired separately: either put " + "`import '@buoy-gg/redux';` first in your app entry (so Buoy is the " + "store enhancer), or wrap your root reducer with withBuoyDevTools().");
+    return;
+  }
+  store.dispatch({
+    type: BUOY_JUMP_TO_STATE,
+    payload: state
+  });
 }
 
+/**
+ * Whether the JUMP affordance can do anything in this app. Re-exported from
+ * the registry so hosts have one import for the whole time-travel surface.
+ */
+export { isTimeTravelAvailable } from "./activeStoreRegistry";
+
 /**
  * Replay an action (dispatch it again)
  */
@@ -87,6 +106,9 @@ export function replayAction(action) {
  * ```
  */
 export function withBuoyDevTools(reducer) {
+  // The other half of the time-travel wiring (see jumpToState): this is one of
+  // exactly two places that can answer BUOY_JUMP_TO_STATE.
+  markTimeTravelReducer();
   return (state, action) => {
     // Handle jump to state action
     if (action.type === BUOY_JUMP_TO_STATE) {

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

@@ -27,7 +27,7 @@
 
 import { reduxActionStore } from "./reduxActionStore";
 import { BUOY_JUMP_TO_STATE, isMiddlewareActive } from "./buoyReduxMiddleware";
-import { registerActiveStore, ENHANCER_SYMBOL } from "./activeStoreRegistry";
+import { registerActiveStore, markTimeTravelReducer, ENHANCER_SYMBOL } from "./activeStoreRegistry";
 /** Standard redux compose. */
 function composeFns(...funcs) {
   if (funcs.length === 0) return arg => arg;
@@ -37,6 +37,10 @@ function composeFns(...funcs) {
 
 /** Wrap a reducer so BUOY_JUMP_TO_STATE performs a real state jump. */
 function wrapReducer(reducer) {
+  // Announce the capability, not just perform it: with nothing wrapped, a jump
+  // is dispatched, ignored, and silent — so the UI needs to know in advance
+  // whether the button it is drawing can keep its promise.
+  markTimeTravelReducer();
   return (state, action) => {
     if (action && action.type === BUOY_JUMP_TO_STATE) {
       return action.payload;