@buoy-gg/redux 7.0.5 → 7.0.6

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

@@ -17,6 +17,7 @@
  */
 
 import { reduxActionStore } from "./reduxActionStore";
+import { registerActiveStore, getActiveStore } from "./activeStoreRegistry";
 
 // ============================================
 // Middleware Active Tracking
@@ -39,20 +40,22 @@ export function isMiddlewareActive() {
 
 export const BUOY_JUMP_TO_STATE = "@@buoy/JUMP_TO_STATE";
 export const BUOY_REPLAY_ACTION = "@@buoy/REPLAY_ACTION";
-// Store reference to dispatch for time-travel
-let storeDispatch = null;
-
 /**
- * Jump to a specific state (time-travel)
+ * 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.
  */
 export function jumpToState(state) {
-  if (storeDispatch) {
-    storeDispatch({
+  const store = getActiveStore();
+  if (store) {
+    store.dispatch({
       type: BUOY_JUMP_TO_STATE,
       payload: state
     });
   } else {
-    console.warn("[BuoyRedux] Cannot jump to state - middleware not initialized");
+    console.warn("[BuoyRedux] Cannot jump to state - no store instrumented");
   }
 }
 
@@ -60,11 +63,11 @@ export function jumpToState(state) {
  * Replay an action (dispatch it again)
  */
 export function replayAction(action) {
-  if (storeDispatch) {
-    // Dispatch the original action directly
-    storeDispatch(action);
+  const store = getActiveStore();
+  if (store) {
+    store.dispatch(action);
   } else {
-    console.warn("[BuoyRedux] Cannot replay action - middleware not initialized");
+    console.warn("[BuoyRedux] Cannot replay action - no store instrumented");
   }
 }
 
@@ -99,8 +102,10 @@ export const buoyReduxMiddleware = storeApi => {
   // Mark middleware as active so auto-instrument knows to skip
   middlewareActive = true;
 
-  // Store dispatch reference for time-travel
-  storeDispatch = storeApi.dispatch;
+  // Register as the active store so getState/dispatch (MCP, desktop, time
+  // travel) work on the middleware path too — storeApi has both getState and
+  // dispatch, which is all the registry needs.
+  registerActiveStore(storeApi, "middleware");
   return next => action => {
     const actionObj = action;
     const actionType = actionObj.type;
@@ -132,8 +137,8 @@ export function createBuoyReduxMiddleware(options = {}) {
     // Mark middleware as active so auto-instrument knows to skip
     middlewareActive = true;
 
-    // Store dispatch reference for time-travel
-    storeDispatch = storeApi.dispatch;
+    // Register as the active store (see buoyReduxMiddleware above).
+    registerActiveStore(storeApi, "middleware");
     return next => action => {
       const actionObj = action;
       const actionType = actionObj.type || "";

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

@@ -0,0 +1,130 @@
+"use strict";
+
+/**
+ * Store-creation-time capture via the OFFICIAL Redux DevTools hook.
+ *
+ * `configureStore` defaults `devTools: true` and, at RTK module-evaluation
+ * time, snapshots `window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__` if defined.
+ * That global doesn't exist in React Native — so Buoy claims it (dev builds
+ * only, and only when nothing else has). This makes Buoy a real store
+ * ENHANCER, present from the store's birth:
+ *
+ * - FULL capture: actions dispatched from inside middleware/thunks (RTK
+ *   `pending`/`fulfilled`/`rejected`, RTK Query) hit our dispatch because the
+ *   enhancer sits BELOW applyMiddleware in the compose chain.
+ * - Real time travel: we wrap the reducer, so BUOY_JUMP_TO_STATE actually
+ *   jumps — and replaceReducer is re-wrapped, so hosts that inject reducers
+ *   dynamically keep working.
+ * - Nothing is monkey-patched: this is the integration point Redux itself
+ *   ships for devtools (same one react-native-debugger used).
+ *
+ * Race note: RTK snapshots the global when ITS module first evaluates, so this
+ * module must load before `@reduxjs/toolkit` does. `@buoy-gg/core` requires us
+ * at module scope, which usually wins; when it doesn't, the dispatch-patch
+ * fallback in autoInstrument.ts still binds at first mount. Apps that want a
+ * guarantee put `import '@buoy-gg/redux';` as the FIRST import of their entry.
+ */
+
+import { reduxActionStore } from "./reduxActionStore";
+import { BUOY_JUMP_TO_STATE, isMiddlewareActive } from "./buoyReduxMiddleware";
+import { registerActiveStore, ENHANCER_SYMBOL } from "./activeStoreRegistry";
+/** Standard redux compose. */
+function composeFns(...funcs) {
+  if (funcs.length === 0) return arg => arg;
+  if (funcs.length === 1) return funcs[0];
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
+}
+
+/** Wrap a reducer so BUOY_JUMP_TO_STATE performs a real state jump. */
+function wrapReducer(reducer) {
+  return (state, action) => {
+    if (action && action.type === BUOY_JUMP_TO_STATE) {
+      return action.payload;
+    }
+    return reducer(state, action);
+  };
+}
+
+/** Should this action be recorded? (Mirrors autoInstrument's filters.) */
+function isRecordable(action) {
+  if (typeof action !== "object" || action === null) return false;
+  const type = action.type;
+  if (typeof type !== "string") return false;
+  return !type.startsWith("@@buoy/") && !type.startsWith("@@redux/");
+}
+
+/**
+ * The Buoy store enhancer. Innermost in the compose chain (below
+ * applyMiddleware), so every action that reaches the reducer — including ones
+ * dispatched from inside middleware and thunks — passes through here.
+ */
+export const buoyDevtoolsEnhancer = createStore => (reducer, preloadedState) => {
+  const store = createStore(wrapReducer(reducer), preloadedState);
+  const dispatch = action => {
+    // If the explicit middleware is installed it already records — the
+    // enhancer stays passive to avoid double capture.
+    if (!isRecordable(action) || isMiddlewareActive()) {
+      return store.dispatch(action);
+    }
+    const startTime = performance.now();
+    const prevState = store.getState();
+    const result = store.dispatch(action);
+    reduxActionStore.addAction(action, prevState, store.getState(), performance.now() - startTime);
+    return result;
+  };
+  const enhanced = {
+    ...store,
+    dispatch,
+    // Keep time travel alive across dynamic reducer injection.
+    replaceReducer: next => store.replaceReducer(wrapReducer(next)),
+    [ENHANCER_SYMBOL]: true
+  };
+  registerActiveStore(enhanced, "enhancer");
+  return enhanced;
+};
+
+/**
+ * Implements the `__REDUX_DEVTOOLS_EXTENSION_COMPOSE__` calling conventions:
+ * - `compose(options)(...enhancers)` — what RTK's configureStore does
+ * - `compose(...enhancers)` — classic createStore usage from the Redux docs
+ */
+function buoyComposeWithDevTools(...args) {
+  if (args.length === 0) {
+    return composeFns(buoyDevtoolsEnhancer);
+  }
+  if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+    // Options form → return a compose function.
+    return (...enhancers) => composeFns(...enhancers, buoyDevtoolsEnhancer);
+  }
+  return composeFns(...args, buoyDevtoolsEnhancer);
+}
+let claimed = false;
+
+/**
+ * Claim the DevTools globals — dev builds only, and never over an existing
+ * claimant (e.g. the real browser extension on web).
+ *
+ * Idempotent; runs at module scope so simply importing `@buoy-gg/redux` (which
+ * `@buoy-gg/core` does at module scope) performs the claim as early as
+ * possible.
+ */
+export function claimDevtoolsHook() {
+  const isDev = typeof __DEV__ !== "undefined" && __DEV__;
+  if (!isDev) return false;
+  const g = globalThis;
+  if (!g.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) {
+    g.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ = buoyComposeWithDevTools;
+    claimed = true;
+  }
+  if (!g.__REDUX_DEVTOOLS_EXTENSION__) {
+    // Legacy single-enhancer form: `createStore(reducer, __REDUX_DEVTOOLS_EXTENSION__())`
+    g.__REDUX_DEVTOOLS_EXTENSION__ = () => buoyDevtoolsEnhancer;
+  }
+  return claimed;
+}
+
+/** Whether Buoy owns the DevTools compose global (i.e. won the load race). */
+export function isDevtoolsHookClaimed() {
+  return claimed;
+}
+claimDevtoolsHook();

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

@@ -5,4 +5,6 @@ export { buoyReduxMiddleware, createBuoyReduxMiddleware, withBuoyDevTools, jumpT
 export { createReduxHistoryAdapter, reduxHistoryAdapter } from "./createReduxHistoryAdapter";
 
 // Auto-instrumentation (zero-config)
-export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore, jumpToState as autoJumpToState, replayAction as autoReplayAction } from "./autoInstrument";
+export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore, getInstrumentationStatus, registerReduxStore, jumpToState as autoJumpToState, replayAction as autoReplayAction } from "./autoInstrument";
+// Store-creation-time capture (the primary, full-capture path)
+export { buoyDevtoolsEnhancer, claimDevtoolsHook, isDevtoolsHookClaimed } from "./devtoolsHook";

package/lib/typescript/index.d.ts

@@ -27,9 +27,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({
@@ -39,10 +50,12 @@
  * });
  * ```
  */
+import "./redux/utils/devtoolsHook";
 export { reduxToolPreset, createReduxTool } from "./preset";
 export { buoyReduxMiddleware, createBuoyReduxMiddleware, withBuoyDevTools, jumpToState, replayAction, BUOY_JUMP_TO_STATE, BUOY_REPLAY_ACTION, } from "./redux/utils/buoyReduxMiddleware";
-export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore, } from "./redux/utils/autoInstrument";
-export type { AutoInstrumentOptions } from "./redux/utils/autoInstrument";
+export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore, getInstrumentationStatus, registerReduxStore, } from "./redux/utils/autoInstrument";
+export type { AutoInstrumentOptions, InstrumentationStatus, CaptureMechanism, } from "./redux/utils/autoInstrument";
+export { buoyDevtoolsEnhancer, claimDevtoolsHook, isDevtoolsHookClaimed, } from "./redux/utils/devtoolsHook";
 export { createReduxHistoryAdapter, reduxHistoryAdapter, type ReduxHistoryAdapterOptions, } from "./redux/utils/createReduxHistoryAdapter";
 export { reduxSyncAdapter } from "./redux/sync/reduxSyncAdapter";
 export { useReduxActions } from "./redux/hooks/useReduxActions";
@@ -54,6 +67,7 @@ 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";
+export { ReduxAutoInstrument } from "./redux/components/ReduxAutoInstrument";
 export type { ActionCategory, ActionMeta, ReduxAction, ReduxFilter, ReduxConnectorOptions, ReduxStoreMinimal, BuoyReduxMiddlewareOptions, } from "./redux/types";
 /** @internal */
 export { reduxActionStore } from "./redux/utils/reduxActionStore";

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAKH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK5D,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,cAAc,GACf,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAK1E,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,KAAK,0BAA0B,GAChC,MAAM,yCAAyC,CAAC;AAKjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,YAAY,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAG3E,OAAO,EACL,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACV,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,sCAAsC,CAAC;AAO9C,OAAO,EACL,UAAU,EACV,aAAa,EACb,sBAAsB,GACvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EACL,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAKzD,YAAY,EACV,cAAc,EACd,UAAU,EACV,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,0BAA0B,GAC3B,MAAM,eAAe,CAAC;AAKvB,gBAAgB;AAChB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAKH,OAAO,4BAA4B,CAAC;AAKpC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK5D,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,cAAc,EACd,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,KAAK,0BAA0B,GAChC,MAAM,yCAAyC,CAAC;AAKjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,YAAY,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAG3E,OAAO,EACL,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACV,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,sCAAsC,CAAC;AAO9C,OAAO,EACL,UAAU,EACV,aAAa,EACb,sBAAsB,GACvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EACL,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAK7E,YAAY,EACV,cAAc,EACd,UAAU,EACV,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,0BAA0B,GAC3B,MAAM,eAAe,CAAC;AAKvB,gBAAgB;AAChB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}

package/lib/typescript/redux/components/ReduxAutoInstrument.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 declare function ReduxAutoInstrument(): null;
+//# sourceMappingURL=ReduxAutoInstrument.d.ts.map

package/lib/typescript/redux/components/ReduxAutoInstrument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReduxAutoInstrument.d.ts","sourceRoot":"","sources":["../../../../src/redux/components/ReduxAutoInstrument.tsx"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C"}

package/lib/typescript/redux/components/ReduxModal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReduxModal.d.ts","sourceRoot":"","sources":["../../../../src/redux/components/ReduxModal.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2CH,yCAAyC;AACzC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,UAAU,eAAe;IACvB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3C,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAgBD,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,OAAO,EACP,MAAM,EACN,UAAU,EACV,2BAAmC,EACnC,MAAc,GACf,EAAE,eAAe,sCAwZjB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,GAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAM,+BAGpE"}
+{"version":3,"file":"ReduxModal.d.ts","sourceRoot":"","sources":["../../../../src/redux/components/ReduxModal.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2CH,yCAAyC;AACzC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,UAAU,eAAe;IACvB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3C,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAgBD,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,OAAO,EACP,MAAM,EACN,UAAU,EACV,2BAAmC,EACnC,MAAc,GACf,EAAE,eAAe,sCAwajB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,GAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAM,+BAGpE"}

package/lib/typescript/redux/components/index.d.ts

@@ -3,4 +3,5 @@ export { ReduxActionItem } from "./ReduxActionItem";
 export { ReduxActionDetailView } from "./ReduxActionDetailView";
 export { ReduxActionDetailContent, ReduxActionDetailFooter, } from "./ReduxActionDetailContent";
 export { ReduxIcon } from "./ReduxIcon";
+export { ReduxAutoInstrument } from "./ReduxAutoInstrument";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/redux/components/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/redux/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EACL,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/redux/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EACL,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/lib/typescript/redux/hooks/useAutoInstrumentRedux.d.ts

@@ -1,29 +1,20 @@
 /**
  * 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 type { Store } from "@reduxjs/toolkit";
-import { type AutoInstrumentOptions } from "../utils/autoInstrument";
+import { type AutoInstrumentOptions, type CaptureMechanism } from "../utils/autoInstrument";
 export interface UseAutoInstrumentReduxOptions extends AutoInstrumentOptions {
     /** Whether to auto-start instrumentation (default: true) */
     autoStart?: boolean;
@@ -37,6 +28,11 @@ export interface UseAutoInstrumentReduxResult {
     error: string | null;
     /** Whether react-redux is available */
     isReactReduxAvailable: boolean;
+    /**
+     * Which capture path is live: 'enhancer' | 'middleware' (full capture) or
+     * 'patch' (top-level-only), null when nothing is bound yet.
+     */
+    captureMechanism: CaptureMechanism | null;
     /** Manually start instrumentation */
     startInstrumentation: () => void;
     /** Manually stop instrumentation */
@@ -44,14 +40,6 @@ export interface UseAutoInstrumentReduxResult {
     /** Reference to the instrumented store */
     store: Store | null;
 }
-/**
- * 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 declare function useAutoInstrumentRedux(options?: UseAutoInstrumentReduxOptions): UseAutoInstrumentReduxResult;
 /**
  * Lightweight hook to just check if Redux is available

package/lib/typescript/redux/hooks/useAutoInstrumentRedux.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAutoInstrumentRedux.d.ts","sourceRoot":"","sources":["../../../../src/redux/hooks/useAutoInstrumentRedux.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,yBAAyB,CAAC;AAyBjC,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E,4DAA4D;IAC5D,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,4BAA4B;IAC3C,kDAAkD;IAClD,cAAc,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,uCAAuC;IACvC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,qCAAqC;IACrC,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,oCAAoC;IACpC,mBAAmB,EAAE,MAAM,IAAI,CAAC;IAChC,0CAA0C;IAC1C,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAMD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,6BAAkC,GAC1C,4BAA4B,CA2G9B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CA0BA"}
+{"version":3,"file":"useAutoInstrumentRedux.d.ts","sourceRoot":"","sources":["../../../../src/redux/hooks/useAutoInstrumentRedux.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAIL,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AA0BjC,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E,4DAA4D;IAC5D,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,4BAA4B;IAC3C,kDAAkD;IAClD,cAAc,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,uCAAuC;IACvC,qBAAqB,EAAE,OAAO,CAAC;IAC/B;;;OAGG;IACH,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC1C,qCAAqC;IACrC,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,oCAAoC;IACpC,mBAAmB,EAAE,MAAM,IAAI,CAAC;IAChC,0CAA0C;IAC1C,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAMD,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,6BAAkC,GAC1C,4BAA4B,CAkH9B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CA0BA"}

package/lib/typescript/redux/sync/reduxSyncAdapter.d.ts

@@ -3,9 +3,11 @@
  * `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
@@ -23,12 +25,24 @@ export declare const reduxSyncAdapter: {
          * the full state tree only when `includeValues` is set (heavy).
          */
         getState: (params: unknown) => {
-            state?: any;
+            available: false;
+            slices: string[];
+            /** 'no-react-redux' | 'no-provider' | 'not-instrumented' */
+            reason: string;
+        } | {
+            state?: unknown;
             available: boolean;
             slices: string[];
+            /** 'full' | 'top-level-only' — what the live capture mechanism sees. */
+            capture: "full" | "top-level-only" | "none";
+            mechanism: import("..").CaptureMechanism | null;
         };
         /** Dispatch a plain action object to the instrumented store. */
         dispatch: (params: unknown) => {
+            available: false;
+            slices: string[];
+            /** 'no-react-redux' | 'no-provider' | 'not-instrumented' */
+            reason: string;
             dispatched: boolean;
             type?: undefined;
         } | {

package/lib/typescript/redux/sync/reduxSyncAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reduxSyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/redux/sync/reduxSyncAdapter.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;0BAGL,MAAM,IAAI;;;QAK9B;;;WAGG;2BACgB,OAAO;;;;;QAc1B,gEAAgE;2BAC7C,OAAO;;;;;;;;CAU7B,CAAC"}
+{"version":3,"file":"reduxSyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/redux/sync/reduxSyncAdapter.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB;;;0BAGL,MAAM,IAAI;;;QAK9B;;;WAGG;2BACgB,OAAO;;oBAlCZ,MAAM,EAAE;YACtB,4DAA4D;;;;;;YA6CxD,wEAAwE;;;;QAM5E,gEAAgE;2BAC7C,OAAO;;oBArDZ,MAAM,EAAE;YACtB,4DAA4D;;;;;;;;;CA8D/D,CAAC"}

package/lib/typescript/redux/utils/activeStoreRegistry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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). */
+export interface ActiveReduxStore {
+    getState: () => unknown;
+    dispatch: (action: any) => unknown;
+}
+/**
+ * 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.
+ */
+export type CaptureMechanism = "enhancer" | "middleware" | "patch";
+/** Why there is no bound store, when there isn't one. */
+export type ReduxDiagnostic = "no-react-redux" | "no-provider" | null;
+/** Marks stores created through the Buoy devtools-hook enhancer. */
+export declare const ENHANCER_SYMBOL: unique symbol;
+export declare function registerActiveStore(store: ActiveReduxStore, mech: CaptureMechanism): void;
+export declare function unregisterActiveStore(store: ActiveReduxStore): void;
+export declare function getActiveStore(): ActiveReduxStore | null;
+export declare function getCaptureMechanism(): CaptureMechanism | 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.
+ */
+export declare function setReduxDiagnostic(d: ReduxDiagnostic): void;
+export interface InstrumentationStatus {
+    /** Which capture path bound the store, or null when none has. */
+    mechanism: CaptureMechanism | null;
+    /** What the bound mechanism can see. */
+    capture: "full" | "top-level-only" | "none";
+    hasStore: boolean;
+    /** Why there's no store, when known (from the auto-instrument hook). */
+    diagnostic: ReduxDiagnostic;
+}
+export declare function getInstrumentationStatus(): InstrumentationStatus;
+//# sourceMappingURL=activeStoreRegistry.d.ts.map

package/lib/typescript/redux/utils/activeStoreRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activeStoreRegistry.d.ts","sourceRoot":"","sources":["../../../../src/redux/utils/activeStoreRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,OAAO,CAAC;IAIxB,QAAQ,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,YAAY,GAAG,OAAO,CAAC;AAEnE,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG,aAAa,GAAG,IAAI,CAAC;AAEtE,oEAAoE;AACpE,eAAO,MAAM,eAAe,eAA4C,CAAC;AAMzE,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,gBAAgB,GACrB,IAAI,CAIN;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAKnE;AAED,wBAAgB,cAAc,IAAI,gBAAgB,GAAG,IAAI,CAExD;AAED,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAE7D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAE3D;AAED,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnC,wCAAwC;IACxC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,MAAM,CAAC;IAC5C,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED,wBAAgB,wBAAwB,IAAI,qBAAqB,CAYhE"}

package/lib/typescript/redux/utils/autoInstrument.d.ts

@@ -1,16 +1,26 @@
 /**
- * Auto-instrumentation for Redux stores
+ * Fallback auto-instrumentation for Redux stores.
  *
- * This module provides zero-config Redux DevTools integration by automatically
- * patching the store's dispatch method when the DevTools component mounts.
+ * The PRIMARY capture path is the store-creation-time enhancer in
+ * devtoolsHook.ts (full capture, real time travel). This module is the
+ * fallback for stores created before our module loaded: it patches
+ * store.dispatch after the fact.
  *
- * Similar to how @buoy-gg/network patches globalThis.fetch, this patches
- * store.dispatch to capture all Redux actions without requiring manual
- * middleware configuration.
+ * Fallback limitation (inherent to patching, verified against redux 5.x):
+ * `middlewareAPI.dispatch` is a separate closure from `store.dispatch`, so
+ * actions dispatched from INSIDE middleware/thunks (RTK pending/fulfilled/
+ * rejected, RTK Query) bypass the patch. That's why this mechanism reports
+ * capture as "top-level-only" — see activeStoreRegistry.getInstrumentationStatus.
  */
 import type { Store, UnknownAction } from "@reduxjs/toolkit";
+import { type ActiveReduxStore } from "./activeStoreRegistry";
+export { getInstrumentationStatus, type InstrumentationStatus, type CaptureMechanism, } from "./activeStoreRegistry";
 export interface AutoInstrumentOptions {
-    /** Enable time-travel support (requires replaceReducer) */
+    /**
+     * @deprecated No longer does anything. Time travel is real on the enhancer
+     * path (zero-config) and via `withBuoyDevTools` on the middleware path; the
+     * old patch-path implementation could corrupt host stores and was removed.
+     */
     enableTimeTravel?: boolean;
     /** Maximum number of actions to store */
     maxActions?: number;
@@ -18,29 +28,42 @@ export interface AutoInstrumentOptions {
     ignoreActions?: string[];
 }
 /**
- * Check if a store has already been instrumented
+ * Check if a store has already been instrumented (either mechanism)
  */
 export declare function isStoreInstrumented(store: Store): boolean;
 /**
- * Instrument a Redux store for action capture
+ * Instrument a Redux store for action capture (fallback path).
  *
- * This function patches store.dispatch to capture all actions without
- * requiring the user to configure middleware manually.
+ * Patches store.dispatch to capture top-level dispatches. No-ops (but still
+ * registers the store for getState/dispatch) when the enhancer or the
+ * explicit middleware is already capturing.
  *
- * @param store - The Redux store to instrument
- * @param options - Configuration options
  * @returns Cleanup function to restore original dispatch
  */
 export declare function instrumentStore(store: Store, options?: AutoInstrumentOptions): () => void;
 /**
- * Remove instrumentation from a store
+ * Remove dispatch-patch instrumentation from a store.
+ *
+ * Only restores the patched dispatch. (This used to also replaceReducer with a
+ * synthetic reducer that froze the host store permanently — that path is gone.)
+ * Enhancer-created stores are left untouched apart from the registry.
  */
 export declare function uninstrumentStore(store: Store): void;
 /**
- * Jump to a specific state (time-travel)
+ * Manually register a store with Buoy — the escape hatch for apps that can't
+ * render FloatingDevTools inside a react-redux Provider (or don't use
+ * react-redux at all). Instruments via the fallback dispatch patch.
+ *
+ * Prefer the zero-config paths; this exists so no app is ever stuck.
+ */
+export declare function registerReduxStore(store: Store, options?: AutoInstrumentOptions): () => void;
+/**
+ * Jump to a specific state (time-travel).
  *
- * For full time-travel support, users should use withBuoyDevTools.
- * This limited version attempts to work with auto-instrumentation.
+ * 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 declare function jumpToState(state: unknown): void;
 /**
@@ -48,15 +71,15 @@ export declare function jumpToState(state: unknown): void;
  */
 export declare function replayAction(action: UnknownAction): void;
 /**
- * Get the currently active (instrumented) store
+ * Get the currently active (instrumented) store.
+ *
+ * NOTE: on the middleware path this is the middleware `storeApi`
+ * ({getState, dispatch}) rather than the full Store object — every consumer
+ * in this package only needs those two.
  */
-export declare function getActiveStore(): Store | null;
+export declare function getActiveStore(): ActiveReduxStore | null;
 /**
  * Check if auto-instrumentation is active
  */
 export declare function isAutoInstrumentActive(): boolean;
-/**
- * Check if time-travel support is enabled
- */
-export declare function isTimeTravelEnabled(): boolean;
 //# sourceMappingURL=autoInstrument.d.ts.map

package/lib/typescript/redux/utils/autoInstrument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../../src/redux/utils/autoInstrument.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAW,MAAM,kBAAkB,CAAC;AAiCtE,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,qBAA0B,GAClC,MAAM,IAAI,CAuFZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CA6BpD;AAwCD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAMhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAMxD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,KAAK,GAAG,IAAI,CAE7C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C"}
+{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../../src/redux/utils/autoInstrument.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAG7D,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,GACtB,MAAM,uBAAuB,CAAC;AAsB/B,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAGzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,qBAA0B,GAClC,MAAM,IAAI,CAuFZ;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAapD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,qBAA0B,GAClC,MAAM,IAAI,CAEZ;AASD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAoBhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAOxD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,gBAAgB,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD"}

package/lib/typescript/redux/utils/buoyReduxMiddleware.d.ts

@@ -23,7 +23,11 @@ export declare function isMiddlewareActive(): boolean;
 export declare const BUOY_JUMP_TO_STATE = "@@buoy/JUMP_TO_STATE";
 export declare const BUOY_REPLAY_ACTION = "@@buoy/REPLAY_ACTION";
 /**
- * Jump to a specific state (time-travel)
+ * 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.
  */
 export declare function jumpToState(state: unknown): void;
 /**

package/lib/typescript/redux/utils/buoyReduxMiddleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buoyReduxMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/redux/utils/buoyReduxMiddleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAU3D;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAMD,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AACzD,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AAiBzD;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAMhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAOxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAWnE;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,UA0BjC,CAAC;AAEF;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,0BAA+B,GACvC,UAAU,CAoCZ"}
+{"version":3,"file":"buoyReduxMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/redux/utils/buoyReduxMiddleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAc3D;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAMD,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AACzD,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AAczD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAOhD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAOxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAWnE;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,UA4BjC,CAAC;AAEF;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,0BAA+B,GACvC,UAAU,CAoCZ"}