fix(tables): address audit findings across table, undo hook, and store

- Add missing bounds check in handleCopy (c >= cols.length) matching
  handleCut for defensive consistency
- Clear lastCheckboxRowRef in Ctrl+Space and Shift+Space to prevent
  stale shift-click checkbox range after keyboard selection
- Fix stale snapshot race in patchRedoRowId/patchUndoRowId by reading
  state inside the set() updater instead of via get() outside it
- Add metadata cleanup to create-column undo so column width is removed
  from both local state and server, symmetric with delete-column redo
- Remove stale width key from columnWidths on column delete instead of
  persisting orphaned entries
- Normalize undefined vs null in handleInlineSave change detection to
  prevent unnecessary mutations when oldValue is undefined
- Use ghost.parentNode?.removeChild instead of document.body.removeChild
  in drag ghost cleanup to prevent throw on component unmount

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: waleedlatif1

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

@@ -1025,6 +1025,7 @@ export function Table({
         if (lastRow < 0) return
         e.preventDefault()
         setCheckedRows((prev) => (prev.size === 0 ? prev : EMPTY_CHECKED_ROWS))
+        lastCheckboxRowRef.current = null
         setSelectionAnchor({ rowIndex: 0, colIndex: a.colIndex })
         setSelectionFocus({ rowIndex: lastRow, colIndex: a.colIndex })
         setIsColumnSelection(true)
@@ -1038,6 +1039,7 @@ export function Table({
         if (currentCols.length === 0) return
         e.preventDefault()
         setCheckedRows((prev) => (prev.size === 0 ? prev : EMPTY_CHECKED_ROWS))
+        lastCheckboxRowRef.current = null
         setIsColumnSelection(false)
         setSelectionAnchor({ rowIndex: a.rowIndex, colIndex: 0 })
         setSelectionFocus({ rowIndex: a.rowIndex, colIndex: currentCols.length - 1 })
@@ -1354,6 +1356,7 @@ export function Table({
       for (let r = sel.startRow; r <= sel.endRow; r++) {
         const cells: string[] = []
         for (let c = sel.startCol; c <= sel.endCol; c++) {
+          if (c >= cols.length) break
           const row = pMap.get(r)
           const value: unknown = row ? row.data[cols[c].name] : null
           if (value === null || value === undefined) {
@@ -1593,15 +1596,16 @@ export function Table({
         return
       }
 
-      const oldValue = row.data[columnName]
-      const changed = !(oldValue === value) && !(oldValue === null && value === null)
+      const oldValue = row.data[columnName] ?? null
+      const normalizedValue = value ?? null
+      const changed = oldValue !== normalizedValue
 
       if (changed) {
         pushUndoRef.current({
           type: 'update-cell',
           rowId,
           columnName,
-          previousValue: oldValue ?? null,
+          previousValue: oldValue,
           newValue: value,
         })
         mutateRef.current({ rowId, data: { [columnName]: value } })
@@ -1806,13 +1810,19 @@ export function Table({
             previousWidth,
           })
 
+          const { [columnToDelete]: _removedWidth, ...cleanedWidths } = columnWidthsRef.current
+          setColumnWidths(cleanedWidths)
+          columnWidthsRef.current = cleanedWidths
+
           if (currentOrder) {
             currentOrder = currentOrder.filter((n) => n !== columnToDelete)
             setColumnOrder(currentOrder)
             updateMetadataRef.current({
-              columnWidths: columnWidthsRef.current,
+              columnWidths: cleanedWidths,
               columnOrder: currentOrder,
             })
+          } else {
+            updateMetadataRef.current({ columnWidths: cleanedWidths })
           }
 
           deleteNext(index + 1)
@@ -3147,7 +3157,7 @@ const ColumnHeaderMenu = React.memo(function ColumnHeaderMenu({
         'position:absolute;top:-9999px;padding:4px 8px;background:var(--bg);border:1px solid var(--border);border-radius:4px;font-size:13px;font-weight:500;white-space:nowrap;color:var(--text-primary)'
       document.body.appendChild(ghost)
       e.dataTransfer.setDragImage(ghost, ghost.offsetWidth / 2, ghost.offsetHeight / 2)
-      requestAnimationFrame(() => document.body.removeChild(ghost))
+      requestAnimationFrame(() => ghost.parentNode?.removeChild(ghost))
 
       onDragStart?.(column.name)
     },

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

@@ -202,7 +202,16 @@ export function useTableUndo({
 
           case 'create-column': {
             if (direction === 'undo') {
-              deleteColumnMutation.mutate(action.columnName)
+              deleteColumnMutation.mutate(action.columnName, {
+                onSuccess: () => {
+                  const currentWidths = getColumnWidthsRef.current?.() ?? {}
+                  if (action.columnName in currentWidths) {
+                    const { [action.columnName]: _, ...rest } = currentWidths
+                    onColumnWidthsChangeRef.current?.(rest)
+                    updateMetadataMutation.mutate({ columnWidths: rest })
+                  }
+                },
+              })
             } else {
               addColumnMutation.mutate({
                 name: action.columnName,

apps/sim/stores/table/store.ts

@@ -150,31 +150,35 @@ export const useTableUndoStore = create<TableUndoState>()(
       },
 
       patchRedoRowId: (tableId: string, oldRowId: string, newRowId: string) => {
-        const stacks = get().stacks[tableId]
-        if (!stacks) return
-
-        const patchedRedo = stacks.redo.map((entry) => patchRowIdInEntry(entry, oldRowId, newRowId))
-
-        set((state) => ({
-          stacks: {
-            ...state.stacks,
-            [tableId]: { ...stacks, redo: patchedRedo },
-          },
-        }))
+        set((state) => {
+          const stacks = state.stacks[tableId]
+          if (!stacks) return state
+          const patchedRedo = stacks.redo.map((entry) =>
+            patchRowIdInEntry(entry, oldRowId, newRowId)
+          )
+          return {
+            stacks: {
+              ...state.stacks,
+              [tableId]: { ...stacks, redo: patchedRedo },
+            },
+          }
+        })
       },
 
       patchUndoRowId: (tableId: string, oldRowId: string, newRowId: string) => {
-        const stacks = get().stacks[tableId]
-        if (!stacks) return
-
-        const patchedUndo = stacks.undo.map((entry) => patchRowIdInEntry(entry, oldRowId, newRowId))
-
-        set((state) => ({
-          stacks: {
-            ...state.stacks,
-            [tableId]: { ...stacks, undo: patchedUndo },
-          },
-        }))
+        set((state) => {
+          const stacks = state.stacks[tableId]
+          if (!stacks) return state
+          const patchedUndo = stacks.undo.map((entry) =>
+            patchRowIdInEntry(entry, oldRowId, newRowId)
+          )
+          return {
+            stacks: {
+              ...state.stacks,
+              [tableId]: { ...stacks, undo: patchedUndo },
+            },
+          }
+        })
       },
 
       clear: (tableId: string) => {