@bygd/nc-report-ui 0.1.41 → 0.1.42

package/dist/default/esm/index.js

@@ -44,7 +44,7 @@ import ArrowBackIcon from '@mui/icons-material/ArrowBack';
 import SaveIcon from '@mui/icons-material/Save';
 import DownloadIcon from '@mui/icons-material/Download';
 import { useSensors, useSensor, PointerSensor, KeyboardSensor, DndContext, closestCenter } from '@dnd-kit/core';
-import { sortableKeyboardCoordinates, SortableContext, verticalListSortingStrategy, arrayMove, useSortable } from '@dnd-kit/sortable';
+import { sortableKeyboardCoordinates, SortableContext, verticalListSortingStrategy, useSortable, arrayMove } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
 import DragIndicatorIcon from '@mui/icons-material/DragIndicator';
 import ArrowUpwardIcon from '@mui/icons-material/ArrowUpward';
@@ -64,6 +64,7 @@ import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
 import { DatePicker } from '@mui/x-date-pickers/DatePicker';
 import { AdapterDayjs } from '@mui/x-date-pickers/AdapterDayjs';
 import dayjs from 'dayjs';
+import CalculateIcon from '@mui/icons-material/Calculate';
 import { ThemeProvider, createTheme } from '@mui/material/styles';
 
 function _extends() {
@@ -2528,6 +2529,140 @@ const ProviderSelection = ({
   }, renderSelectionChain()));
 };
 
+// Shared drag-and-drop primitives for the index-identified, arrow-reorderable
+// lists used across the report builder (Dimensions, Metrics, Column Order).
+// Previously duplicated per-tab; consolidated here so all three behave and
+// look identical and only need to be fixed in one place.
+
+const useSortableListSensors = () => useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, {
+  coordinateGetter: sortableKeyboardCoordinates
+}));
+
+// Builds drag/move handlers for a list where dnd-kit item ids are the array
+// index. `onReorder` receives the whole reordered list.
+const makeListReorderHandlers = (list, onReorder) => {
+  const handleDragEnd = ({
+    active,
+    over
+  }) => {
+    if (over && active.id !== over.id) {
+      const oldIndex = list.findIndex((_, i) => i === active.id);
+      const newIndex = list.findIndex((_, i) => i === over.id);
+      onReorder(arrayMove(list, oldIndex, newIndex));
+    }
+  };
+  const handleMoveUp = index => {
+    if (index > 0) {
+      onReorder(arrayMove(list, index, index - 1));
+    }
+  };
+  const handleMoveDown = index => {
+    if (index < list.length - 1) {
+      onReorder(arrayMove(list, index, index + 1));
+    }
+  };
+  return {
+    handleDragEnd,
+    handleMoveUp,
+    handleMoveDown
+  };
+};
+
+// Wraps DndContext + SortableContext + the vertical list container.
+// `itemIds` must line up with the ids passed to each item's useSortable().
+const SortableListContext = ({
+  sensors,
+  itemIds,
+  onDragEnd,
+  children
+}) => /*#__PURE__*/React__default.createElement(DndContext, {
+  sensors: sensors,
+  collisionDetection: closestCenter,
+  onDragEnd: onDragEnd
+}, /*#__PURE__*/React__default.createElement(SortableContext, {
+  items: itemIds,
+  strategy: verticalListSortingStrategy
+}, /*#__PURE__*/React__default.createElement(Box$1, {
+  sx: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 1
+  }
+}, children)));
+
+// Per-row useSortable() wiring shared by every sortable chip/row component.
+const useSortableRow = id => {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    transform,
+    transition,
+    isDragging
+  } = useSortable({
+    id
+  });
+  const style = {
+    transform: CSS.Transform.toString(transform),
+    transition,
+    opacity: isDragging ? 0.5 : 1,
+    display: "flex",
+    alignItems: "center",
+    width: "100%"
+  };
+  return {
+    attributes,
+    listeners,
+    setNodeRef,
+    style
+  };
+};
+const DragHandle = ({
+  listeners
+}) => /*#__PURE__*/React__default.createElement(Box$1, _extends({}, listeners, {
+  sx: {
+    display: "flex",
+    alignItems: "center",
+    cursor: "grab",
+    "&:active": {
+      cursor: "grabbing"
+    }
+  }
+}), /*#__PURE__*/React__default.createElement(DragIndicatorIcon, {
+  sx: {
+    cursor: "grab",
+    color: "rgba(110, 110, 110, 0.62)"
+  }
+}));
+const MoveButtons = ({
+  onMoveUp,
+  onMoveDown,
+  isFirst,
+  isLast
+}) => /*#__PURE__*/React__default.createElement(Box$1, {
+  className: "hover-icons",
+  sx: {
+    display: "flex",
+    gap: 0.5,
+    opacity: 0,
+    transition: "opacity 0.2s"
+  }
+}, /*#__PURE__*/React__default.createElement(IconButton$1, {
+  size: "small",
+  onClick: onMoveUp,
+  disabled: isFirst,
+  "aria-label": "move up"
+}, /*#__PURE__*/React__default.createElement(ArrowUpwardIcon, {
+  fontSize: "small"
+})), /*#__PURE__*/React__default.createElement(IconButton$1, {
+  size: "small",
+  onClick: onMoveDown,
+  disabled: isLast,
+  "aria-label": "move down"
+}, /*#__PURE__*/React__default.createElement(ArrowDownwardIcon, {
+  fontSize: "small"
+})));
+
 // Replace {{key}} placeholders in a title with values from the report
 // parameters (e.g. "Balance ({{base_currency}})" -> "Balance (EUR)").
 // Unknown keys are left as-is so missing parameters remain visible.
@@ -2539,6 +2674,50 @@ const interpolateTitle = (template, params) => {
   });
 };
 
