@buoy-gg/redux 7.0.38 → 7.0.39

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

@@ -1 +1,231 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getActiveStore=getActiveStore,Object.defineProperty(exports,"getInstrumentationStatus",{enumerable:!0,get:function(){return _activeStoreRegistry.getInstrumentationStatus}}),exports.instrumentStore=instrumentStore,exports.isAutoInstrumentActive=isAutoInstrumentActive,exports.isStoreInstrumented=isStoreInstrumented,Object.defineProperty(exports,"isTimeTravelAvailable",{enumerable:!0,get:function(){return _buoyReduxMiddleware.isTimeTravelAvailable}}),Object.defineProperty(exports,"jumpToState",{enumerable:!0,get:function(){return _buoyReduxMiddleware.jumpToState}}),exports.registerReduxStore=registerReduxStore,Object.defineProperty(exports,"replayAction",{enumerable:!0,get:function(){return _buoyReduxMiddleware.replayAction}}),exports.uninstrumentStore=uninstrumentStore;var _reduxActionStore=require("./reduxActionStore"),_buoyReduxMiddleware=require("./buoyReduxMiddleware"),_activeStoreRegistry=require("./activeStoreRegistry");const INSTRUMENTED_SYMBOL=Symbol.for("@@buoy/instrumented"),ORIGINAL_DISPATCH_SYMBOL=Symbol.for("@@buoy/originalDispatch");function isStoreInstrumented(e){const t=e;return!0===t[INSTRUMENTED_SYMBOL]||!0===t[_activeStoreRegistry.ENHANCER_SYMBOL]}function instrumentStore(e,t={}){const r=e;if(r[_activeStoreRegistry.ENHANCER_SYMBOL])return(0,_activeStoreRegistry.registerActiveStore)(e,"enhancer"),()=>{};if((0,_buoyReduxMiddleware.isMiddlewareActive)())return(0,_activeStoreRegistry.registerActiveStore)(e,"middleware"),()=>{};if(r[INSTRUMENTED_SYMBOL])return(0,_activeStoreRegistry.registerActiveStore)(e,"patch"),()=>{};const{maxActions:i=200,ignoreActions:n=[]}=t;_reduxActionStore.reduxActionStore.setMaxActions(i);const o=e.dispatch.bind(e);return r[ORIGINAL_DISPATCH_SYMBOL]=o,e.dispatch=t=>{if("object"!=typeof t||null===t||"string"!=typeof t.type)return o(t);const r=t.type;if(r.startsWith("@@buoy/"))return o(t);if(r.startsWith("@@redux/"))return o(t);if(n.includes(r))return o(t);const i=performance.now(),u=e.getState(),s=o(t),c=e.getState(),S=performance.now()-i;return _reduxActionStore.reduxActionStore.addAction(t,u,c,S),s},r[INSTRUMENTED_SYMBOL]=!0,(0,_activeStoreRegistry.registerActiveStore)(e,"patch"),()=>{uninstrumentStore(e)}}function uninstrumentStore(e){const t=e;if(t[INSTRUMENTED_SYMBOL]){const r=t[ORIGINAL_DISPATCH_SYMBOL];r&&(e.dispatch=r),delete t[INSTRUMENTED_SYMBOL],delete t[ORIGINAL_DISPATCH_SYMBOL]}(0,_activeStoreRegistry.unregisterActiveStore)(e)}function registerReduxStore(e,t={}){return instrumentStore(e,t)}function getActiveStore(){return(0,_activeStoreRegistry.getActiveStore)()}function isAutoInstrumentActive(){return null!==(0,_activeStoreRegistry.getActiveStore)()}
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getActiveStore = getActiveStore;
+Object.defineProperty(exports, "getInstrumentationStatus", {
+  enumerable: true,
+  get: function () {
+    return _activeStoreRegistry.getInstrumentationStatus;
+  }
+});
+exports.instrumentStore = instrumentStore;
+exports.isAutoInstrumentActive = isAutoInstrumentActive;
+exports.isStoreInstrumented = isStoreInstrumented;
+Object.defineProperty(exports, "isTimeTravelAvailable", {
+  enumerable: true,
+  get: function () {
+    return _buoyReduxMiddleware.isTimeTravelAvailable;
+  }
+});
+Object.defineProperty(exports, "jumpToState", {
+  enumerable: true,
+  get: function () {
+    return _buoyReduxMiddleware.jumpToState;
+  }
+});
+exports.registerReduxStore = registerReduxStore;
+Object.defineProperty(exports, "replayAction", {
+  enumerable: true,
+  get: function () {
+    return _buoyReduxMiddleware.replayAction;
+  }
+});
+exports.uninstrumentStore = uninstrumentStore;
+var _reduxActionStore = require("./reduxActionStore");
+var _buoyReduxMiddleware = require("./buoyReduxMiddleware");
+var _activeStoreRegistry = require("./activeStoreRegistry");
+/**
+ * Fallback auto-instrumentation for Redux stores.
+ *
+ * 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.
+ *
+ * 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.
+ */
+
+// Re-exported for non-React callers (sync adapter, app code).
+
+// ============================================
+// Store Tracking
+// ============================================
+
+/** Symbol to mark stores that have been instrumented */
+const INSTRUMENTED_SYMBOL = Symbol.for("@@buoy/instrumented");
+
+/** Symbol to store original dispatch reference */
+const ORIGINAL_DISPATCH_SYMBOL = Symbol.for("@@buoy/originalDispatch");
+
+// ============================================
+// Type Definitions
+// ============================================
+
+// ============================================
+// Core Instrumentation
+// ============================================
+
+/**
+ * Check if a store has already been instrumented (either mechanism)
+ */
+function isStoreInstrumented(store) {
+  const s = store;
+  return s[INSTRUMENTED_SYMBOL] === true || s[_activeStoreRegistry.ENHANCER_SYMBOL] === true;
+}
+
+/**
+ * Instrument a Redux store for action capture (fallback path).
+ *
+ * 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.
+ *
+ * @returns Cleanup function to restore original dispatch
+ */
+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[_activeStoreRegistry.ENHANCER_SYMBOL]) {
+    (0, _activeStoreRegistry.registerActiveStore)(store, "enhancer");
+    return () => {};
+  }
+
+  // Skip if middleware is already handling action capture
+  if ((0, _buoyReduxMiddleware.isMiddlewareActive)()) {
+    (0, _activeStoreRegistry.registerActiveStore)(store, "middleware");
+    return () => {};
+  }
+
+  // Skip if already patched — update the registry even so (store swap case)
+  if (instrumentedStore[INSTRUMENTED_SYMBOL]) {
+    (0, _activeStoreRegistry.registerActiveStore)(store, "patch");
+    return () => {};
+  }
+  const {
+    maxActions = 200,
+    ignoreActions = []
+  } = options;
+
+  // Configure store
+  _reduxActionStore.reduxActionStore.setMaxActions(maxActions);
+
+  // Store original dispatch
+  const originalDispatch = store.dispatch.bind(store);
+  instrumentedStore[ORIGINAL_DISPATCH_SYMBOL] = originalDispatch;
+
+  // Create instrumented dispatch
+  const instrumentedDispatch = action => {
+    // Skip if action is not a plain object with a type property
+    // This filters out thunk functions, promises, and other non-action dispatches
+    if (typeof action !== "object" || action === null || typeof action.type !== "string") {
+      return originalDispatch(action);
+    }
+    const actionType = action.type;
+
+    // Don't record devtools internal actions
+    if (actionType.startsWith("@@buoy/")) {
+      return originalDispatch(action);
+    }
+
+    // Don't record Redux internal actions
+    if (actionType.startsWith("@@redux/")) {
+      return originalDispatch(action);
+    }
+
+    // Check ignore list
+    if (ignoreActions.includes(actionType)) {
+      return originalDispatch(action);
+    }
+
+    // Capture timing and state
+    const startTime = performance.now();
+    const prevState = store.getState();
+    const result = originalDispatch(action);
+    const nextState = store.getState();
+    const duration = performance.now() - startTime;
+
+    // Record the action
+    _reduxActionStore.reduxActionStore.addAction(action, prevState, nextState, duration);
+    return result;
+  };
+
+  // Replace dispatch
+  store.dispatch = instrumentedDispatch;
+  instrumentedStore[INSTRUMENTED_SYMBOL] = true;
+  (0, _activeStoreRegistry.registerActiveStore)(store, "patch");
+
+  // Return cleanup function
+  return () => {
+    uninstrumentStore(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.
+ */
+function uninstrumentStore(store) {
+  const instrumentedStore = store;
+  if (instrumentedStore[INSTRUMENTED_SYMBOL]) {
+    const originalDispatch = instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
+    if (originalDispatch) {
+      store.dispatch = originalDispatch;
+    }
+    delete instrumentedStore[INSTRUMENTED_SYMBOL];
+    delete instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
+  }
+  (0, _activeStoreRegistry.unregisterActiveStore)(store);
+}
+
+/**
+ * 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.
+ */
+function registerReduxStore(store, options = {}) {
+  return instrumentStore(store, options);
+}
+
+// ============================================
+// Time-Travel / Introspection
+// ============================================
+
+/**
+ * Time travel lives in buoyReduxMiddleware.ts and is re-exported here.
+ *
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+function getActiveStore() {
+  return (0, _activeStoreRegistry.getActiveStore)();
+}
+
+/**
+ * Check if auto-instrumentation is active
+ */
+function isAutoInstrumentActive() {
+  return (0, _activeStoreRegistry.getActiveStore)() !== null;
+}

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

@@ -1 +1,202 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.buoyReduxMiddleware=exports.BUOY_REPLAY_ACTION=exports.BUOY_JUMP_TO_STATE=void 0,exports.createBuoyReduxMiddleware=createBuoyReduxMiddleware,exports.isMiddlewareActive=isMiddlewareActive,Object.defineProperty(exports,"isTimeTravelAvailable",{enumerable:!0,get:function(){return _activeStoreRegistry.isTimeTravelAvailable}}),exports.jumpToState=jumpToState,exports.replayAction=replayAction,exports.withBuoyDevTools=withBuoyDevTools;var _reduxActionStore=require("./reduxActionStore"),_activeStoreRegistry=require("./activeStoreRegistry");let middlewareActive=!1;function isMiddlewareActive(){return middlewareActive}const BUOY_JUMP_TO_STATE=exports.BUOY_JUMP_TO_STATE="@@buoy/JUMP_TO_STATE",BUOY_REPLAY_ACTION=exports.BUOY_REPLAY_ACTION="@@buoy/REPLAY_ACTION";function jumpToState(e){if((0,_reduxActionStore.isEvictedState)(e))return void console.warn("[BuoyRedux] Cannot jump - this action's state was evicted (raw state is retained for recent actions only)");const t=(0,_activeStoreRegistry.getActiveStore)();t?(0,_activeStoreRegistry.isTimeTravelAvailable)()?t.dispatch({type:BUOY_JUMP_TO_STATE,payload:e}):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()."):console.warn("[BuoyRedux] Cannot jump to state - no store instrumented")}function replayAction(e){const t=(0,_activeStoreRegistry.getActiveStore)();t?t.dispatch(e):console.warn("[BuoyRedux] Cannot replay action - no store instrumented")}function withBuoyDevTools(e){return(0,_activeStoreRegistry.markTimeTravelReducer)(),(t,r)=>r.type===BUOY_JUMP_TO_STATE?r.payload:e(t,r)}const buoyReduxMiddleware=e=>(middlewareActive=!0,(0,_activeStoreRegistry.registerActiveStore)(e,"middleware"),t=>r=>{const o=r,i=o.type;if(i?.startsWith("@@buoy/"))return t(r);const a=performance.now(),n=e.getState(),s=t(r),u=e.getState(),c=performance.now()-a;return _reduxActionStore.reduxActionStore.addAction(o,n,u,c),s});function createBuoyReduxMiddleware(e={}){const{maxActions:t=200,ignoreActions:r=[]}=e;return _reduxActionStore.reduxActionStore.setMaxActions(t),e=>(middlewareActive=!0,(0,_activeStoreRegistry.registerActiveStore)(e,"middleware"),t=>o=>{const i=o,a=i.type||"";if(a?.startsWith("@@buoy/"))return t(o);if(r.includes(a))return t(o);const n=performance.now(),s=e.getState(),u=t(o),c=e.getState(),d=performance.now()-n;return _reduxActionStore.reduxActionStore.addAction(i,s,c,d),u})}exports.buoyReduxMiddleware=buoyReduxMiddleware;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buoyReduxMiddleware = exports.BUOY_REPLAY_ACTION = exports.BUOY_JUMP_TO_STATE = void 0;
+exports.createBuoyReduxMiddleware = createBuoyReduxMiddleware;
+exports.isMiddlewareActive = isMiddlewareActive;
+Object.defineProperty(exports, "isTimeTravelAvailable", {
+  enumerable: true,
+  get: function () {
+    return _activeStoreRegistry.isTimeTravelAvailable;
+  }
+});
+exports.jumpToState = jumpToState;
+exports.replayAction = replayAction;
+exports.withBuoyDevTools = withBuoyDevTools;
+var _reduxActionStore = require("./reduxActionStore");
+var _activeStoreRegistry = require("./activeStoreRegistry");
+/**
+ * Buoy Redux Middleware for Redux Toolkit
+ *
+ * @example
+ * ```tsx
+ * import { configureStore } from '@reduxjs/toolkit';
+ * import { buoyReduxMiddleware, withBuoyDevTools } from '@buoy-gg/redux';
+ *
+ * const store = configureStore({
+ *   reducer: withBuoyDevTools(rootReducer),  // Enable time-travel
+ *   middleware: (getDefaultMiddleware) =>
+ *     getDefaultMiddleware().concat(buoyReduxMiddleware),
+ * });
+ * ```
+ */
+
+// ============================================
+// Middleware Active Tracking
+// ============================================
+
+/** Flag to indicate middleware is handling action capture */
+let middlewareActive = false;
+
+/**
+ * Check if the explicit middleware is active
+ * Used by auto-instrument to avoid duplicate capture
+ */
+function isMiddlewareActive() {
+  return middlewareActive;
+}
+
+// ============================================
+// Time-Travel Action Types
+// ============================================
+
+const BUOY_JUMP_TO_STATE = exports.BUOY_JUMP_TO_STATE = "@@buoy/JUMP_TO_STATE";
+const BUOY_REPLAY_ACTION = exports.BUOY_REPLAY_ACTION = "@@buoy/REPLAY_ACTION";
+/**
+ * Jump to a specific state (time-travel).
+ *
+ * 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.
+ */
+function jumpToState(state) {
+  if ((0, _reduxActionStore.isEvictedState)(state)) {
+    console.warn("[BuoyRedux] Cannot jump - this action's state was evicted (raw state is retained for recent actions only)");
+    return;
+  }
+  const store = (0, _activeStoreRegistry.getActiveStore)();
+  if (!store) {
+    console.warn("[BuoyRedux] Cannot jump to state - no store instrumented");
+    return;
+  }
+  if (!(0, _activeStoreRegistry.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.
+ */
+
+/**
+ * Replay an action (dispatch it again)
+ */
+function replayAction(action) {
+  const store = (0, _activeStoreRegistry.getActiveStore)();
+  if (store) {
+    store.dispatch(action);
+  } else {
+    console.warn("[BuoyRedux] Cannot replay action - no store instrumented");
+  }
+}
+
+/**
+ * Wrap your root reducer to enable time-travel support
+ *
+ * @example
+ * ```tsx
+ * const store = configureStore({
+ *   reducer: withBuoyDevTools(rootReducer),
+ *   middleware: (getDefault) => getDefault().concat(buoyReduxMiddleware),
+ * });
+ * ```
+ */
+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.
+  (0, _activeStoreRegistry.markTimeTravelReducer)();
+  return (state, action) => {
+    // Handle jump to state action
+    if (action.type === BUOY_JUMP_TO_STATE) {
+      const jumpAction = action;
+      return jumpAction.payload;
+    }
+
+    // Pass through to original reducer
+    return reducer(state, action);
+  };
+}
+
+/**
+ * Default middleware - just add to your store!
+ */
+const buoyReduxMiddleware = storeApi => {
+  // Mark middleware as active so auto-instrument knows to skip
+  middlewareActive = true;
+
+  // 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.
+  (0, _activeStoreRegistry.registerActiveStore)(storeApi, "middleware");
+  return next => action => {
+    const actionObj = action;
+    const actionType = actionObj.type;
+
+    // Don't record devtools internal actions
+    if (actionType?.startsWith("@@buoy/")) {
+      return next(action);
+    }
+    const startTime = performance.now();
+    const prevState = storeApi.getState();
+    const result = next(action);
+    const nextState = storeApi.getState();
+    const duration = performance.now() - startTime;
+    _reduxActionStore.reduxActionStore.addAction(actionObj, prevState, nextState, duration);
+    return result;
+  };
+};
+
+/**
+ * Create middleware with custom options
+ */
+exports.buoyReduxMiddleware = buoyReduxMiddleware;
+function createBuoyReduxMiddleware(options = {}) {
+  const {
+    maxActions = 200,
+    ignoreActions = []
+  } = options;
+  _reduxActionStore.reduxActionStore.setMaxActions(maxActions);
+  return storeApi => {
+    // Mark middleware as active so auto-instrument knows to skip
+    middlewareActive = true;
+
+    // Register as the active store (see buoyReduxMiddleware above).
+    (0, _activeStoreRegistry.registerActiveStore)(storeApi, "middleware");
+    return next => action => {
+      const actionObj = action;
+      const actionType = actionObj.type || "";
+
+      // Don't record devtools internal actions
+      if (actionType?.startsWith("@@buoy/")) {
+        return next(action);
+      }
+      if (ignoreActions.includes(actionType)) {
+        return next(action);
+      }
+      const startTime = performance.now();
+      const prevState = storeApi.getState();
+      const result = next(action);
+      const nextState = storeApi.getState();
+      const duration = performance.now() - startTime;
+      _reduxActionStore.reduxActionStore.addAction(actionObj, prevState, nextState, duration);
+      return result;
+    };
+  };
+}

package/lib/commonjs/redux/utils/createReduxHistoryAdapter.js

@@ -1 +1,146 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.createReduxHistoryAdapter=createReduxHistoryAdapter,exports.reduxHistoryAdapter=void 0;var _reduxActionStore=require("./reduxActionStore"),_ReduxIcon=require("../components/ReduxIcon");const REDUX_CAPABILITIES={timeTravel:!1,toggle:!1,edit:!1,diff:!0,export:!0,import:!1,reset:!0,recording:!0};function toHistoryEntry(t,e,r){return{id:t.id,label:t.type,timestamp:t.timestamp,data:t.payload??t.action,prevState:t.prevState,nextState:t.nextState,hasStateChange:t.hasStateChange,duration:t.duration,source:"redux",isCurrent:0===e,isInFuture:!1,isSkipped:!1,meta:{fullAction:t.action}}}function createReduxHistoryAdapter(t){const{icon:e=_ReduxIcon.ReduxIcon,color:r="#764ABC",name:o="Redux"}=t??{};let n=0;return{id:"redux",name:o,icon:e,color:r,capabilities:REDUX_CAPABILITIES,subscribe:t=>_reduxActionStore.reduxActionStore.subscribe(()=>{t()}),getEntries:()=>{const t=_reduxActionStore.reduxActionStore.getActions();return t.map((e,r)=>toHistoryEntry(e,r,t.length))},getEntryCount:()=>_reduxActionStore.reduxActionStore.getActions().length,getCurrentState:()=>{const t=_reduxActionStore.reduxActionStore.getActions();if(0!==t.length)return t[0].nextState},getStateAtEntry:t=>{const e=_reduxActionStore.reduxActionStore.getActionById(String(t));return e?.nextState},get currentIndex(){return n},jumpTo:t=>{const e=_reduxActionStore.reduxActionStore.getActions().findIndex(e=>e.id===String(t));-1!==e&&(n=e)},get isRecording(){return _reduxActionStore.reduxActionStore.getEnabled()},setRecording:t=>{_reduxActionStore.reduxActionStore.setEnabled(t)},reset:()=>{_reduxActionStore.reduxActionStore.clearActions(),n=0},exportHistory:()=>{const t=_reduxActionStore.reduxActionStore.getActions();return JSON.stringify(t,null,2)}}}const reduxHistoryAdapter=exports.reduxHistoryAdapter=createReduxHistoryAdapter();
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReduxHistoryAdapter = createReduxHistoryAdapter;
+exports.reduxHistoryAdapter = void 0;
+var _reduxActionStore = require("./reduxActionStore");
+var _ReduxIcon = require("../components/ReduxIcon");
+/**
+ * Redux History Adapter
+ *
+ * Wraps the existing reduxActionStore to implement the universal HistoryAdapter interface.
+ */
+
+/**
+ * Redux adapter capabilities
+ * Note: Full time-travel requires the instrument() pattern from redux-devtools.
+ * This adapter provides history viewing with basic navigation.
+ */
+const REDUX_CAPABILITIES = {
+  timeTravel: false,
+  // Would need instrument() for true time travel
+  toggle: false,
+  // Would need instrument() for skip/toggle
+  edit: false,
+  diff: true,
+  // We have prevState/nextState
+  export: true,
+  import: false,
+  reset: true,
+  recording: true
+};
+
+/**
+ * Convert ReduxAction to HistoryEntry
+ */
+function toHistoryEntry(action, index, _total) {
+  return {
+    id: action.id,
+    label: action.type,
+    timestamp: action.timestamp,
+    data: action.payload ?? action.action,
+    prevState: action.prevState,
+    nextState: action.nextState,
+    hasStateChange: action.hasStateChange,
+    duration: action.duration,
+    source: "redux",
+    isCurrent: index === 0,
+    // Most recent is current
+    isInFuture: false,
+    isSkipped: false,
+    meta: {
+      fullAction: action.action
+    }
+  };
+}
+
+/**
+ * Options for creating a Redux history adapter
+ */
+
+/**
+ * Create a Redux history adapter
+ *
+ * @param options - Optional configuration
+ * @returns HistoryAdapter instance
+ */
+function createReduxHistoryAdapter(options) {
+  const {
+    icon = _ReduxIcon.ReduxIcon,
+    color = "#764ABC",
+    // Redux purple
+    name = "Redux"
+  } = options ?? {};
+  let currentIndex = 0;
+  const adapter = {
+    // === Identity ===
+    id: "redux",
+    name,
+    icon,
+    color,
+    capabilities: REDUX_CAPABILITIES,
+    // === Subscription ===
+    subscribe: callback => {
+      return _reduxActionStore.reduxActionStore.subscribe(() => {
+        callback();
+      });
+    },
+    // === Data Access ===
+    getEntries: () => {
+      const actions = _reduxActionStore.reduxActionStore.getActions();
+      return actions.map((action, index) => toHistoryEntry(action, index, actions.length));
+    },
+    getEntryCount: () => {
+      return _reduxActionStore.reduxActionStore.getActions().length;
+    },
+    getCurrentState: () => {
+      const actions = _reduxActionStore.reduxActionStore.getActions();
+      if (actions.length === 0) return undefined;
+      // Most recent action's nextState is current state
+      return actions[0].nextState;
+    },
+    getStateAtEntry: entryId => {
+      const action = _reduxActionStore.reduxActionStore.getActionById(String(entryId));
+      return action?.nextState;
+    },
+    // === Navigation ===
+    get currentIndex() {
+      return currentIndex;
+    },
+    jumpTo: entryId => {
+      const actions = _reduxActionStore.reduxActionStore.getActions();
+      const index = actions.findIndex(a => a.id === String(entryId));
+      if (index !== -1) {
+        currentIndex = index;
+        // Note: This doesn't actually change app state without instrument()
+        // It just updates which entry is "selected" for viewing
+      }
+    },
+    // === Recording ===
+    get isRecording() {
+      return _reduxActionStore.reduxActionStore.getEnabled();
+    },
+    setRecording: enabled => {
+      _reduxActionStore.reduxActionStore.setEnabled(enabled);
+    },
+    // === Reset ===
+    reset: () => {
+      _reduxActionStore.reduxActionStore.clearActions();
+      currentIndex = 0;
+    },
+    // === Export ===
+    exportHistory: () => {
+      const actions = _reduxActionStore.reduxActionStore.getActions();
+      return JSON.stringify(actions, null, 2);
+    }
+  };
+  return adapter;
+}
+
+/**
+ * Default Redux adapter instance
+ * Use this if you only have one Redux store
+ */
+const reduxHistoryAdapter = exports.reduxHistoryAdapter = createReduxHistoryAdapter();