fix(tables): scope layout undo to the view that recorded it

Layout is view-owned, but UndoEntry carried no owner, so the persistence
sink — rebound every render to the active view — decided the target at undo
time rather than at record time. Reordering in view A then undoing from view
B wrote A's column order into B and left A unchanged.

Entries are now stamped with the active view id, and the three layout-bearing
action types (create-column, delete-column, reorder-columns) are pruned from
both stacks when the active view changes. Row and schema actions are
table-scoped and survive the switch untouched. Inert when views are disabled:
the id is always null, so nothing is ever pruned.

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -730,6 +730,7 @@ export function TableGrid({
     getPinnedColumns,
     getColumnWidths,
     onPersistLayout,
+    activeViewId: viewLayoutKey,
   })
   const undoRef = useRef(undo)
   undoRef.current = undo

apps/sim/hooks/use-table-undo.test.ts

@@ -41,6 +41,7 @@ const mockPush = vi.fn()
 const mockPatchRedoRowId = vi.fn()
 const mockPatchUndoRowId = vi.fn()
 const mockClear = vi.fn()
+const mockPruneLayoutActions = vi.fn()
 
 const storeState = {
   stacks: {},
@@ -50,6 +51,7 @@ const storeState = {
   patchRedoRowId: mockPatchRedoRowId,
   patchUndoRowId: mockPatchUndoRowId,
   clear: mockClear,
+  pruneLayoutActions: mockPruneLayoutActions,
 }
 
 vi.mock('@/stores/table/store', () => ({

apps/sim/hooks/use-table-undo.ts

@@ -110,6 +110,13 @@ interface UseTableUndoProps {
    * reorder was stored rather than silently rewriting the "All" layout.
    */
   onPersistLayout?: (patch: TableMetadata) => void
+  /**
+   * Active view id (`null` for "All" or when views are disabled). Layout is
+   * view-owned, so recorded layout actions are stamped with it and dropped when
+   * the user switches away — otherwise an undo would write the outgoing view's
+   * column order into whichever view happens to be active at the time.
+   */
+  activeViewId?: string | null
 }
 
 export function useTableUndo({
@@ -123,13 +130,15 @@ export function useTableUndo({
   getPinnedColumns,
   getColumnWidths,
   onPersistLayout,
+  activeViewId = null,
 }: UseTableUndoProps) {
   const push = useTableUndoStore((s) => s.push)
   const popUndo = useTableUndoStore((s) => s.popUndo)
   const popRedo = useTableUndoStore((s) => s.popRedo)
   const patchRedoRowId = useTableUndoStore((s) => s.patchRedoRowId)
   const patchUndoRowId = useTableUndoStore((s) => s.patchUndoRowId)
   const clear = useTableUndoStore((s) => s.clear)
+  const pruneLayoutActions = useTableUndoStore((s) => s.pruneLayoutActions)
   const canUndo = useTableUndoStore((s) => (s.stacks[tableId]?.undo.length ?? 0) > 0)
   const canRedo = useTableUndoStore((s) => (s.stacks[tableId]?.redo.length ?? 0) > 0)
 
@@ -161,14 +170,20 @@ export function useTableUndo({
   getColumnWidthsRef.current = getColumnWidths
   const getLocksRef = useRef(getLocks)
   getLocksRef.current = getLocks
+  const activeViewIdRef = useRef(activeViewId)
+  activeViewIdRef.current = activeViewId
 
   useEffect(() => {
     return () => clear(tableId)
   }, [clear, tableId])
 
+  useEffect(() => {
+    pruneLayoutActions(tableId, activeViewId)
+  }, [pruneLayoutActions, tableId, activeViewId])
+
   const pushUndo = useCallback(
     (action: TableUndoAction) => {
-      push(tableId, action)
+      push(tableId, action, activeViewIdRef.current)
     },
     [push, tableId]
   )

apps/sim/stores/table/store.test.ts

@@ -0,0 +1,75 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it } from 'vitest'
+import { useTableUndoStore } from '@/stores/table/store'
+import type { TableUndoAction } from '@/stores/table/types'
+
+const TABLE = 'tbl-1'
+
+const reorder: TableUndoAction = {
+  type: 'reorder-columns',
+  previousOrder: ['a', 'b'],
+  newOrder: ['b', 'a'],
+}
+const updateCell: TableUndoAction = {
+  type: 'update-cell',
+  rowId: 'r1',
+  columnName: 'a',
+  previousValue: 1,
+  newValue: 2,
+}
+
+describe('pruneLayoutActions', () => {
+  beforeEach(() => {
+    useTableUndoStore.getState().clear(TABLE)
+  })
+
+  it('drops a layout action recorded under a different view', () => {
+    const store = useTableUndoStore.getState()
+    store.push(TABLE, reorder, 'view-a')
+
+    store.pruneLayoutActions(TABLE, 'view-b')
+
+    expect(useTableUndoStore.getState().stacks[TABLE]?.undo).toHaveLength(0)
+  })
+
+  it('keeps a layout action when the owning view is still active', () => {
+    const store = useTableUndoStore.getState()
+    store.push(TABLE, reorder, 'view-a')
+
+    store.pruneLayoutActions(TABLE, 'view-a')
+
+    expect(useTableUndoStore.getState().stacks[TABLE]?.undo).toHaveLength(1)
+  })
+
+  it('keeps row actions across a view switch — rows are table-scoped', () => {
+    const store = useTableUndoStore.getState()
+    store.push(TABLE, updateCell, 'view-a')
+
+    store.pruneLayoutActions(TABLE, 'view-b')
+
+    const undo = useTableUndoStore.getState().stacks[TABLE]?.undo
+    expect(undo).toHaveLength(1)
+    expect(undo?.[0].action.type).toBe('update-cell')
+  })
+
+  it('prunes the redo stack too, so redo cannot replay into the wrong view', () => {
+    const store = useTableUndoStore.getState()
+    store.push(TABLE, reorder, 'view-a')
+    store.popUndo(TABLE)
+    expect(useTableUndoStore.getState().stacks[TABLE]?.redo).toHaveLength(1)
+
+    store.pruneLayoutActions(TABLE, 'view-b')
+
+    expect(useTableUndoStore.getState().stacks[TABLE]?.redo).toHaveLength(0)
+  })
+
+  it('treats All (null) as its own owner', () => {
+    const store = useTableUndoStore.getState()
+    store.push(TABLE, reorder, null)
+
+    store.pruneLayoutActions(TABLE, 'view-a')
+    expect(useTableUndoStore.getState().stacks[TABLE]?.undo).toHaveLength(0)
+  })
+})

apps/sim/stores/table/store.ts

@@ -7,6 +7,7 @@ import { generateShortId } from '@sim/utils/id'
 import { create } from 'zustand'
 import { devtools } from 'zustand/middleware'
 import type { TableUndoAction, TableUndoStacks, TableUndoState, UndoEntry } from './types'
+import { LAYOUT_UNDO_ACTIONS } from './types'
 
 const STACK_CAPACITY = 100
 const EMPTY_STACKS: TableUndoStacks = { undo: [], redo: [] }
@@ -99,10 +100,15 @@ export const useTableUndoStore = create<TableUndoState>()(
     (set, get) => ({
       stacks: {},
 
-      push: (tableId: string, action: TableUndoAction) => {
+      push: (tableId: string, action: TableUndoAction, viewId: string | null) => {
         if (undoRedoInProgress) return
 
-        const entry: UndoEntry = { id: generateShortId(), action, timestamp: Date.now() }
+        const entry: UndoEntry = {
+          id: generateShortId(),
+          action,
+          timestamp: Date.now(),
+          viewId,
+        }
 
         set((state) => {
           const current = state.stacks[tableId] ?? EMPTY_STACKS
@@ -182,6 +188,17 @@ export const useTableUndoStore = create<TableUndoState>()(
         })
       },
 
+      pruneLayoutActions: (tableId: string, viewId: string | null) => {
+        const current = get().stacks[tableId]
+        if (!current) return
+        const owned = (entry: UndoEntry) =>
+          !LAYOUT_UNDO_ACTIONS.has(entry.action.type) || entry.viewId === viewId
+        const undo = current.undo.filter(owned)
+        const redo = current.redo.filter(owned)
+        if (undo.length === current.undo.length && redo.length === current.redo.length) return
+        set((state) => ({ stacks: { ...state.stacks, [tableId]: { undo, redo } } }))
+      },
+
       clear: (tableId: string) => {
         set((state) => {
           const { [tableId]: _, ...rest } = state.stacks

apps/sim/stores/table/types.ts

@@ -87,19 +87,41 @@ export interface UndoEntry {
   id: string
   action: TableUndoAction
   timestamp: number
+  /**
+   * Active view when the action was recorded — `null` for "All" or when views
+   * are disabled. Layout is view-owned, so a layout action is only meaningful
+   * against the view that owned it; see {@link LAYOUT_UNDO_ACTIONS}.
+   */
+  viewId: string | null
 }
 
+/**
+ * Action types whose undo writes column layout (order, widths, pinning). These
+ * are scoped to the view that was active when they were recorded; every other
+ * action type operates on rows or the schema and is table-scoped.
+ */
+export const LAYOUT_UNDO_ACTIONS = new Set<TableUndoAction['type']>([
+  'create-column',
+  'delete-column',
+  'reorder-columns',
+])
+
 export interface TableUndoStacks {
   undo: UndoEntry[]
   redo: UndoEntry[]
 }
 
 export interface TableUndoState {
   stacks: Record<string, TableUndoStacks>
-  push: (tableId: string, action: TableUndoAction) => void
+  push: (tableId: string, action: TableUndoAction, viewId: string | null) => void
   popUndo: (tableId: string) => UndoEntry | null
   popRedo: (tableId: string) => UndoEntry | null
   patchRedoRowId: (tableId: string, oldRowId: string, newRowId: string) => void
   patchUndoRowId: (tableId: string, oldRowId: string, newRowId: string) => void
   clear: (tableId: string) => void
+  /**
+   * Drops layout actions recorded under a different view. Called on every view
+   * switch so undo can never write one view's layout into another.
+   */
+  pruneLayoutActions: (tableId: string, viewId: string | null) => void
 }