+// Resolves the final column display order for the results grid: dimensions,
+// computed dimensions, and metrics combined into a single list.
+//
+// `columnOrder` is the optional, explicitly-arranged order (raw entries
+// `{ type: 'dimension' | 'computed' | 'metric', key }`) set on the Column
+// Order tab. When present, its entries come first, in that order. Anything
+// not covered by it (new fields added since it was last touched, or when
+// it's empty/undefined because no custom order has ever been defined) is
+// appended in the pre-existing default order: dimensions/computed (in their
+// own `dimensionOrder`) first, then metrics (in their own array order) —
+// this keeps behavior unchanged for reports that never define a column order.
+const resolveColumnOrder = (columnOrder, orderedDimensionItems, metrics) => {
+  // Normalise every candidate item to a uniform { kind, key, data } shape
+  // up front, so callers (e.g. the Column Order tab) can always read
+  // `.key` regardless of where the item came from.
+  const normalizedDimensionItems = orderedDimensionItems.map(item => ({
+    kind: item.kind,
+    key: item.kind === 'computed' ? item.data.name : item.data.fullPath,
+    data: item.data
+  }));
+  const normalizedMetricItems = metrics.map(m => ({
+    kind: 'metric',
+    key: m.fullPath,
+    data: m
+  }));
+  const byKey = Object.fromEntries([...normalizedDimensionItems, ...normalizedMetricItems].map(item => [`${item.kind}:${item.key}`, item]));
+  const resolved = [];
+  const seen = new Set();
+  (columnOrder || []).forEach(entry => {
+    const seenKey = `${entry.type}:${entry.key}`;
+    if (seen.has(seenKey) || !byKey[seenKey]) return;
+    resolved.push(byKey[seenKey]);
+    seen.add(seenKey);
+  });
+  [...normalizedDimensionItems, ...normalizedMetricItems].forEach(item => {
+    const seenKey = `${item.kind}:${item.key}`;
+    if (!seen.has(seenKey)) {
+      resolved.push(item);
+      seen.add(seenKey);
+    }
+  });
+  return resolved;
+};
+
 // Sortable Chip Component
 const SortableChip$1 = ({
   id,
@@ -2567,20 +2746,8 @@ const SortableChip$1 = ({
     attributes,
     listeners,
     setNodeRef,
-    transform,
-    transition,
-    isDragging
-  } = useSortable({
-    id
-  });
-  const style = {
-    transform: CSS.Transform.toString(transform),
-    transition,
-    opacity: isDragging ? 0.5 : 1,
-    display: "flex",
-    alignItems: "center",
-    width: "100%"
-  };
+    style
+  } = useSortableRow(id);
 
   // Focus input when entering edit mode
   useEffect(() => {
@@ -2689,21 +2856,9 @@ const SortableChip$1 = ({
         opacity: 1 // show icons on hover
       }
     }
-  }, /*#__PURE__*/React__default.createElement(Box$1, _extends({}, listeners, {
-    sx: {
-      display: "flex",
-      alignItems: "center",
-      cursor: "grab",
-      "&:active": {
-        cursor: "grabbing"
-      }
-    }
-  }), /*#__PURE__*/React__default.createElement(DragIndicatorIcon, {
-    sx: {
-      cursor: "grab",
-      color: "rgba(110, 110, 110, 0.62)"
-    }
-  })), !isEditing ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Box$1, {
+  }, /*#__PURE__*/React__default.createElement(DragHandle, {
+    listeners: listeners
+  }), !isEditing ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Box$1, {
     sx: {
       minWidth: 0
     }
@@ -2766,29 +2921,12 @@ const SortableChip$1 = ({
     sx: {
       flex: 1
     }
-  }), /*#__PURE__*/React__default.createElement(Box$1, {
-    className: "hover-icons",
-    sx: {
-      display: "flex",
-      gap: 0.5,
-      opacity: 0,
-      transition: "opacity 0.2s"
-    }
-  }, /*#__PURE__*/React__default.createElement(IconButton$1, {
-    size: "small",
-    onClick: onMoveUp,
-    disabled: isFirst,
-    "aria-label": "move up"
-  }, /*#__PURE__*/React__default.createElement(ArrowUpwardIcon, {
-    fontSize: "small"
-  })), /*#__PURE__*/React__default.createElement(IconButton$1, {
-    size: "small",
-    onClick: onMoveDown,
-    disabled: isLast,
-    "aria-label": "move down"
-  }, /*#__PURE__*/React__default.createElement(ArrowDownwardIcon, {
-    fontSize: "small"
-  })))) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(TextField, {
+  }), /*#__PURE__*/React__default.createElement(MoveButtons, {
+    onMoveUp: onMoveUp,
+    onMoveDown: onMoveDown,
+    isFirst: isFirst,
+    isLast: isLast
+  })) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(TextField, {
     inputRef: inputRef,
     value: editValue,
     onChange: e => setEditValue(e.target.value),
@@ -2864,24 +3002,12 @@ const SortableComputedChip = ({
     attributes,
     listeners,
     setNodeRef,
-    transform,
-    transition,
-    isDragging
-  } = useSortable({
-    id
-  });
+    style
+  } = useSortableRow(id);
   const [isEditing, setIsEditing] = useState(false);
   const [editName, setEditName] = useState("");
   const [editValue, setEditValue] = useState("");
   const containerRef = useRef(null);
-  const style = {
-    transform: CSS.Transform.toString(transform),
-    transition,
-    opacity: isDragging ? 0.5 : 1,
-    display: "flex",
-    alignItems: "center",
-    width: "100%"
-  };
 
   // Handle click outside to cancel
   useEffect(() => {
@@ -2944,21 +3070,9 @@ const SortableComputedChip = ({
         opacity: 1
       }
     }
-  }, /*#__PURE__*/React__default.createElement(Box$1, _extends({}, listeners, {
-    sx: {
-      display: "flex",
-      alignItems: "center",
-      cursor: "grab",
-      "&:active": {
-        cursor: "grabbing"
-      }
-    }
-  }), /*#__PURE__*/React__default.createElement(DragIndicatorIcon, {
-    sx: {
-      cursor: "grab",
-      color: "rgba(110, 110, 110, 0.62)"
-    }
-  })), !isEditing ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Chip, {
+  }, /*#__PURE__*/React__default.createElement(DragHandle, {
+    listeners: listeners
+  }), !isEditing ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Chip, {
     icon: /*#__PURE__*/React__default.createElement(FunctionsIcon, {
       sx: {
         fontSize: "15px !important"
@@ -3022,29 +3136,12 @@ const SortableComputedChip = ({
     sx: {
       flex: 1
     }
-  }), /*#__PURE__*/React__default.createElement(Box$1, {
-    className: "hover-icons",
-    sx: {
-      display: "flex",
-      gap: 0.5,
-      opacity: 0,
-      transition: "opacity 0.2s"
-    }
-  }, /*#__PURE__*/React__default.createElement(IconButton$1, {
-    size: "small",
-    onClick: onMoveUp,
-    disabled: isFirst,
-    "aria-label": "move up"
-  }, /*#__PURE__*/React__default.createElement(ArrowUpwardIcon, {
-    fontSize: "small"
-  })), /*#__PURE__*/React__default.createElement(IconButton$1, {
-    size: "small",
-    onClick: onMoveDown,
-    disabled: isLast,
-    "aria-label": "move down"
-  }, /*#__PURE__*/React__default.createElement(ArrowDownwardIcon, {
-    fontSize: "small"
-  })))) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(TextField, {
+  }), /*#__PURE__*/React__default.createElement(MoveButtons, {
+    onMoveUp: onMoveUp,
+    onMoveDown: onMoveDown,
+    isFirst: isFirst,
+    isLast: isLast
+  })) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(TextField, {
     value: editName,
     onChange: e => setEditName(e.target.value),
     onKeyDown: handleKeyDown,
@@ -3129,9 +3226,7 @@ const Dimensions = ({
   const [computedValue, setComputedValue] = useState("");
 
   // Setup drag and drop sensors
-  const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, {
-    coordinateGetter: sortableKeyboardCoordinates
-  }));
+  const sensors = useSortableListSensors();
 
   // Resolve the unified dimensionOrder into the actual dimension / computed
   // dimension objects, so dimensions and computed dimensions can be shown
@@ -3148,32 +3243,12 @@ const Dimensions = ({
     data: computedDimensionByName[entry.key]
   }).filter(item => item.data);
 
-  // Handle drag end for the unified list
-  const handleDragEnd = event => {
-    const {
-      active,
-      over
-    } = event;
-    if (over && active.id !== over.id) {
-      const oldIndex = dimensionOrder.findIndex((_, i) => i === active.id);
-      const newIndex = dimensionOrder.findIndex((_, i) => i === over.id);
-      onReorderDimensionItems(arrayMove(dimensionOrder, oldIndex, newIndex));
-    }
-  };
-
-  // Handle move up
-  const handleMoveUp = index => {
-    if (index > 0) {
-      onReorderDimensionItems(arrayMove(dimensionOrder, index, index - 1));
-    }
-  };
-
-  // Handle move down
-  const handleMoveDown = index => {
-    if (index < dimensionOrder.length - 1) {
-      onReorderDimensionItems(arrayMove(dimensionOrder, index, index + 1));
-    }
-  };
+  // Handle drag/move for the unified list
+  const {
+    handleDragEnd,
+    handleMoveUp,
+    handleMoveDown
+  } = makeListReorderHandlers(dimensionOrder, onReorderDimensionItems);
 
   // Handle sort order change (dimensions only - computed dimensions have no order_by)
   const handleSortOrderChange = (fullPath, sortOrder) => {
@@ -3666,19 +3741,10 @@ const Dimensions = ({
       color: "#666",
       marginBottom: 2
     }
-  }, "Drag to reorder or use arrows"), /*#__PURE__*/React__default.createElement(DndContext, {
+  }, "Drag to reorder or use arrows"), /*#__PURE__*/React__default.createElement(SortableListContext, {
     sensors: sensors,
-    collisionDetection: closestCenter,
+    itemIds: orderedItems.map((_, index) => index),
     onDragEnd: handleDragEnd
-  }, /*#__PURE__*/React__default.createElement(SortableContext, {
-    items: orderedItems.map((_, index) => index),
-    strategy: verticalListSortingStrategy
-  }, /*#__PURE__*/React__default.createElement(Box$1, {
-    sx: {
-      display: "flex",
-      flexDirection: "column",
-      gap: 1
-    }
   }, orderedItems.map((item, index) => item.kind === "dimension" ? /*#__PURE__*/React__default.createElement(SortableChip$1, {
     key: `dim-${item.key}`,
     id: index,
@@ -3708,7 +3774,7 @@ const Dimensions = ({
     onMoveDown: () => handleMoveDown(index),
     isFirst: index === 0,
     isLast: index === orderedItems.length - 1
-  })))))));
+  })))));
 };
 
 const MetricSourceIcon = ({
@@ -3783,20 +3849,8 @@ const SortableChip = ({
     attributes,
     listeners,
     setNodeRef,
-    transform,
-    transition,
-    isDragging
-  } = useSortable({
-    id
-  });
-  const style = {
-    transform: CSS.Transform.toString(transform),
-    transition,
-    opacity: isDragging ? 0.5 : 1,
-    display: 'flex',
-    alignItems: 'center',
-    width: '100%'
-  };
+    style
+  } = useSortableRow(id);
 
   // Focus input when entering edit mode
   useEffect(() => {
@@ -3874,21 +3928,9 @@ const SortableChip = ({
         opacity: 1 // show icons on hover
       }
     }
-  }, /*#__PURE__*/React__default.createElement(Box$1, _extends({}, listeners, {
-    sx: {
-      display: "flex",
-      alignItems: "center",
-      cursor: "grab",
-      "&:active": {
-        cursor: "grabbing"
-      }
-    }
-  }), /*#__PURE__*/React__default.createElement(DragIndicatorIcon, {
-    sx: {
-      cursor: "grab",
-      color: "rgba(110, 110, 110, 0.62)"
-    }
-  })), !isEditing ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, source && /*#__PURE__*/React__default.createElement(Box$1, {
+  }, /*#__PURE__*/React__default.createElement(DragHandle, {
+    listeners: listeners
+  }), !isEditing ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, source && /*#__PURE__*/React__default.createElement(Box$1, {
     sx: {
       display: 'flex',
       alignItems: 'center',
@@ -3950,29 +3992,12 @@ const SortableChip = ({
     sx: {
       flex: 1
     }
-  }), /*#__PURE__*/React__default.createElement(Box$1, {
-    className: "hover-icons",
-    sx: {
-      display: "flex",
-      gap: 0.5,
-      opacity: 0,
-      transition: "opacity 0.2s"
-    }
-  }, /*#__PURE__*/React__default.createElement(IconButton$1, {
-    size: "small",
-    onClick: onMoveUp,
-    disabled: isFirst,
-    "aria-label": "move up"
-  }, /*#__PURE__*/React__default.createElement(ArrowUpwardIcon, {
-    fontSize: "small"
-  })), /*#__PURE__*/React__default.createElement(IconButton$1, {
-    size: "small",
-    onClick: onMoveDown,
-    disabled: isLast,
-    "aria-label": "move down"
-  }, /*#__PURE__*/React__default.createElement(ArrowDownwardIcon, {
-    fontSize: "small"
-  })))) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(TextField, {
+  }), /*#__PURE__*/React__default.createElement(MoveButtons, {
+    onMoveUp: onMoveUp,
+    onMoveDown: onMoveDown,
+    isFirst: isFirst,
+    isLast: isLast
+  })) : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(TextField, {
     inputRef: inputRef,
     value: editValue,
     onChange: e => setEditValue(e.target.value),
@@ -4047,39 +4072,14 @@ const Metrics = ({
   const [selectedMetric, setSelectedMetric] = useState('');
 
   // Setup drag and drop sensors
-  const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, {
-    coordinateGetter: sortableKeyboardCoordinates
-  }));
-
-  // Handle drag end
-  const handleDragEnd = event => {
-    const {
-      active,
-      over
-    } = event;
-    if (over && active.id !== over.id) {
-      const oldIndex = savedMetrics.findIndex((_, i) => i === active.id);
-      const newIndex = savedMetrics.findIndex((_, i) => i === over.id);
-      const newOrder = arrayMove(savedMetrics, oldIndex, newIndex);
-      onReorderMetrics(newOrder);
-    }
-  };
+  const sensors = useSortableListSensors();
 
-  // Handle move up
-  const handleMoveUp = index => {
-    if (index > 0) {
-      const newOrder = arrayMove(savedMetrics, index, index - 1);
-      onReorderMetrics(newOrder);
-    }
-  };
-
-  // Handle move down
-  const handleMoveDown = index => {
-    if (index < savedMetrics.length - 1) {
-      const newOrder = arrayMove(savedMetrics, index, index + 1);
-      onReorderMetrics(newOrder);
-    }
-  };
+  // Handle drag/move
+  const {
+    handleDragEnd,
+    handleMoveUp,
+    handleMoveDown
+  } = makeListReorderHandlers(savedMetrics, onReorderMetrics);
 
   // Get the current provider based on selection chain
   const getCurrentProvider = () => {
@@ -4418,19 +4418,10 @@ const Metrics = ({
       marginBottom: 1,
       color: "rgb(37, 37, 37)"
     }
-  }, "Saved Metrics"), /*#__PURE__*/React__default.createElement(DndContext, {
+  }, "Saved Metrics"), /*#__PURE__*/React__default.createElement(SortableListContext, {
     sensors: sensors,
-    collisionDetection: closestCenter,
+    itemIds: savedMetrics.map((_, index) => index),
     onDragEnd: handleDragEnd
-  }, /*#__PURE__*/React__default.createElement(SortableContext, {
-    items: savedMetrics.map((_, index) => index),
-    strategy: verticalListSortingStrategy
-  }, /*#__PURE__*/React__default.createElement(Box$1, {
-    sx: {
-      display: 'flex',
-      flexDirection: 'column',
-      gap: 1
-    }
   }, savedMetrics.map((metric, index) => /*#__PURE__*/React__default.createElement(SortableChip, {
     key: index,
     id: index,
@@ -4447,7 +4438,7 @@ const Metrics = ({
     onUpdateTitle: onUpdateTitle,
     onResetTitle: onResetTitle,
     source: metric.metric?.source
-  })))))));
+  })))));
 };
 
 const Filters = ({
@@ -5674,6 +5665,205 @@ const Filters = ({
   }))));
 };
 
