@buoy-gg/redux 7.0.38 → 7.0.40

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

@@ -1 +1,465 @@
-"use strict";import{ChangeLog,approxJsonSize}from"@buoy-gg/shared-ui";export const STATE_RETENTION_LIMIT=25;export const STATE_EVICTED=Object.freeze({__buoyStateEvicted:!0,note:"Raw state retained for the 25 most recent actions only."});export const STATE_ON_DEVICE=Object.freeze({__buoyStateOnDevice:!0,note:"State trees stay on the device — fetched on demand via getActionDetail."});export const PAYLOAD_ON_DEVICE=Object.freeze({__buoyPayloadOnDevice:!0,note:"Payload stays on the device — fetched on demand via getActionDetail."});export function isPayloadOnDevice(e){return"object"==typeof e&&null!==e&&!0===e.__buoyPayloadOnDevice}export function isEvictedState(e){if("object"!=typeof e||null===e)return!1;const t=e;return!0===t.__buoyStateEvicted||!0===t.__buoyStateOnDevice}function getActionCategory(e){return e.startsWith("@@")?"internal":e.includes("/pending")?"pending":e.includes("/fulfilled")?"fulfilled":e.includes("/rejected")?"rejected":e.includes("/executeQuery")?"query":e.includes("/executeMutation")?"mutation":"action"}function parseActionType(e){if(e.startsWith("@@")){const t=e.split("/");return{sliceName:null,actionName:t[t.length-1]||e}}const t=e.split("/");if(t.length>=2){const e=t[0];let n=t[1];return t.length>=3&&["pending","fulfilled","rejected"].includes(t[t.length-1])&&(n=t.slice(1,-1).join("/")),{sliceName:e,actionName:n.toUpperCase()}}return{sliceName:null,actionName:e.toUpperCase()}}export function jsonLongerThan(e,t){return approxJsonSize(e,t).bytes>t}function formatPayloadPreview(e,t=40){if(void 0===e)return"";if(null===e)return"null";try{if("string"==typeof e)return e.length>t?`"${e.slice(0,t-3)}..."`:`"${e}"`;if("number"==typeof e||"boolean"==typeof e)return String(e);if(Array.isArray(e)){if(0===e.length)return"[]";if(jsonLongerThan(e,t))return`[${e.length} items]`;const n=JSON.stringify(e);return n.length>t?`[${e.length} items]`:n}if("object"==typeof e){const n=Object.keys(e);if(0===n.length)return"{}";if(jsonLongerThan(e,t))return`{ ${n.length} keys }`;const i=JSON.stringify(e);return i.length<=t?i:`{ ${n.length} keys }`}return String(e).slice(0,t)}catch{return"[complex]"}}function getStateDiffSummary(e,t){if(e===t)return{summary:"no change",changedCount:0};if("object"!=typeof e||"object"!=typeof t||null===e||null===t)return{summary:"changed",changedCount:1};const n=Object.keys(e),i=Object.keys(t),r=i.filter(e=>!n.includes(e)).length,a=n.filter(e=>!i.includes(e)).length;let o=0;for(const r of n)i.includes(r)&&e[r]!==t[r]&&o++;const s=[];r>0&&s.push(`+${r}`),a>0&&s.push(`-${a}`),o>0&&s.push(`~${o}`);const c=r+a+o;return 0===s.length?{summary:"nested change",changedCount:1}:{summary:`${s.join(" ")} ${1===c?"key":"keys"}`,changedCount:c}}function extractMeta(e){const t=e.meta;if(t)return{requestId:t.requestId,requestStatus:t.requestStatus,arg:t.arg,rejectedWithValue:t.rejectedWithValue,aborted:t.aborted,condition:t.condition}}class ReduxActionStore extends ChangeLog{addAction(e,t,n,i){if(!this.canRecord())return;const r=e.type||"";if(!r)return;const a=t!==n,o=getActionCategory(r),{sliceName:s,actionName:c}=parseActionType(r),u=extractMeta(e),l=formatPayloadPreview(e.payload),{summary:d,changedCount:h}=getStateDiffSummary(t,n),g=(i??0)>16,y={id:this.nextId(),type:r,payload:e.payload,action:e,timestamp:Date.now(),prevState:t,nextState:n,duration:i,hasStateChange:a,category:o,sliceName:s,actionName:c,meta:u,error:e.error,payloadPreview:l,diffSummary:d,changedKeysCount:h,isSlowAction:g};this.push(y);for(let e=25;e<this.items.length;e++){const t=this.items[e];if(t.prevState===STATE_EVICTED)break;t.prevState=STATE_EVICTED,t.nextState=STATE_EVICTED}this.notifyListeners()}getActions(){return this.getAll()}getActionById(e){return this.getById(e)}clearActions(){this.clear()}replaceActions(e){if(!this.getEnabled())return;const t=new Map;for(const e of this.items)void 0===e.prevState||isEvictedState(e.prevState)||t.set(e.id,e);const n=e.slice(0,this.max).map(e=>{const n=t.get(e.id);return n&&isEvictedState(e.prevState)?{...e,prevState:n.prevState,nextState:n.nextState,payload:isPayloadOnDevice(e.payload)?n.payload:e.payload,action:isPayloadOnDevice(e.action)?n.action:e.action,meta:isPayloadOnDevice(e.meta?.arg)?n.meta:e.meta,error:isPayloadOnDevice(e.error)?n.error:e.error}:e});this.setItems(n)}hydrateAction(e,t){this.hydrateById(e,t)}setMaxActions(e){this.setMax(e)}getStats(){const e=this.items.length,t=this.items.filter(e=>e.hasStateChange).length,n=new Set(this.items.map(e=>e.type)),i=this.items.filter(e=>void 0!==e.duration).map(e=>e.duration),r=i.length>0?i.reduce((e,t)=>e+t,0)/i.length:0;return{totalActions:e,actionsWithChanges:t,actionsWithoutChanges:e-t,uniqueActionTypes:n.size,averageDuration:Math.round(100*r)/100}}filterActions(e){let t=[...this.items];if(e.searchText){const n=e.searchText.toLowerCase();t=t.filter(e=>e.type.toLowerCase().includes(n))}return e.actionTypes&&e.actionTypes.length>0&&(t=t.filter(t=>e.actionTypes.includes(t.type))),e.onlyWithChanges&&(t=t.filter(e=>e.hasStateChange)),t}getUniqueActionTypes(){return Array.from(new Set(this.items.map(e=>e.type))).sort()}getRelatedActions(e){return this.items.filter(t=>t.meta?.requestId===e).sort((e,t)=>e.timestamp-t.timestamp)}getLinkedActions(e){return e.meta?.requestId?this.getRelatedActions(e.meta.requestId):[]}getLinkedActionsCount(e){return e.meta?.requestId?this.items.filter(t=>t.meta?.requestId===e.meta?.requestId).length:0}getAsyncOperationDuration(e){const t=this.getRelatedActions(e);if(t.length<2)return null;const n=t.find(e=>"pending"===e.category),i=t.find(e=>"fulfilled"===e.category||"rejected"===e.category);return n&&i?i.timestamp-n.timestamp:null}getBaseActionType(e){const t=e.split("/");if(t.length>=2){const e=t[t.length-1];if(["pending","fulfilled","rejected"].includes(e))return t.slice(0,-1).join("/")}return e}getAsyncOperationIndex(e){const t=new Map;for(const e of this.items)e.meta?.requestId&&!t.has(e.meta.requestId)&&t.set(e.meta.requestId,e.timestamp);const n=Array.from(t.entries()).sort((e,t)=>e[1]-t[1]).map(([e])=>e).indexOf(e);return n>=0?n+1:0}}export const reduxActionStore=new ReduxActionStore;
+"use strict";
+
+/**
+ * Redux action store - captures and stores Redux Toolkit actions
+ */
+
+import { ChangeLog, approxJsonSize } from "@buoy-gg/shared-ui";
+/**
+ * How many of the most-recent actions keep their raw prevState/nextState
+ * trees. Older actions keep all diff metadata but their trees are replaced
+ * with STATE_EVICTED so a store switch can't pin hundreds of MB.
+ */
+export const STATE_RETENTION_LIMIT = 25;
+
+/**
+ * Sentinel installed in place of evicted state trees. A frozen plain object
+ * so existing detail viewers render it harmlessly; jumpToState refuses it.
+ */
+export const STATE_EVICTED = Object.freeze({
+  __buoyStateEvicted: true,
+  note: `Raw state retained for the ${STATE_RETENTION_LIMIT} most recent actions only.`
+});
+
+/**
+ * Sentinel used in WIRE-FORM snapshots (sync to desktop/MCP) in place of raw
+ * prevState/nextState trees. Unlike STATE_EVICTED the trees still exist on
+ * the device — dashboards fetch them on demand via the adapter's
+ * `getActionDetail` action. Shipping them in every snapshot serialized up to
+ * 25×2 full state trees through socket.emit per action (no guard), which
+ * froze and native-OOM-crashed enterprise-scale apps whenever a dashboard
+ * was connected (confirmed by patch-and-retest on the affected app).
+ */
+export const STATE_ON_DEVICE = Object.freeze({
+  __buoyStateOnDevice: true,
+  note: "State trees stay on the device — fetched on demand via getActionDetail."
+});
+
+/**
+ * Wire-form sentinel for an oversized action `payload`/`action`. A dispatched
+ * payload can itself be huge (rehydration actions carry the whole new state),
+ * so the per-snapshot stream ships `payloadPreview` + this marker instead;
+ * `getActionDetail` serves the real value on demand.
+ */
+export const PAYLOAD_ON_DEVICE = Object.freeze({
+  __buoyPayloadOnDevice: true,
+  note: "Payload stays on the device — fetched on demand via getActionDetail."
+});
+
+/** True when a wire-form value is the payload-on-device sentinel. */
+export function isPayloadOnDevice(value) {
+  return typeof value === "object" && value !== null && value.__buoyPayloadOnDevice === true;
+}
+
+/**
+ * True when a value is one of the state sentinels (evicted or on-device) —
+ * guards time travel and any consumer that needs a REAL tree.
+ */
+export function isEvictedState(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v.__buoyStateEvicted === true || v.__buoyStateOnDevice === true;
+}
+
+// ============================================
+// Helper Functions for Enhanced Data
+// ============================================
+
+/**
+ * Get action category from type string
+ */
+function getActionCategory(type) {
+  if (type.startsWith("@@")) return "internal";
+  if (type.includes("/pending")) return "pending";
+  if (type.includes("/fulfilled")) return "fulfilled";
+  if (type.includes("/rejected")) return "rejected";
+  if (type.includes("/executeQuery")) return "query";
+  if (type.includes("/executeMutation")) return "mutation";
+  return "action";
+}
+
+/**
+ * Parse action type to extract slice and action names
+ */
+function parseActionType(type) {
+  // Handle internal actions
+  if (type.startsWith("@@")) {
+    const parts = type.split("/");
+    return {
+      sliceName: null,
+      actionName: parts[parts.length - 1] || type
+    };
+  }
+
+  // Handle RTK pattern: "sliceName/actionName" or "sliceName/actionName/status"
+  const parts = type.split("/");
+  if (parts.length >= 2) {
+    const sliceName = parts[0];
+    // For async thunks, action name might be "fetchUser/pending" -> we want "fetchUser"
+    let actionName = parts[1];
+
+    // If it's an async status, use the base action name
+    if (parts.length >= 3 && ["pending", "fulfilled", "rejected"].includes(parts[parts.length - 1])) {
+      actionName = parts.slice(1, -1).join("/");
+    }
+    return {
+      sliceName,
+      actionName: actionName.toUpperCase()
+    };
+  }
+  return {
+    sliceName: null,
+    actionName: type.toUpperCase()
+  };
+}
+
+/**
+ * Cheap early-abort size probe: is `value`'s JSON form definitely longer than
+ * `limit`? Bails the moment the running estimate exceeds the limit, so the
+ * cost is O(limit) — never O(payload). Used to avoid JSON.stringify-ing large
+ * payloads (a fulfilled thunk's payload can be megabytes) just to produce a
+ * 40-char preview; that full stringify ran on EVERY dispatch and blocked the
+ * JS thread at enterprise state sizes.
+ */
+export function jsonLongerThan(value, limit) {
+  return approxJsonSize(value, limit).bytes > limit;
+}
+
+/**
+ * Format payload preview for display
+ */
+function formatPayloadPreview(payload, maxLength = 40) {
+  if (payload === undefined) return "";
+  if (payload === null) return "null";
+  try {
+    if (typeof payload === "string") {
+      return payload.length > maxLength ? `"${payload.slice(0, maxLength - 3)}..."` : `"${payload}"`;
+    }
+    if (typeof payload === "number" || typeof payload === "boolean") {
+      return String(payload);
+    }
+    if (Array.isArray(payload)) {
+      if (payload.length === 0) return "[]";
+      // Probe cheaply first — only stringify payloads that can actually fit.
+      if (jsonLongerThan(payload, maxLength)) return `[${payload.length} items]`;
+      const preview = JSON.stringify(payload);
+      return preview.length > maxLength ? `[${payload.length} items]` : preview;
+    }
+    if (typeof payload === "object") {
+      const keys = Object.keys(payload);
+      if (keys.length === 0) return "{}";
+
+      // Probe cheaply first — only stringify payloads that can actually fit.
+      if (jsonLongerThan(payload, maxLength)) return `{ ${keys.length} keys }`;
+      const preview = JSON.stringify(payload);
+      if (preview.length <= maxLength) return preview;
+
+      // Show key count
+      return `{ ${keys.length} keys }`;
+    }
+    return String(payload).slice(0, maxLength);
+  } catch {
+    return "[complex]";
+  }
+}
+
+/**
+ * Calculate state diff summary
+ */
+function getStateDiffSummary(prevState, nextState) {
+  if (prevState === nextState) {
+    return {
+      summary: "no change",
+      changedCount: 0
+    };
+  }
+
+  // Handle non-objects
+  if (typeof prevState !== "object" || typeof nextState !== "object" || prevState === null || nextState === null) {
+    return {
+      summary: "changed",
+      changedCount: 1
+    };
+  }
+  const prevKeys = Object.keys(prevState);
+  const nextKeys = Object.keys(nextState);
+  const added = nextKeys.filter(k => !prevKeys.includes(k)).length;
+  const removed = prevKeys.filter(k => !nextKeys.includes(k)).length;
+
+  // Check which existing keys changed
+  let changed = 0;
+  for (const key of prevKeys) {
+    if (nextKeys.includes(key) && prevState[key] !== nextState[key]) {
+      changed++;
+    }
+  }
+  const parts = [];
+  if (added > 0) parts.push(`+${added}`);
+  if (removed > 0) parts.push(`-${removed}`);
+  if (changed > 0) parts.push(`~${changed}`);
+  const totalChanged = added + removed + changed;
+  if (parts.length === 0) {
+    return {
+      summary: "nested change",
+      changedCount: 1
+    };
+  }
+  return {
+    summary: `${parts.join(" ")} ${totalChanged === 1 ? "key" : "keys"}`,
+    changedCount: totalChanged
+  };
+}
+
+/**
+ * Extract RTK async thunk metadata
+ */
+function extractMeta(action) {
+  const meta = action.meta;
+  if (!meta) return undefined;
+  return {
+    requestId: meta.requestId,
+    requestStatus: meta.requestStatus,
+    arg: meta.arg,
+    rejectedWithValue: meta.rejectedWithValue,
+    aborted: meta.aborted,
+    condition: meta.condition
+  };
+}
+
+// ============================================
+// Redux Action Store
+// ============================================
+
+class ReduxActionStore extends ChangeLog {
+  addAction(action, prevState, nextState, duration) {
+    if (!this.canRecord()) {
+      return;
+    }
+    const actionType = action.type || "";
+
+    // Skip actions without a proper type (e.g., thunk functions)
+    if (!actionType) {
+      return;
+    }
+    const hasStateChange = prevState !== nextState;
+
+    // Enhanced data extraction
+    const category = getActionCategory(actionType);
+    const {
+      sliceName,
+      actionName
+    } = parseActionType(actionType);
+    const meta = extractMeta(action);
+    const payloadPreview = formatPayloadPreview(action.payload);
+    const {
+      summary: diffSummary,
+      changedCount: changedKeysCount
+    } = getStateDiffSummary(prevState, nextState);
+    const isSlowAction = (duration ?? 0) > 16; // Frame budget
+
+    const reduxAction = {
+      id: this.nextId(),
+      type: actionType,
+      payload: action.payload,
+      action,
+      timestamp: Date.now(),
+      prevState,
+      nextState,
+      duration,
+      hasStateChange,
+      // Enhanced fields
+      category,
+      sliceName,
+      actionName,
+      meta,
+      error: action.error,
+      payloadPreview,
+      diffSummary,
+      changedKeysCount,
+      isSlowAction
+    };
+    this.push(reduxAction);
+
+    // Bound raw-state retention. Every action holds prevState/nextState by
+    // reference; with structural sharing that's normally cheap, but when a
+    // host replaces large slices wholesale (store switch / rehydration),
+    // each retained action pins a DISTINCT multi-MB subtree — measured 88MB
+    // pinned by 50 slice-replacing actions, enough to OOM-kill enterprise
+    // apps. Detail view + time travel realistically use recent actions, so
+    // older ones keep their diff metadata but drop the raw trees.
+    for (let i = STATE_RETENTION_LIMIT; i < this.items.length; i++) {
+      const a = this.items[i];
+      if (a.prevState !== STATE_EVICTED) {
+        a.prevState = STATE_EVICTED;
+        a.nextState = STATE_EVICTED;
+      } else {
+        break; // older entries already evicted (list is newest-first)
+      }
+    }
+    this.notifyListeners();
+  }
+  getActions() {
+    return this.getAll();
+  }
+  getActionById(id) {
+    return this.getById(id);
+  }
+  clearActions() {
+    this.clear();
+  }
+
+  // ============================================
+  // Remote Mirror Mode
+  // ============================================
+
+  /**
+   * Replace the entire action list and notify listeners. Used in remote
+   * mirror mode where full snapshots arrive from a synced device. Respects
+   * the enabled flag so the UI's pause button freezes the mirror.
+   */
+  replaceActions(actions) {
+    if (!this.getEnabled()) {
+      return;
+    }
+    // Preserve any trees a remote mirror already hydrated via
+    // replaceActionStates — wire-form snapshots always carry markers, and a
+    // full snapshot arriving after a detail fetch must not blank the detail
+    // pane back out.
+    const hydrated = new Map();
+    for (const existing of this.items) {
+      if (existing.prevState !== undefined && !isEvictedState(existing.prevState)) {
+        hydrated.set(existing.id, existing);
+      }
+    }
+    const merged = actions.slice(0, this.max).map(a => {
+      const h = hydrated.get(a.id);
+      if (!h || !isEvictedState(a.prevState)) return a;
+      return {
+        ...a,
+        prevState: h.prevState,
+        nextState: h.nextState,
+        payload: isPayloadOnDevice(a.payload) ? h.payload : a.payload,
+        action: isPayloadOnDevice(a.action) ? h.action : a.action,
+        meta: isPayloadOnDevice(a.meta?.arg) ? h.meta : a.meta,
+        error: isPayloadOnDevice(a.error) ? h.error : a.error
+      };
+    });
+    this.setItems(merged);
+  }
+
+  /**
+   * Hydrate one mirrored action with real values (state trees, payload,
+   * action) fetched on demand from the device via the adapter's
+   * `getActionDetail` action. Remote-mirror (desktop) use only.
+   */
+  hydrateAction(id, patch) {
+    this.hydrateById(id, patch);
+  }
+  setMaxActions(max) {
+    this.setMax(max);
+  }
+  getStats() {
+    const total = this.items.length;
+    const withChanges = this.items.filter(a => a.hasStateChange).length;
+    const actionTypes = new Set(this.items.map(a => a.type));
+
+    // Calculate average duration
+    const durations = this.items.filter(a => a.duration !== undefined).map(a => a.duration);
+    const avgDuration = durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;
+    return {
+      totalActions: total,
+      actionsWithChanges: withChanges,
+      actionsWithoutChanges: total - withChanges,
+      uniqueActionTypes: actionTypes.size,
+      averageDuration: Math.round(avgDuration * 100) / 100
+    };
+  }
+  filterActions(filter) {
+    let filtered = [...this.items];
+    if (filter.searchText) {
+      const search = filter.searchText.toLowerCase();
+      filtered = filtered.filter(a => a.type.toLowerCase().includes(search));
+    }
+    if (filter.actionTypes && filter.actionTypes.length > 0) {
+      filtered = filtered.filter(a => filter.actionTypes.includes(a.type));
+    }
+    if (filter.onlyWithChanges) {
+      filtered = filtered.filter(a => a.hasStateChange);
+    }
+    return filtered;
+  }
+  getUniqueActionTypes() {
+    return Array.from(new Set(this.items.map(a => a.type))).sort();
+  }
+
+  /**
+   * Find related async actions by requestId
+   */
+  getRelatedActions(requestId) {
+    return this.items.filter(a => a.meta?.requestId === requestId).sort((a, b) => a.timestamp - b.timestamp); // Sort chronologically
+  }
+
+  /**
+   * Get all actions that share a requestId with the given action
+   */
+  getLinkedActions(action) {
+    if (!action.meta?.requestId) return [];
+    return this.getRelatedActions(action.meta.requestId);
+  }
+
+  /**
+   * Get count of linked actions for a given action
+   */
+  getLinkedActionsCount(action) {
+    if (!action.meta?.requestId) return 0;
+    return this.items.filter(a => a.meta?.requestId === action.meta?.requestId).length;
+  }
+
+  /**
+   * Calculate total duration for an async operation (pending to resolution)
+   */
+  getAsyncOperationDuration(requestId) {
+    const related = this.getRelatedActions(requestId);
+    if (related.length < 2) return null;
+    const pending = related.find(a => a.category === "pending");
+    const resolution = related.find(a => a.category === "fulfilled" || a.category === "rejected");
+    if (pending && resolution) {
+      return resolution.timestamp - pending.timestamp;
+    }
+    return null;
+  }
+
+  /**
+   * Get the base action type (without /pending, /fulfilled, /rejected suffix)
+   */
+  getBaseActionType(type) {
+    const parts = type.split("/");
+    if (parts.length >= 2) {
+      const lastPart = parts[parts.length - 1];
+      if (["pending", "fulfilled", "rejected"].includes(lastPart)) {
+        return parts.slice(0, -1).join("/");
+      }
+    }
+    return type;
+  }
+
+  /**
+   * Get sequential index for an async operation (1, 2, 3, etc.)
+   * Based on order of when pending actions first appeared
+   */
+  getAsyncOperationIndex(requestId) {
+    // Get all unique requestIds with their first timestamp
+    const requestIdTimestamps = new Map();
+    for (const action of this.items) {
+      if (action.meta?.requestId && !requestIdTimestamps.has(action.meta.requestId)) {
+        requestIdTimestamps.set(action.meta.requestId, action.timestamp);
+      }
+    }
+
+    // Sort by timestamp (oldest first) and find index
+    const sortedIds = Array.from(requestIdTimestamps.entries()).sort((a, b) => a[1] - b[1]).map(([id]) => id);
+    const index = sortedIds.indexOf(requestId);
+    return index >= 0 ? index + 1 : 0;
+  }
+}
+export const reduxActionStore = new ReduxActionStore();

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

