@buoy-gg/redux 7.0.4 → 7.0.6

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

@@ -1,18 +1,26 @@
 "use strict";
 
 /**
- * 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 { reduxActionStore } from "./reduxActionStore";
 import { BUOY_JUMP_TO_STATE, isMiddlewareActive } from "./buoyReduxMiddleware";
+import { registerActiveStore, unregisterActiveStore, getActiveStore as getRegisteredStore, ENHANCER_SYMBOL } from "./activeStoreRegistry";
+
+// Re-exported for non-React callers (sync adapter, app code).
+export { getInstrumentationStatus } from "./activeStoreRegistry";
 
 // ============================================
 // Store Tracking
@@ -24,15 +32,6 @@ const INSTRUMENTED_SYMBOL = Symbol.for("@@buoy/instrumented");
 /** Symbol to store original dispatch reference */
 const ORIGINAL_DISPATCH_SYMBOL = Symbol.for("@@buoy/originalDispatch");
 
-/** Symbol to store original reducer reference */
-const ORIGINAL_REDUCER_SYMBOL = Symbol.for("@@buoy/originalReducer");
-
-/** Reference to the active store for time-travel operations */
-let activeStore = null;
-
-/** Track if store has been enhanced for time-travel */
-let timeTravelEnabled = false;
-
 // ============================================
 // Type Definitions
 // ============================================
@@ -42,40 +41,44 @@ let timeTravelEnabled = false;
 // ============================================
 
 /**
- * Check if a store has already been instrumented
+ * Check if a store has already been instrumented (either mechanism)
  */
 export function isStoreInstrumented(store) {
-  return store[INSTRUMENTED_SYMBOL] === true;
+  const s = store;
+  return s[INSTRUMENTED_SYMBOL] === true || s[ENHANCER_SYMBOL] === true;
 }
 
 /**
- * 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 function instrumentStore(store, options = {}) {
   const instrumentedStore = store;
 
+  // Store was created through the devtools-hook enhancer — full capture is
+  // already live; just (re)point the registry at it.
+  if (instrumentedStore[ENHANCER_SYMBOL]) {
+    registerActiveStore(store, "enhancer");
+    return () => {};
+  }
+
   // Skip if middleware is already handling action capture
-  // This prevents duplicate recording when both mechanisms are active
   if (isMiddlewareActive()) {
-    activeStore = store;
+    registerActiveStore(store, "middleware");
     return () => {};
   }
 
-  // Skip if already instrumented
+  // Skip if already patched — update the registry even so (store swap case)
   if (instrumentedStore[INSTRUMENTED_SYMBOL]) {
-    // Update active store reference even if already instrumented
-    activeStore = store;
+    registerActiveStore(store, "patch");
     return () => {};
   }
   const {
-    enableTimeTravel = false,
     maxActions = 200,
     ignoreActions = []
   } = options;
@@ -126,12 +129,7 @@ export function instrumentStore(store, options = {}) {
   // Replace dispatch
   store.dispatch = instrumentedDispatch;
   instrumentedStore[INSTRUMENTED_SYMBOL] = true;
-  activeStore = store;
-
-  // Enable time-travel if requested and store supports replaceReducer
-  if (enableTimeTravel && typeof store.replaceReducer === "function") {
-    enableTimeTravelSupport(store);
-  }
+  registerActiveStore(store, "patch");
 
   // Return cleanup function
   return () => {
@@ -140,90 +138,63 @@ export function instrumentStore(store, options = {}) {
 }
 
 /**
- * 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 function uninstrumentStore(store) {
   const instrumentedStore = store;
-  if (!instrumentedStore[INSTRUMENTED_SYMBOL]) {
-    return;
-  }
-
-  // Restore original dispatch
-  const originalDispatch = instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
-  if (originalDispatch) {
-    store.dispatch = originalDispatch;
-  }
-
-  // Restore original reducer if time-travel was enabled
-  const originalReducer = instrumentedStore[ORIGINAL_REDUCER_SYMBOL];
-  if (originalReducer && typeof store.replaceReducer === "function") {
-    store.replaceReducer(originalReducer);
-    timeTravelEnabled = false;
-  }
-
-  // Clean up symbols
-  delete instrumentedStore[INSTRUMENTED_SYMBOL];
-  delete instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
-  delete instrumentedStore[ORIGINAL_REDUCER_SYMBOL];
-
-  // Clear active store reference
-  if (activeStore === store) {
-    activeStore = null;
+  if (instrumentedStore[INSTRUMENTED_SYMBOL]) {
+    const originalDispatch = instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
+    if (originalDispatch) {
+      store.dispatch = originalDispatch;
+    }
+    delete instrumentedStore[INSTRUMENTED_SYMBOL];
+    delete instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
   }
+  unregisterActiveStore(store);
 }
 
-// ============================================
-// Time-Travel Support
-// ============================================
-
 /**
- * Enable time-travel support by wrapping the store's reducer
+ * 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.
  *
- * This uses store.replaceReducer to inject our time-travel wrapper
- * dynamically, without requiring users to manually wrap their reducer.
+ * Prefer the zero-config paths; this exists so no app is ever stuck.
  */