+const KIND_LABEL = {
+  dimension: "Dimension",
+  computed: "Computed",
+  metric: "Metric"
+};
+const KindChip = ({
+  kind,
+  source
+}) => {
+  if (kind === "metric") {
+    return /*#__PURE__*/React__default.createElement(Box$1, {
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        flexShrink: 0
+      }
+    }, /*#__PURE__*/React__default.createElement(MetricSourceIcon, {
+      source: source
+    }));
+  }
+  return /*#__PURE__*/React__default.createElement(Chip, {
+    icon: kind === "computed" ? /*#__PURE__*/React__default.createElement(CalculateIcon, {
+      sx: {
+        fontSize: "15px !important"
+      }
+    }) : undefined,
+    label: KIND_LABEL[kind],
+    size: "small",
+    sx: {
+      fontWeight: 500,
+      backgroundColor: "rgba(70, 134, 128, 0.1)",
+      color: "rgb(70, 134, 128)",
+      flexShrink: 0
+    }
+  });
+};
+
+// Read-only sortable row: this tab only reorders columns. Adding, removing,
+// and renaming stay on the Dimensions/Metrics tabs so there's one place each
+// field is managed.
+const SortableColumnRow = ({
+  id,
+  label,
+  fullPath,
+  kind,
+  source,
+  onMoveUp,
+  onMoveDown,
+  isFirst,
+  isLast
+}) => {
+  const reportingContext = useReportingContextOptional();
+  const parameters = reportingContext?.parameters;
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    style
+  } = useSortableRow(id);
+  const displayLabel = interpolateTitle(label, parameters);
+  return /*#__PURE__*/React__default.createElement("div", _extends({
+    ref: setNodeRef,
+    style: style
+  }, attributes), /*#__PURE__*/React__default.createElement(Box$1, {
+    sx: {
+      display: "flex",
+      alignItems: "center",
+      width: "100%",
+      gap: 1,
+      backgroundColor: "white",
+      border: "1px solid #e0e0e0",
+      borderRadius: 2,
+      padding: 1,
+      transition: "transform 0.2s ease, box-shadow 0.2s ease",
+      "&:hover .hover-icons": {
+        opacity: 1
+      }
+    }
+  }, /*#__PURE__*/React__default.createElement(DragHandle, {
+    listeners: listeners
+  }), /*#__PURE__*/React__default.createElement(KindChip, {
+    kind: kind,
+    source: source
+  }), /*#__PURE__*/React__default.createElement(Tooltip$1, {
+    title: fullPath,
+    arrow: true,
+    placement: "top"
+  }, /*#__PURE__*/React__default.createElement(Typography$1, {
+    variant: "h6",
+    sx: {
+      fontWeight: 500,
+      color: "#1a1a1a",
+      fontSize: "14px",
+      whiteSpace: "nowrap",
+      overflow: "hidden",
+      textOverflow: "ellipsis"
+    }
+  }, displayLabel)), /*#__PURE__*/React__default.createElement(Box$1, {
+    sx: {
+      flex: 1
+    }
+  }), /*#__PURE__*/React__default.createElement(MoveButtons, {
+    onMoveUp: onMoveUp,
+    onMoveDown: onMoveDown,
+    isFirst: isFirst,
+    isLast: isLast
+  })));
+};
+const ColumnOrder = ({
+  orderedDimensionItems = [],
+  metrics = [],
+  columnOrder = [],
+  onReorderColumnItems,
+  titleOverrides = {
+    dimensions: {},
+    metrics: {}
+  }
+}) => {
+  const isCustomized = columnOrder.length > 0;
+  const resolvedItems = resolveColumnOrder(columnOrder, orderedDimensionItems, metrics);
+  const sensors = useSortableListSensors();
+  const reorderResolved = newResolvedItems => {
+    onReorderColumnItems(newResolvedItems.map(item => ({
+      type: item.kind,
+      key: item.key
+    })));
+  };
+  const {
+    handleDragEnd,
+    handleMoveUp,
+    handleMoveDown
+  } = makeListReorderHandlers(resolvedItems, reorderResolved);
+  const labelFor = item => {
+    if (item.kind === "computed") return item.data.name;
+    if (item.kind === "metric") {
+      return titleOverrides.metrics[item.key] || item.data.metricTitle || item.key;
+    }
+    return titleOverrides.dimensions[item.key] || item.data.dimensionTitle || item.key;
+  };
+  return /*#__PURE__*/React__default.createElement("div", null, /*#__PURE__*/React__default.createElement(Box$1, {
+    sx: {
+      display: "flex",
+      justifyContent: "space-between",
+      alignItems: "flex-start",
+      mb: 2,
+      gap: 2
+    }
+  }, /*#__PURE__*/React__default.createElement(Typography$1, {
+    sx: {
+      fontSize: "13px",
+      color: "#666"
+    }
+  }, "Optional: define a single order for all columns (dimensions, computed dimensions and metrics together) in the results grid. Drag to reorder or use the arrows. Newly added dimensions/metrics are appended to the end automatically. Without a custom order, columns follow the Dimensions tab order, then the Metrics tab order."), isCustomized && /*#__PURE__*/React__default.createElement(Tooltip$1, {
+    title: "Discard the custom order and go back to the default (Dimensions, then Metrics)",
+    arrow: true
+  }, /*#__PURE__*/React__default.createElement(Button, {
+    variant: "outlined",
+    size: "small",
+    startIcon: /*#__PURE__*/React__default.createElement(RestartAltIcon, null),
+    onClick: () => onReorderColumnItems([]),
+    sx: {
+      height: "36px",
+      flexShrink: 0,
+      fontFamily: "system-ui",
+      fontSize: "13px",
+      fontWeight: 500,
+      borderRadius: "8px",
+      boxShadow: "none",
+      textTransform: "none",
+      borderColor: "#e0e0e0",
+      color: "rgb(37, 37, 37)",
+      "&:hover": {
+        backgroundColor: "#f5f5f5",
+        borderColor: "#d0d0d0"
+      }
+    }
+  }, "Reset to Default"))), resolvedItems.length === 0 ? /*#__PURE__*/React__default.createElement(Typography$1, {
+    sx: {
+      fontSize: "13px",
+      color: "#999"
+    }
+  }, "Add dimensions or metrics in the other tabs first.") : /*#__PURE__*/React__default.createElement(SortableListContext, {
+    sensors: sensors,
+    itemIds: resolvedItems.map((_, index) => index),
+    onDragEnd: handleDragEnd
+  }, resolvedItems.map((item, index) => /*#__PURE__*/React__default.createElement(SortableColumnRow, {
+    key: `${item.kind}-${item.key}`,
+    id: index,
+    label: labelFor(item),
+    fullPath: item.kind === "computed" ? item.data.value : item.key,
+    kind: item.kind,
+    source: item.kind === "metric" ? item.data.metric?.source : undefined,
+    onMoveUp: () => handleMoveUp(index),
+    onMoveDown: () => handleMoveDown(index),
+    isFirst: index === 0,
+    isLast: index === resolvedItems.length - 1
+  }))));
+};
+
 // Default numeral.js formats applied when a dimension/metric definition has a
 // known type but no explicit `format` set on the provider.
 const DEFAULT_FORMATS_BY_TYPE = {
@@ -5688,10 +5878,107 @@ const formatValue = (value, def) => {
   return def?.prefix ? `${def.prefix} ${formatted}` : formatted;
 };
 const isNumericType = type => type === 'integer' || type === 'currency';
+
+// Builds a single DataGrid column definition for one resolved column item
+// (a dimension, computed dimension, or metric). Field naming logic:
+// - Dimensions from base provider: baseAlias.field -> baseAlias_field
+// - Dimensions from nested provider: baseAlias_rel1_rel2.field -> rel1_rel2_field (drops base alias)
+// - Computed dimensions have no provider/relations chain, so the API returns
+//   each row keyed by the computed dimension's own `name`.
+// - Metrics: API returns metric keys in different forms depending on path depth
+//   (see comment inline below), normalised to match the row-key normalisation
+//   done when building `rows`.
+const buildColumn = (item, titleOverrides, parameters) => {
+  if (item.kind === 'computed') {
+    const cd = item.data;
+    return {
+      field: cd.name,
+      headerName: cd.name,
+      flex: 1,
+      minWidth: 150,
+      type: 'string'
+    };
+  }
+  if (item.kind === 'metric') {
+    const metric = item.data;
+    const metricDef = metric.metric;
+    let fieldName;
+    const dotCount = (metric.fullPath.match(/\./g) || []).length;
+    if (dotCount >= 2) {
+      // 3+-part namespaced path: API returns the full dotted path as the key.
+      // Normalise dots to underscores to match the row key normalisation below.
+      // Example: "mc.dkpi.activeAgreementsCount" -> "mc_dkpi_activeAgreementsCount"
+      fieldName = metric.fullPath.replace(/\./g, '_');
+    } else if (metric.relations && metric.relations.length > 0) {
+      // 2-part path from a nested provider: API drops the base provider alias.
+      // Example: "mc_fa.total_amount" -> "fa_total_amount"
+      const parts = metric.fullPath.split('.');
+      const pathWithoutField = parts[0]; // e.g., "mc_fa"
+      const field = parts[1]; // e.g., "total_amount"
+
+      const pathParts = pathWithoutField.split('_');
+      pathParts.shift(); // remove base provider alias
+      const pathWithoutBase = pathParts.join('_');
+      fieldName = pathWithoutBase ? `${pathWithoutBase}_${field}` : field;
+    } else {
+      // 2-part path from the base provider: API returns just the metric name.
+      // Example: "mc.record_count" -> "record_count"
+      fieldName = metric.metricName;
+    }
+    const headerName = interpolateTitle(titleOverrides.metrics[metric.fullPath] || metric.metricTitle || fieldName, parameters);
+    return {
+      field: fieldName,
+      headerName: headerName,
+      flex: 1,
+      minWidth: 150,
+      type: isNumericType(metricDef?.type) ? 'number' : 'string',
+      renderHeader: () => /*#__PURE__*/React__default.createElement(Box$1, {
+        sx: {
+          display: 'flex',
+          alignItems: 'center',
+          gap: 0.5
+        }
+      }, /*#__PURE__*/React__default.createElement(MetricSourceIcon, {
+        source: metricDef?.source
+      }), /*#__PURE__*/React__default.createElement("span", null, headerName)),
+      valueFormatter: value => formatValue(value, metricDef)
+    };
+  }
+
+  // Dimension
+  const dim = item.data;
+  let fieldName;
+  if (dim.relations && dim.relations.length > 0) {
+    // From nested provider: drop the base provider alias
+    // Example: ft_fa_db.currency -> fa_db_currency
+    const parts = dim.fullPath.split('.');
+    const pathWithoutField = parts[0]; // e.g., "ft_fa_db"
+    const field = parts[1]; // e.g., "currency"
+
+    const pathParts = pathWithoutField.split('_');
+    pathParts.shift(); // Remove base provider alias
+    const pathWithoutBase = pathParts.join('_'); // e.g., "fa_db"
+
+    fieldName = pathWithoutBase ? `${pathWithoutBase}_${field}` : field;
+  } else {
+    // From base provider: keep the full path with underscore
+    // Example: ba.created_at -> ba_created_at
+    fieldName = dim.fullPath.replace('.', '_');
+  }
+  const headerName = interpolateTitle(titleOverrides.dimensions[dim.fullPath] || dim.dimensionTitle || fieldName, parameters);
+  const dimDef = dim.dimension;
+  return {
+    field: fieldName,
+    headerName: headerName,
+    flex: 1,
+    minWidth: 150,
+    type: isNumericType(dimDef?.type) ? 'number' : 'string',
+    valueFormatter: value => formatValue(value, dimDef)
+  };
+};
 const ReportDataGrid = ({
   reportData,
-  orderedDimensionItems = [],
-  metrics,
+  columnItems = [],
   loading,
   onPageChange,
   totalRows = 0,
@@ -5707,127 +5994,10 @@ const ReportDataGrid = ({
     pageSize: 50
   });
 
-  // Generate columns dynamically from dimensions and metrics
-  const columns = React__default.useMemo(() => {
-    const cols = [];
-
-    // Add dimension + computed-dimension columns, in the single unified
-    // order the user arranged them in on the Dimensions tab.
-    // Field naming logic (dimensions):
-    // - If from base provider: baseAlias.field -> baseAlias_field
-    // - If from nested provider: baseAlias_rel1_rel2.field -> rel1_rel2_field (drops base alias)
-    // Computed dimensions have no provider/relations chain, so the API
-    // returns each row keyed by the computed dimension's own `name`.
-    orderedDimensionItems.forEach(item => {
-      if (item.kind === 'computed') {
-        const cd = item.data;
-        cols.push({
-          field: cd.name,
-          headerName: cd.name,
-          flex: 1,
-          minWidth: 150,
-          type: 'string'
-        });
-        return;
-      }
-      const dim = item.data;
-      let fieldName;
-      let headerName;
-
-      // Check if there are relations (nested providers)
-      if (dim.relations && dim.relations.length > 0) {
-        // From nested provider: drop the base provider alias
-        // Example: ft_fa_db.currency -> fa_db_currency
-        const parts = dim.fullPath.split('.');
-        const pathWithoutField = parts[0]; // e.g., "ft_fa_db"
-        const field = parts[1]; // e.g., "currency"
-
-        // Remove the base provider alias (first part before first underscore)
-        const pathParts = pathWithoutField.split('_');
-        pathParts.shift(); // Remove base provider alias
-        const pathWithoutBase = pathParts.join('_'); // e.g., "fa_db"
-
-        fieldName = pathWithoutBase ? `${pathWithoutBase}_${field}` : field;
-      } else {
-        // From base provider: keep the full path with underscore
-        // Example: ba.created_at -> ba_created_at
-        fieldName = dim.fullPath.replace('.', '_');
-      }
-
-      // Check for title override, otherwise use the friendly dimension title from provider
-      headerName = titleOverrides.dimensions[dim.fullPath] || dim.dimensionTitle || fieldName;
-      headerName = interpolateTitle(headerName, parameters);
-      const dimDef = dim.dimension;
-      cols.push({
-        field: fieldName,
-        headerName: headerName,
-        flex: 1,
-        minWidth: 150,
-        type: isNumericType(dimDef?.type) ? 'number' : 'string',
-        valueFormatter: value => formatValue(value, dimDef)
-      });
-    });
-
-    // Add metric columns
-    // The API returns metric keys in two different forms depending on the path depth:
-    //
-    //  • 2-part path  "mc.record_count"              → API key: "record_count"
-    //  • 2-part path  "mc_fa.total_amount"  (nested) → API key: "fa_total_amount"
-    //  • 3+-part path "mc.dkpi.activeAgreementsCount"→ API key: "mc.dkpi.activeAgreementsCount" (dots)
-    //
-    // For 3+-part paths the API key contains dots. MUI DataGrid interprets dots
-    // in field names as nested-object accessors, so the rows useMemo normalises
-    // those keys (dots → underscores). The column field must match that normalised key.
-    metrics.forEach(metric => {
-      const metricDef = metric.metric;
-      let fieldName;
-      let headerName;
-      const dotCount = (metric.fullPath.match(/\./g) || []).length;
-      if (dotCount >= 2) {
-        // 3+-part namespaced path: API returns the full dotted path as the key.
-        // Normalise dots to underscores to match the row key normalisation below.
-        // Example: "mc.dkpi.activeAgreementsCount" -> "mc_dkpi_activeAgreementsCount"
-        fieldName = metric.fullPath.replace(/\./g, '_');
-      } else if (metric.relations && metric.relations.length > 0) {
-        // 2-part path from a nested provider: API drops the base provider alias.
-        // Example: "mc_fa.total_amount" -> "fa_total_amount"
-        const parts = metric.fullPath.split('.');
-        const pathWithoutField = parts[0]; // e.g., "mc_fa"
-        const field = parts[1]; // e.g., "total_amount"
-
-        const pathParts = pathWithoutField.split('_');
-        pathParts.shift(); // remove base provider alias
-        const pathWithoutBase = pathParts.join('_');
-        fieldName = pathWithoutBase ? `${pathWithoutBase}_${field}` : field;
-      } else {
-        // 2-part path from the base provider: API returns just the metric name.
-        // Example: "mc.record_count" -> "record_count"
-        fieldName = metric.metricName;
-      }
-
-      // Check for title override, otherwise use the friendly metric title from provider
-      headerName = titleOverrides.metrics[metric.fullPath] || metric.metricTitle || fieldName;
-      headerName = interpolateTitle(headerName, parameters);
-      cols.push({
-        field: fieldName,
-        headerName: headerName,
-        flex: 1,
-        minWidth: 150,
-        type: isNumericType(metricDef?.type) ? 'number' : 'string',
-        renderHeader: () => /*#__PURE__*/React__default.createElement(Box$1, {
-          sx: {
-            display: 'flex',
-            alignItems: 'center',
-            gap: 0.5
-          }
-        }, /*#__PURE__*/React__default.createElement(MetricSourceIcon, {
-          source: metricDef?.source
-        }), /*#__PURE__*/React__default.createElement("span", null, headerName)),
-        valueFormatter: value => formatValue(value, metricDef)
-      });
-    });
-    return cols;
-  }, [orderedDimensionItems, metrics, titleOverrides, parameters]);
+  // Generate columns dynamically, in the final resolved column order
+  // (custom Column Order tab arrangement when defined, otherwise
+  // dimensions/computed then metrics).
+  const columns = React__default.useMemo(() => columnItems.map(item => buildColumn(item, titleOverrides, parameters)), [columnItems, titleOverrides, parameters]);
 
   // Transform report data to rows with unique IDs.
   // Keys are normalised by replacing dots with underscores so that MUI DataGrid
@@ -5937,7 +6107,12 @@ const ReportBuilder = ({
     computedDimensions: [],
     // Unified display/execution order across dimensions + computedDimensions.
     // Entries: { type: 'dimension', key: fullPath } | { type: 'computed', key: name }
-    dimensionOrder: []
+    dimensionOrder: [],
+    // Optional unified display order across dimensions + computedDimensions +
+    // metrics, set on the Column Order tab. Empty means "not defined" — the
+    // results grid falls back to dimensionOrder followed by metrics order.
+    // Entries: { type: 'dimension' | 'computed' | 'metric', key }
+    columnOrder: []
   });
   const [titleOverrides, setTitleOverrides] = useState({
     dimensions: {},
@@ -6168,6 +6343,46 @@ const ReportBuilder = ({
     });
     return dimensionOrder;
   };
+
+  // Build the optional unified column order (dimensions + computed
+  // dimensions + metrics) from the persisted `ordered_columns` field.
+  // Unlike buildDimensionOrder, entries that no longer resolve are simply
+  // dropped rather than backfilled — an empty/partial result just means "no
+  // custom order defined (yet)", which resolveColumnOrder treats as
+  // "fall back to the default order".
+  const buildColumnOrder = (rawOrderedColumns, dimensions, computedDimensions, metrics) => {
+    if (!Array.isArray(rawOrderedColumns)) return [];
+    const dimensionPaths = new Set(dimensions.map(d => d.fullPath));
+    const computedNames = new Set(computedDimensions.map(cd => cd.name));
+    const metricPaths = new Set(metrics.map(m => m.fullPath));
+    const columnOrder = [];
+    rawOrderedColumns.forEach(entry => {
+      if (entry.type === "dimension" && dimensionPaths.has(entry.ref)) {
+        columnOrder.push({
+          type: "dimension",
+          key: entry.ref
+        });
+      } else if (entry.type === "computed" && computedNames.has(entry.ref)) {
+        columnOrder.push({
+          type: "computed",
+          key: entry.ref
+        });
+      } else if (entry.type === "metric" && metricPaths.has(entry.ref)) {
+        columnOrder.push({
+          type: "metric",
+          key: entry.ref
+        });
+      }
+    });
+    return columnOrder;
+  };
+
+  // Auto-append a newly added dimension/computed dimension/metric to the end
+  // of columnOrder — but only once a custom order actually exists. While
+  // columnOrder is empty (no custom order defined) it's left untouched, so
+  // the results grid keeps falling back to the default dimensions-then-
+  // metrics order until the user visits the Column Order tab.
+  const appendToColumnOrder = (columnOrder, entry) => columnOrder.length > 0 ? [...columnOrder, entry] : columnOrder;
   const loadReportDefinition = async id => {
     try {
       console.log("Loading report definition:", id);
@@ -6264,6 +6479,7 @@ const ReportBuilder = ({
       // provider/relation chain, so they're loaded as-is (no reconstruction needed)
       const computedDimensions = reportDef.definition?.doc?.query?.computed_dimensions || [];
       const dimensionOrder = buildDimensionOrder(reportDef.definition?.doc?.query?.ordered_dimensions, reconstructedDimensions, computedDimensions);
+      const columnOrder = buildColumnOrder(reportDef.definition?.doc?.query?.ordered_columns, reconstructedDimensions, computedDimensions, reconstructedMetrics);
 
       // Set the report state
       setReport({
@@ -6271,7 +6487,8 @@ const ReportBuilder = ({
         metrics: reconstructedMetrics,
         filters: loadedFilters,
         computedDimensions,
-        dimensionOrder
+        dimensionOrder,
+        columnOrder
       });
 
       // Set title overrides
@@ -6381,6 +6598,7 @@ const ReportBuilder = ({
       // provider/relation chain, so they're loaded as-is (no reconstruction needed)
       const computedDimensions = reportDef.definition?.doc?.query?.computed_dimensions || [];
       const dimensionOrder = buildDimensionOrder(reportDef.definition?.doc?.query?.ordered_dimensions, reconstructedDimensions, computedDimensions);
+      const columnOrder = buildColumnOrder(reportDef.definition?.doc?.query?.ordered_columns, reconstructedDimensions, computedDimensions, reconstructedMetrics);
 
       // Set the report state
       setReport({
@@ -6388,7 +6606,8 @@ const ReportBuilder = ({
         metrics: reconstructedMetrics,
         filters: loadedFilters,
         computedDimensions,
-        dimensionOrder
+        dimensionOrder,
+        columnOrder
       });
 
       // Set title overrides
@@ -6422,7 +6641,8 @@ const ReportBuilder = ({
       metrics: [],
       filters: {},
       computedDimensions: [],
-      dimensionOrder: []
+      dimensionOrder: [],
+      columnOrder: []
     });
     // Reset title overrides
     setTitleOverrides({
@@ -6503,7 +6723,11 @@ const ReportBuilder = ({
         dimensionOrder: [...prev.dimensionOrder, {
           type: "dimension",
           key: dimensionData.fullPath
-        }]
+        }],
+        columnOrder: appendToColumnOrder(prev.columnOrder, {
+          type: "dimension",
+          key: dimensionData.fullPath
+        })
       };
       console.log("Dimension saved:", dimensionData);
       console.log("Complete report:", newReport);
@@ -6514,7 +6738,8 @@ const ReportBuilder = ({
     setReport(prev => ({
       ...prev,
       dimensions: prev.dimensions.filter(d => d.fullPath !== fullPath),
-      dimensionOrder: prev.dimensionOrder.filter(entry => !(entry.type === "dimension" && entry.key === fullPath))
+      dimensionOrder: prev.dimensionOrder.filter(entry => !(entry.type === "dimension" && entry.key === fullPath)),
+      columnOrder: prev.columnOrder.filter(entry => !(entry.type === "dimension" && entry.key === fullPath))
     }));
   };
   const handleUpdateDimensionSortOrder = (fullPath, sortOrder) => {
@@ -6543,7 +6768,11 @@ const ReportBuilder = ({
       dimensionOrder: [...prev.dimensionOrder, {
         type: "computed",
         key: computedDimensionData.name
-      }]
+      }],
+      columnOrder: appendToColumnOrder(prev.columnOrder, {
+        type: "computed",
+        key: computedDimensionData.name
+      })
     }));
   };
   const handleUpdateComputedDimension = (name, computedDimensionData) => {
@@ -6553,6 +6782,10 @@ const ReportBuilder = ({
       dimensionOrder: prev.dimensionOrder.map(entry => entry.type === "computed" && entry.key === name ? {
         ...entry,
         key: computedDimensionData.name
+      } : entry),
+      columnOrder: prev.columnOrder.map(entry => entry.type === "computed" && entry.key === name ? {
+        ...entry,
+        key: computedDimensionData.name
       } : entry)
     }));
   };
@@ -6560,14 +6793,19 @@ const ReportBuilder = ({
     setReport(prev => ({
       ...prev,
       computedDimensions: prev.computedDimensions.filter(cd => cd.name !== name),
-      dimensionOrder: prev.dimensionOrder.filter(entry => !(entry.type === "computed" && entry.key === name))
+      dimensionOrder: prev.dimensionOrder.filter(entry => !(entry.type === "computed" && entry.key === name)),
+      columnOrder: prev.columnOrder.filter(entry => !(entry.type === "computed" && entry.key === name))
     }));
   };
   const handleSaveMetric = metricData => {
     setReport(prev => {
       const newReport = {
         ...prev,
-        metrics: [...prev.metrics, metricData]
+        metrics: [...prev.metrics, metricData],
+        columnOrder: appendToColumnOrder(prev.columnOrder, {
+          type: "metric",
+          key: metricData.fullPath
+        })
       };
       console.log("Metric saved:", metricData);
       console.log("Complete report:", newReport);
@@ -6575,15 +6813,29 @@ const ReportBuilder = ({
     });
   };
   const handleRemoveMetric = index => {
+    setReport(prev => {
+      const fullPath = prev.metrics[index]?.fullPath;
+      return {
+        ...prev,
+        metrics: prev.metrics.filter((_, i) => i !== index),
+        columnOrder: prev.columnOrder.filter(entry => !(entry.type === "metric" && entry.key === fullPath))
+      };
+    });
+  };
+  const handleReorderMetrics = newOrder => {
     setReport(prev => ({
       ...prev,
-      metrics: prev.metrics.filter((_, i) => i !== index)
+      metrics: newOrder
     }));
   };
-  const handleReorderMetrics = newOrder => {
+
+  // Sets the unified column order shown on the Column Order tab. An empty
+  // array (e.g. via "Reset to Default") clears the customization, and the
+  // results grid falls back to dimensionOrder followed by metrics order.
+  const handleReorderColumnItems = newColumnOrder => {
     setReport(prev => ({
       ...prev,
-      metrics: newOrder
+      columnOrder: newColumnOrder
     }));
   };
   const handleSaveFilter = (fullPath, filterData) => {
@@ -6708,6 +6960,17 @@ const ReportBuilder = ({
       }));
     }
 
+    // Persist the optional unified column order (Column Order tab) so the
+    // results grid can reproduce it on reload. Absent when no custom order
+    // has been defined, so old/untouched reports keep their current
+    // dimensions-then-metrics column order unchanged.
+    if (report.columnOrder.length > 0) {
+      queryObj.ordered_columns = report.columnOrder.map(entry => ({
+        type: entry.type,
+        ref: entry.key
+      }));
+    }
+
     // Only add titles if there are any overrides
     if (Object.keys(titles).length > 0) {
       queryObj.titles = titles;
@@ -6767,8 +7030,8 @@ const ReportBuilder = ({
   const handleRunReport = async () => {
     setCurrentPage(0);
     await runReportWithPagination(0, pageSize);
-    // Switch to Results tab after running report (now index 3 after adding Filters tab)
-    setActiveTab(3);
+    // Switch to Results tab after running report (index 4: Dimensions, Metrics, Filters, Column Order, Results)
+    setActiveTab(4);
   };
   const handleDownloadReport = async () => {
     try {
@@ -6875,6 +7138,11 @@ const ReportBuilder = ({
     kind: "computed",
     data: computedDimensionByName[entry.key]
   }).filter(item => item.data);
+
+  // Final column list for the results grid: the explicit Column Order tab
+  // arrangement when defined, otherwise dimensions/computed (in their own
+  // order) followed by metrics (in their own order) — today's behavior.
+  const columnItems = resolveColumnOrder(report.columnOrder, orderedDimensionItems, report.metrics);
   return /*#__PURE__*/React__default.createElement(Box$1, {
     sx: {
       p: 3,
@@ -7129,9 +7397,36 @@ const ReportBuilder = ({
       }
     }
   }), /*#__PURE__*/React__default.createElement(Tab, {
-    label: reportData ? "Results" : "Results (Run report first)",
+    label: /*#__PURE__*/React__default.createElement(Badge, {
+      variant: "dot",
+      invisible: report.columnOrder.length === 0,
+      sx: {
+        "& .MuiBadge-dot": {
+          backgroundColor: "rgb(70, 134, 128)"
+        }
+      }
+    }, /*#__PURE__*/React__default.createElement("span", {
+      style: {
+        marginRight: report.columnOrder.length > 0 ? "8px" : "0"
+      }
+    }, "Column Order")),
     id: "report-tab-3",
     "aria-controls": "report-tabpanel-3",
+    sx: {
+      height: "41px",
+      fontFamily: "system-ui",
+      borderRadius: "0.5rem",
+      boxShadow: "none",
+      textTransform: "none",
+      color: "rgb(37, 37, 37)",
+      "&.Mui-selected": {
+        color: "rgb(70, 134, 128)"
+      }
+    }
+  }), /*#__PURE__*/React__default.createElement(Tab, {
+    label: reportData ? "Results" : "Results (Run report first)",
+    id: "report-tab-4",
+    "aria-controls": "report-tabpanel-4",
     disabled: !reportData,
     sx: {
       height: "41px",
@@ -7198,10 +7493,18 @@ const ReportBuilder = ({
   })), /*#__PURE__*/React__default.createElement(TabPanel, {
     value: activeTab,
     index: 3
-  }, reportData && /*#__PURE__*/React__default.createElement(ReportDataGrid, {
-    reportData: reportData,
+  }, /*#__PURE__*/React__default.createElement(ColumnOrder, {
     orderedDimensionItems: orderedDimensionItems,
     metrics: report.metrics,
+    columnOrder: report.columnOrder,
+    onReorderColumnItems: handleReorderColumnItems,
+    titleOverrides: titleOverrides
+  })), /*#__PURE__*/React__default.createElement(TabPanel, {
+    value: activeTab,
+    index: 4
+  }, reportData && /*#__PURE__*/React__default.createElement(ReportDataGrid, {
+    reportData: reportData,
+    columnItems: columnItems,
     loading: loading,
     onPageChange: handlePageChange,
     totalRows: totalRows,
@@ -7289,6 +7592,12 @@ const CurrencySelector = () => {
     parameters,
     setParameters
   } = useReportingContext();
+
+  // Hidden by default; only shown when a `cur` query parameter is present in the top-level URL.
+  const showCurrencySelector = new URLSearchParams(window.location.search).has("cur");
+  if (!showCurrencySelector) {
+    return null;
+  }
   return /*#__PURE__*/React__default.createElement(SingleSelect, {
     items: CURRENCY_OPTIONS,
     value: parameters.base_currency,