@@ -1 +1,157 @@
-"use strict";import{classifyPreviewItem,createRestoreScope,registerStateSnapshotProvider,skippedRestore,unionKeys,wontApply}from"@buoy-gg/shared-ui";import{getActiveStore,getInstrumentationStatus}from"./activeStoreRegistry";import{BUOY_JUMP_TO_STATE}from"./buoyReduxMiddleware";const ENABLE_HINT="enable restore by using the Buoy enhancer or wrapping your root reducer in withBuoyDevTools()";function status(){const{mechanism:e,hasStore:t,diagnostic:r}=getInstrumentationStatus();return t?"patch"===e?{canCapture:!0,canRestore:!1,detail:`Auto-instrumented store cannot be restored — ${ENABLE_HINT}`}:{canCapture:!0,canRestore:!0,detail:"middleware"===e?"Restore requires withBuoyDevTools(rootReducer) — verified at restore time":void 0}:{canCapture:!1,canRestore:!1,detail:"no-react-redux"===r?"react-redux not installed":"no-provider"===r?"No Redux <Provider> found":"No Redux store instrumented"}}async function capture(){const e=getActiveStore();return e?{data:{state:e.getState()},warnings:[]}:{data:null,warnings:["no Redux store instrumented"]}}async function restore(e,t){const r=e,o=getActiveStore();if(!o||null==r)return skippedRestore("redux",o?"empty redux snapshot":"no Redux store instrumented");const{mechanism:s}=getInstrumentationStatus();if("patch"===s)return skippedRestore("redux",`restore unavailable on auto-instrumented stores — ${ENABLE_HINT}`);const n=createRestoreScope(t),a=Object.keys(r.state??{}).filter(e=>!n.touch(e));let i=r.state;if(a.length>0){const e=o.getState(),t={...r.state};for(const r of a)t[r]=e?.[r];i=t}return o.dispatch({type:BUOY_JUMP_TO_STATE,payload:i}),o.getState()===i?{ok:!0,applied:1,skipped:[],warnings:a.length>0?[`${a.length} slice(s) excluded by you`]:[]}:skippedRestore("redux",`store ignored the state jump — ${ENABLE_HINT}`)}async function previewItems(e,t){const r=e?.state,o=void 0===t,s=getActiveStore(),n=o?s?.getState():t?.state,a=[],i=[];let u;if(o){const{mechanism:e,hasStore:t}=getInstrumentationStatus();t?"patch"===e&&(u=`auto-instrumented store cannot be restored — ${ENABLE_HINT}`):u="no Redux store instrumented"}const c=n??{},d=r??{};for(const e of unionKeys(c,d)){let t=classifyPreviewItem({key:e,label:e,oldValue:c[e],newValue:d[e],inOld:Object.prototype.hasOwnProperty.call(c,e),inNew:Object.prototype.hasOwnProperty.call(d,e)},{tooLargeReason:"slice too large to render a diff — restore still applies it"});u&&(t=wontApply(t,u)),a.push(t)}return u&&i.push(`Redux restore unavailable: ${u}`),{items:a,notes:i}}registerStateSnapshotProvider({id:"redux",label:"Redux",status:status,capture:capture,restore:restore,previewItems:previewItems});
+"use strict";
+
+/**
+ * Time Machine snapshot provider for Redux.
+ *
+ * Registered into @buoy-gg/shared-ui's stateSnapshotRegistry at module init;
+ * consumed by @buoy-gg/time-machine.
+ *
+ * Restore rides the existing `@@buoy/JUMP_TO_STATE` full-state-replace action:
+ * - enhancer path: always handled (wrapReducer).
+ * - middleware path: handled ONLY when the app wrapped its root reducer in
+ *   `withBuoyDevTools()` — unverifiable statically, so restore verifies by
+ *   reference identity after dispatch (the wrapped reducer returns the payload
+ *   object itself).
+ * - patch path: never handled; restore is reported as unavailable up front.
+ */
+import { classifyPreviewItem, createRestoreScope, registerStateSnapshotProvider, skippedRestore, unionKeys, wontApply } from "@buoy-gg/shared-ui";
+import { getActiveStore, getInstrumentationStatus } from "./activeStoreRegistry";
+import { BUOY_JUMP_TO_STATE } from "./buoyReduxMiddleware";
+const ENABLE_HINT = "enable restore by using the Buoy enhancer or wrapping your root reducer in withBuoyDevTools()";
+function status() {
+  const {
+    mechanism,
+    hasStore,
+    diagnostic
+  } = getInstrumentationStatus();
+  if (!hasStore) {
+    return {
+      canCapture: false,
+      canRestore: false,
+      detail: diagnostic === "no-react-redux" ? "react-redux not installed" : diagnostic === "no-provider" ? "No Redux <Provider> found" : "No Redux store instrumented"
+    };
+  }
+  if (mechanism === "patch") {
+    return {
+      canCapture: true,
+      canRestore: false,
+      detail: `Auto-instrumented store cannot be restored — ${ENABLE_HINT}`
+    };
+  }
+  return {
+    canCapture: true,
+    canRestore: true,
+    detail: mechanism === "middleware" ? "Restore requires withBuoyDevTools(rootReducer) — verified at restore time" : undefined
+  };
+}
+async function capture() {
+  const store = getActiveStore();
+  if (!store) {
+    return {
+      data: null,
+      warnings: ["no Redux store instrumented"]
+    };
+  }
+  return {
+    data: {
+      state: store.getState()
+    },
+    warnings: []
+  };
+}
+async function restore(data, options) {
+  const snapshot = data;
+  const store = getActiveStore();
+  if (!store || snapshot === undefined || snapshot === null) {
+    return skippedRestore("redux", store ? "empty redux snapshot" : "no Redux store instrumented");
+  }
+  const {
+    mechanism
+  } = getInstrumentationStatus();
+  if (mechanism === "patch") {
+    return skippedRestore("redux", `restore unavailable on auto-instrumented stores — ${ENABLE_HINT}`);
+  }
+  // Untouched slices keep their LIVE values inside the jump payload, so the
+  // full-state replace leaves them alone. A slice is untouched when it's
+  // explicitly excluded OR outside the includeKeys scope.
+  const scope = createRestoreScope(options);
+  const excluded = Object.keys(snapshot.state ?? {}).filter(k => !scope.touch(k));
+  let payload = snapshot.state;
+  if (excluded.length > 0) {
+    const live = store.getState();
+    const merged = {
+      ...snapshot.state
+    };
+    for (const slice of excluded) merged[slice] = live?.[slice];
+    payload = merged;
+  }
+  store.dispatch({
+    type: BUOY_JUMP_TO_STATE,
+    payload
+  });
+  // The wrapped reducer returns the payload object itself, so reference
+  // identity proves the jump was actually handled (and not silently ignored
+  // by an unwrapped middleware-path reducer).
+  if (store.getState() === payload) {
+    const warnings = excluded.length > 0 ? [`${excluded.length} slice(s) excluded by you`] : [];
+    return {
+      ok: true,
+      applied: 1,
+      skipped: [],
+      warnings
+    };
+  }
+  return skippedRestore("redux", `store ignored the state jump — ${ENABLE_HINT}`);
+}
+
+/** Per-slice restore preview. `base` omitted = compare against the live store. */
+async function previewItems(target, base) {
+  const targetState = target?.state;
+  const liveMode = base === undefined;
+  const store = getActiveStore();
+  const baseState = liveMode ? store?.getState() : base?.state;
+  const items = [];
+  const notes = [];
+
+  // Restore-capability gate — a diff restore can't apply must say so, not
+  // render as a green change.
+  let wontApplyReason;
+  if (liveMode) {
+    const {
+      mechanism,
+      hasStore
+    } = getInstrumentationStatus();
+    if (!hasStore) wontApplyReason = "no Redux store instrumented";else if (mechanism === "patch") {
+      wontApplyReason = `auto-instrumented store cannot be restored — ${ENABLE_HINT}`;
+    }
+  }
+  const oldObj = baseState ?? {};
+  const newObj = targetState ?? {};
+  for (const key of unionKeys(oldObj, newObj)) {
+    let item = classifyPreviewItem({
+      key,
+      label: key,
+      oldValue: oldObj[key],
+      newValue: newObj[key],
+      inOld: Object.prototype.hasOwnProperty.call(oldObj, key),
+      inNew: Object.prototype.hasOwnProperty.call(newObj, key)
+    }, {
+      tooLargeReason: "slice too large to render a diff — restore still applies it"
+    });
+    if (wontApplyReason) item = wontApply(item, wontApplyReason);
+    items.push(item);
+  }
+  if (wontApplyReason) notes.push(`Redux restore unavailable: ${wontApplyReason}`);
+  return {
+    items,
+    notes
+  };
+}
+registerStateSnapshotProvider({
+  id: "redux",
+  label: "Redux",
+  status,
+  capture,
+  restore,
+  previewItems
+});