-function enableTimeTravelSupport(store) {
-  const instrumentedStore = store;
-
-  // Get current reducer by dispatching a probe action
-  // Note: This is a workaround since there's no store.getReducer()
-  // We'll wrap whatever reducer is currently active
-  const currentState = store.getState();
-
-  // Create a time-travel enabled reducer wrapper
-  const timeTravelReducer = (state = currentState, action) => {
-    // Handle jump to state action
-    if (action.type === BUOY_JUMP_TO_STATE) {
-      return action.payload;
-    }
+export function registerReduxStore(store, options = {}) {
+  return instrumentStore(store, options);
+}
 
-    // Get the result from the original dispatch flow
-    // Since we've already wrapped dispatch, we need to be careful here
-    // The state will be updated by the store's internal reducer
-    return state;
-  };
+// ============================================
+// Time-Travel / Introspection
+// ============================================
 
-  // Store reference (we can't actually get the original reducer directly)
-  // This approach has limitations - full time-travel works better with
-  // the explicit withBuoyDevTools wrapper
-  instrumentedStore[ORIGINAL_REDUCER_SYMBOL] = timeTravelReducer;
-  timeTravelEnabled = true;
-}
+let warnedJumpUnsupported = false;
 
 /**
- * Jump to a specific state (time-travel)
+ * 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 function jumpToState(state) {
-  if (activeStore) {
-    activeStore.dispatch({
-      type: BUOY_JUMP_TO_STATE,
-      payload: state
-    });
-  } else {
+  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.");
   }
 }
 
@@ -231,30 +202,28 @@ export function jumpToState(state) {
  * Replay an action (dispatch it again)
  */
 export function replayAction(action) {
-  if (activeStore) {
-    activeStore.dispatch(action);
+  const store = getRegisteredStore();
+  if (store) {
+    store.dispatch(action);
   } else {
     console.warn("[BuoyRedux] Cannot replay action - no store instrumented");
   }
 }
 
 /**
- * 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 function getActiveStore() {
-  return activeStore;
+  return getRegisteredStore();
 }
 
 /**
  * Check if auto-instrumentation is active
  */
 export function isAutoInstrumentActive() {
-  return activeStore !== null && isStoreInstrumented(activeStore);
-}
-
-/**
- * Check if time-travel support is enabled
- */
-export function isTimeTravelEnabled() {
-  return timeTravelEnabled;
+  return getRegisteredStore() !== null;
 }

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,21 +50,24 @@
  * });
  * ```
  */
+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";
 export type { UseReduxActionsResult } from "./redux/hooks/useReduxActions";
 export { useAutoInstrumentRedux, useReduxAvailability, } from "./redux/hooks/useAutoInstrumentRedux";
 export type { UseAutoInstrumentReduxOptions, UseAutoInstrumentReduxResult, } from "./redux/hooks/useAutoInstrumentRedux";
-export { ReduxModal, FREE_TIER_ACTION_LIMIT } from "./redux/components/ReduxModal";
+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";
+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;AAK9C,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACnF,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

@@ -7,12 +7,26 @@
 /** Free tier limit for action history */
 export declare const FREE_TIER_ACTION_LIMIT = 25;
 interface ReduxModalProps {
+    /**
+     * Render as a header-bar + body (+ footer) stack instead of inside `JsModal`,
+     * for hosts that place tools in a panel rather than a modal (Buoy Desktop).
+     * Only the shell differs — header, screens and state are shared. See
+     * `ReduxToolView` at the bottom of this file.
+     */
+    inline?: boolean;
     visible: boolean;
     onClose: () => void;
     onBack?: () => void;
     onMinimize?: (modalState: unknown) => void;
     enableSharedModalDimensions?: boolean;
 }
-export declare function ReduxModal({ visible, onClose, onBack, onMinimize, enableSharedModalDimensions, }: ReduxModalProps): import("react").JSX.Element | null;
+export declare function ReduxModal({ visible, onClose, onBack, onMinimize, enableSharedModalDimensions, inline, }: ReduxModalProps): import("react").JSX.Element | null;
+/**
+ * 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 declare function ReduxToolView(props?: Omit<ReduxModalProps, "visible" | "onClose" | "inline">): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=ReduxModal.d.ts.map

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,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,GACpC,EAAE,eAAe,sCAiYjB"}
+{"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"}