@bygd/nc-report-ui 0.1.42 → 0.1.43

package/dist/app/esm/index.js

@@ -30273,6 +30273,7 @@ function useInView({
   delay,
   trackVisibility,
   rootMargin,
+  scrollMargin,
   root,
   triggerOnce,
   skip,
@@ -30317,8 +30318,8 @@ function useInView({
         {
           root,
           rootMargin,
+          scrollMargin,
           threshold,
-          // @ts-expect-error
           trackVisibility,
           delay
         },
@@ -30338,6 +30339,7 @@ function useInView({
       ref,
       root,
       rootMargin,
+      scrollMargin,
       triggerOnce,
       skip,
       trackVisibility,
@@ -43266,6 +43268,10 @@ const ChartFilterMultiSelect = ({
   })));
 };
 
+var CheckCircleIcon = createSvgIcon$1(/*#__PURE__*/u("path", {
+  d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2m-2 15-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8z"
+}));
+
 const formatLabel = key => {
   return key?.replace(/([a-z])([A-Z])/g, "$1 $2") // insert space before capital letters
   ?.replace(/_/g, " ")?.replace(/-/g, " ") // replace underscores with spaces (optional)
@@ -43329,7 +43335,8 @@ function SingleSelect({
       key,
       value,
       disabled,
-      icon
+      icon,
+      alreadySelected
     } = itm;
     return /*#__PURE__*/gn.createElement(MenuItem, {
       key: key,
@@ -43340,7 +43347,12 @@ function SingleSelect({
         minHeight: "36px",
         display: "flex",
         alignItems: "center",
-        gap: "6px"
+        gap: "6px",
+        ...(alreadySelected && {
+          color: "rgb(70, 134, 128)",
+          backgroundColor: "rgba(70, 134, 128, 0.08)",
+          fontWeight: 600
+        })
       }
     }, icon && /*#__PURE__*/gn.createElement(Box, {
       component: "span",
@@ -43348,7 +43360,13 @@ function SingleSelect({
         display: "inline-flex",
         alignItems: "center"
       }
-    }, icon), formatLabel(value));
+    }, icon), alreadySelected && /*#__PURE__*/gn.createElement(CheckCircleIcon, {
+      fontSize: "small",
+      sx: {
+        color: "rgb(70, 134, 128)",
+        fontSize: "16px"
+      }
+    }), formatLabel(value));
   }))));
 }
 
@@ -77326,6 +77344,29 @@ var FunctionsIcon = createSvgIcon$1(/*#__PURE__*/u("path", {
   d: "M18 4H6v2l6.5 6L6 18v2h12v-3h-7l5-5-5-5h7z"
 }));
 
+// Builds an identity string for a saved dimension/metric instance. Deliberate
+// duplicates (the same field added more than once) are allowed - the first
+// occurrence keeps the plain fullPath (so existing saved reports and their
+// title-override keys stay backward compatible), later occurrences get a
+// `#n` suffix.
+const makeInstanceId = (fullPath, occurrenceIndex) => occurrenceIndex === 0 ? fullPath : `${fullPath}#${occurrenceIndex}`;
+
+// Picks the next free instance id for a newly-added fullPath, given the
+// items already saved. Scans occurrence numbers from 0 rather than just
+// counting existing instances with this fullPath, because counting alone
+// can collide: e.g. add "ft.currency" twice (ids "ft.currency",
+// "ft.currency#1"), remove the first, then add "ft.currency" again - a
+// plain count of 1 would regenerate "ft.currency#1", clashing with the
+// surviving duplicate.
+const nextInstanceId = (fullPath, existingItems) => {
+  const existingIds = new Set(existingItems.map(item => item.id));
+  let occurrenceIndex = 0;
+  while (existingIds.has(makeInstanceId(fullPath, occurrenceIndex))) {
+    occurrenceIndex += 1;
+  }
+  return makeInstanceId(fullPath, occurrenceIndex);
+};
+
 // 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.
@@ -77352,14 +77393,17 @@ 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.
+  // Keyed by instance id (not fullPath) so that two instances of the same
+  // dimension/metric - added deliberately as duplicates - are treated as
+  // distinct columns rather than collapsing into one.
   const normalizedDimensionItems = orderedDimensionItems.map(item => ({
     kind: item.kind,
-    key: item.kind === 'computed' ? item.data.name : item.data.fullPath,
+    key: item.kind === 'computed' ? item.data.name : item.data.id,
     data: item.data
   }));
   const normalizedMetricItems = metrics.map(m => ({
     kind: 'metric',
-    key: m.fullPath,
+    key: m.id,
     data: m
   }));
   const byKey = Object.fromEntries([...normalizedDimensionItems, ...normalizedMetricItems].map(item => [`${item.kind}:${item.key}`, item]));
@@ -77393,7 +77437,7 @@ const SortableChip$1 = ({
   isLast,
   sortOrder,
   onSortOrderChange,
-  fullPath,
+  instanceId,
   defaultTitle,
   customTitle,
   onUpdateTitle,
@@ -77476,7 +77520,7 @@ const SortableChip$1 = ({
       handleCancel();
       return;
     }
-    onUpdateTitle(fullPath, trimmedValue);
+    onUpdateTitle(instanceId, trimmedValue);
     setIsEditing(false);
   };
   const handleCancel = () => {
@@ -77484,7 +77528,7 @@ const SortableChip$1 = ({
     setEditValue("");
   };
   const handleReset = () => {
-    onResetTitle(fullPath);
+    onResetTitle(instanceId);
     setIsEditing(false);
     setEditValue("");
   };
@@ -77695,7 +77739,7 @@ const SortableComputedChip = ({
   const handleSave = () => {
     const trimmedName = editName.trim();
     const trimmedValue = editValue.trim();
-    if (!trimmedName || !trimmedValue) return;
+    if (!trimmedName) return;
     if (isNameTaken(trimmedName, name)) return;
     onUpdate(name, {
       name: trimmedName,
@@ -77845,7 +77889,7 @@ const SortableComputedChip = ({
     onClick: handleSave,
     color: "primary",
     "aria-label": "save computed dimension",
-    disabled: !editName.trim() || !editValue.trim() || nameError
+    disabled: !editName.trim() || nameError
   }, /*#__PURE__*/gn.createElement(CheckIcon, {
     fontSize: "small"
   })))), /*#__PURE__*/gn.createElement(Tooltip, {
@@ -77894,12 +77938,14 @@ const Dimensions = ({
   // Resolve the unified dimensionOrder into the actual dimension / computed
   // dimension objects, so dimensions and computed dimensions can be shown
   // (and dragged) as a single list while staying stored in their own arrays.
-  const dimensionByFullPath = Object.fromEntries(savedDimensions.map(d => [d.fullPath, d]));
+  // Keyed by instance id rather than fullPath, so two instances of the same
+  // dimension (added deliberately as a duplicate) stay distinct entries.
+  const dimensionById = Object.fromEntries(savedDimensions.map(d => [d.id, d]));
   const computedDimensionByName = Object.fromEntries(savedComputedDimensions.map(cd => [cd.name, cd]));
   const orderedItems = dimensionOrder.map(entry => entry.type === "dimension" ? {
     kind: "dimension",
     key: entry.key,
-    data: dimensionByFullPath[entry.key]
+    data: dimensionById[entry.key]
   } : {
     kind: "computed",
     key: entry.key,
@@ -77913,9 +77959,13 @@ const Dimensions = ({
     handleMoveDown
   } = makeListReorderHandlers(dimensionOrder, onReorderDimensionItems);
 
-  // Handle sort order change (dimensions only - computed dimensions have no order_by)
-  const handleSortOrderChange = (fullPath, sortOrder) => {
-    onUpdateDimensionSortOrder(fullPath, sortOrder);
+  // Handle sort order change (dimensions only - computed dimensions have no
+  // order_by). Keyed by instance id but applied query-wide: SQL can only
+  // sort by a given column once, so toggling sort on any duplicate instance
+  // of the same field is propagated to all instances sharing its fullPath
+  // (handled in ReportBuilder's onUpdateDimensionSortOrder).
+  const handleSortOrderChange = (id, sortOrder) => {
+    onUpdateDimensionSortOrder(id, sortOrder);
   };
 
   // Computed Dimensions: { name, value } pairs independent of any provider.
@@ -77936,7 +77986,7 @@ const Dimensions = ({
   const handleSaveComputed = () => {
     const trimmedName = computedName.trim();
     const trimmedValue = computedValue.trim();
-    if (!trimmedName || !trimmedValue) return;
+    if (!trimmedName) return;
     if (isComputedNameTaken(trimmedName)) return;
     onSaveComputedDimension({
       name: trimmedName,
@@ -77978,7 +78028,10 @@ const Dimensions = ({
       currentProviderKey = selection.targetKey;
     });
 
-    // Create a Set of already selected dimension fullPaths for quick lookup
+    // Create a Set of already selected dimension fullPaths for quick lookup.
+    // Already-selected items stay selectable (so the same dimension can be
+    // added again on purpose) - they're just flagged so the dropdown can
+    // highlight them instead of blocking the click.
     const selectedFullPaths = new Set(savedDimensions.map(dim => dim.fullPath));
     const items = [];
     // Iterate through aliases (e.g., 'ba', 'pc')
@@ -77990,9 +78043,6 @@ const Dimensions = ({
 
         // Construct the fullPath for this dimension
         const fullPath = `${aliasPath.join("_")}.${dimKey}`;
-
-        // Check if this dimension is already selected
-        const isAlreadySelected = selectedFullPaths.has(fullPath);
         items.push({
           // Include provider name to ensure uniqueness across different providers
           key: `${currentProvider}_${alias}.${dimKey}`,
@@ -78000,7 +78050,7 @@ const Dimensions = ({
           dimensionKey: dimKey,
           alias: alias,
           dimension: dimension,
-          disabled: isAlreadySelected
+          alreadySelected: selectedFullPaths.has(fullPath)
         });
       });
     });
@@ -78062,7 +78112,10 @@ const Dimensions = ({
       dimensionKey: selectedItem.dimensionKey,
       dimensionTitle: selectedItem.value,
       // The constructed path for server
-      fullPath: fullPath
+      fullPath: fullPath,
+      // Unique per-instance identity, so this field can be added more than
+      // once and each occurrence stays independently orderable/removable.
+      id: nextInstanceId(fullPath, savedDimensions)
     };
     onSaveDimension(dimensionData);
     handleCancel();
@@ -78073,8 +78126,9 @@ const Dimensions = ({
   const handleAddAll = () => {
     const dimensionItems = getDimensionItems();
 
-    // Filter out already selected dimensions (disabled items)
-    const availableItems = dimensionItems.filter(item => !item.disabled);
+    // Filter out already selected dimensions - "Add all" only fills in
+    // missing ones; intentional duplicates are added one at a time above.
+    const availableItems = dimensionItems.filter(item => !item.alreadySelected);
     if (availableItems.length === 0) return;
 
     // Build the complete relation objects array (same for all dimensions in this provider)
@@ -78119,7 +78173,10 @@ const Dimensions = ({
         dimensionKey: item.dimensionKey,
         dimensionTitle: item.value,
         // The constructed path for server
-        fullPath: fullPath
+        fullPath: fullPath,
+        // "Add all" only ever adds fields that aren't already selected, so
+        // this is always the first (and only) occurrence of this fullPath.
+        id: fullPath
       };
       onSaveDimension(dimensionData);
     });
@@ -78253,7 +78310,7 @@ const Dimensions = ({
   }, "Cancel"), /*#__PURE__*/gn.createElement(Button, {
     variant: "contained",
     onClick: handleSaveComputed,
-    disabled: !computedName.trim() || !computedValue.trim() || computedNameError,
+    disabled: !computedName.trim() || computedNameError,
     sx: {
       height: "40px",
       fontFamily: "system-ui",
@@ -78329,7 +78386,7 @@ const Dimensions = ({
     placement: "top"
   }, /*#__PURE__*/gn.createElement("span", null, /*#__PURE__*/gn.createElement(IconButton, {
     onClick: handleAddAll,
-    disabled: getDimensionItems().filter(item => !item.disabled).length === 0,
+    disabled: getDimensionItems().filter(item => !item.alreadySelected).length === 0,
     "aria-label": "add all dimensions",
     sx: {
       color: "rgb(70, 134, 128)",
@@ -78420,9 +78477,9 @@ const Dimensions = ({
     isLast: index === orderedItems.length - 1,
     sortOrder: item.data.sortOrder || null,
     onSortOrderChange: sortOrder => handleSortOrderChange(item.key, sortOrder),
-    fullPath: item.data.fullPath,
+    instanceId: item.data.id,
     defaultTitle: item.data.dimensionTitle,
-    customTitle: titleOverrides[item.data.fullPath],
+    customTitle: titleOverrides[item.data.id],
     onUpdateTitle: onUpdateTitle,
     onResetTitle: onResetTitle
   }) : /*#__PURE__*/gn.createElement(SortableComputedChip, {
@@ -78507,7 +78564,7 @@ const SortableChip = ({
   onMoveDown,
   isFirst,
   isLast,
-  fullPath,
+  instanceId,
   defaultTitle,
   customTitle,
   onUpdateTitle,
@@ -78560,7 +78617,7 @@ const SortableChip = ({
       handleCancel();
       return;
     }
-    onUpdateTitle(fullPath, trimmedValue);
+    onUpdateTitle(instanceId, trimmedValue);
     setIsEditing(false);
   };
   const handleCancel = () => {
@@ -78568,7 +78625,7 @@ const SortableChip = ({
     setEditValue('');
   };
   const handleReset = () => {
-    onResetTitle(fullPath);
+    onResetTitle(instanceId);
     setIsEditing(false);
     setEditValue('');
   };
@@ -78789,7 +78846,10 @@ const Metrics = ({
       currentProviderKey = selection.targetKey;
     });
 
-    // Create a Set of already selected metric fullPaths for quick lookup
+    // Create a Set of already selected metric fullPaths for quick lookup.
+    // Already-selected items stay selectable (so the same metric can be
+    // added again on purpose) - they're just flagged so the dropdown can
+    // highlight them instead of blocking the click.
     const selectedFullPaths = new Set(savedMetrics.map(metric => metric.fullPath));
 
     // Metrics are a direct array, not nested by alias
@@ -78797,15 +78857,12 @@ const Metrics = ({
     const items = provider.metrics.map((metric, index) => {
       // Construct the fullPath for this metric
       const fullPath = `${aliasPath.join('_')}.${metric.name}`;
-
-      // Check if this metric is already selected
-      const isAlreadySelected = selectedFullPaths.has(fullPath);
       return {
         key: `${currentProvider}_${metric.name}_${index}`,
         value: metric.title || metric.name,
         metricName: metric.name,
         metric: metric,
-        disabled: isAlreadySelected,
+        alreadySelected: selectedFullPaths.has(fullPath),
         icon: metric.source ? /*#__PURE__*/gn.createElement(MetricSourceIcon, {
           source: metric.source
         }) : undefined
@@ -78868,7 +78925,11 @@ const Metrics = ({
       metricName: selectedItem.metricName,
       metricTitle: selectedItem.value,
       // The constructed path for server
-      fullPath: fullPath
+      fullPath: fullPath,
+      // Unique per-instance identity, so this field can be added more
+      // than once and each occurrence stays independently
+      // orderable/removable/titleable.
+      id: nextInstanceId(fullPath, savedMetrics)
     };
     onSaveMetric(metricData);
     handleCancel();
@@ -78879,8 +78940,9 @@ const Metrics = ({
   const handleAddAll = () => {
     const metricItems = getMetricItems();
 
-    // Filter out already selected metrics (disabled items)
-    const availableItems = metricItems.filter(item => !item.disabled);
+    // Filter out already selected metrics - "Add all" only fills in
+    // missing ones; intentional duplicates are added one at a time above.
+    const availableItems = metricItems.filter(item => !item.alreadySelected);
     if (availableItems.length === 0) return;
 
     // Build the complete relation objects array (same for all metrics in this provider)
@@ -78925,7 +78987,10 @@ const Metrics = ({
         metricName: item.metricName,
         metricTitle: item.value,
         // The constructed path for server
-        fullPath: fullPath
+        fullPath: fullPath,
+        // "Add all" only ever adds fields that aren't already
+        // selected, so this is always the first occurrence.
+        id: fullPath
       };
       onSaveMetric(metricData);
     });
@@ -79024,7 +79089,7 @@ const Metrics = ({
     placement: "top"
   }, /*#__PURE__*/gn.createElement("span", null, /*#__PURE__*/gn.createElement(IconButton, {
     onClick: handleAddAll,
-    disabled: getMetricItems().filter(item => !item.disabled).length === 0,
+    disabled: getMetricItems().filter(item => !item.alreadySelected).length === 0,
     "aria-label": "add all metrics",
     sx: {
       color: "rgb(70, 134, 128)",
@@ -79102,14 +79167,14 @@ const Metrics = ({
     id: index,
     label: metric.metricTitle,
     fullLabel: `${formatProviderPath(metric)} → ${metric.metricTitle} (${metric.fullPath})`,
-    onDelete: () => onRemoveMetric(index),
+    onDelete: () => onRemoveMetric(metric.id),
     onMoveUp: () => handleMoveUp(index),
     onMoveDown: () => handleMoveDown(index),
     isFirst: index === 0,
     isLast: index === savedMetrics.length - 1,
-    fullPath: metric.fullPath,
+    instanceId: metric.id,
     defaultTitle: metric.metricTitle,
-    customTitle: titleOverrides[metric.fullPath],
+    customTitle: titleOverrides[metric.id],
     onUpdateTitle: onUpdateTitle,
     onResetTitle: onResetTitle,
     source: metric.metric?.source
@@ -91282,7 +91347,12 @@ const Filters = ({
       mb: 3
     }
   }, /*#__PURE__*/gn.createElement(SingleSelect, {
-    items: existingDimensions.map(dim => ({
+    items: Array.from(
+    // Dimensions can now be added more than once (same fullPath,
+    // different instance), but a filter targets the underlying
+    // field regardless of how many columns display it - so this
+    // list is deduped by fullPath to avoid showing it twice.
+    new Map(existingDimensions.map(dim => [dim.fullPath, dim])).values()).map(dim => ({
       key: dim.fullPath,
       value: interpolateTitle(dimensionTitleOverrides[dim.fullPath] || dim.dimensionTitle, parameters)
     })).sort((a, b) => a.value.localeCompare(b.value)),
@@ -91869,7 +91939,7 @@ const ColumnOrder = ({
     key: `${item.kind}-${item.key}`,
     id: index,
     label: labelFor(item),
-    fullPath: item.kind === "computed" ? item.data.value : item.key,
+    fullPath: item.kind === "computed" ? item.data.value : item.data.fullPath,
     kind: item.kind,
     source: item.kind === "metric" ? item.data.metric?.source : undefined,
     onMoveUp: () => handleMoveUp(index),
@@ -91895,11 +91965,17 @@ const formatValue = (value, def) => {
 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:
+// (a dimension, computed dimension, or metric). The DataGrid `field` is the
+// item's instance id (so two duplicate instances of the same underlying
+// dimension/metric still get distinct columns); the actual cell value is
+// read via `valueGetter` from `dataFieldName`, the key the API response
+// actually uses - shared by every duplicate instance, since the backend
+// only ever returns one value per fullPath. dataFieldName rules:
 // - 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`.
+//   each row keyed by the computed dimension's own `name` (and can't be
+//   duplicated - names must be unique - so field/dataFieldName coincide).
 // - 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`.
@@ -91917,13 +91993,13 @@ const buildColumn = (item, titleOverrides, parameters) => {
   if (item.kind === 'metric') {
     const metric = item.data;
     const metricDef = metric.metric;
-    let fieldName;
+    let dataFieldName;
     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, '_');
+      dataFieldName = 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"
@@ -91934,19 +92010,24 @@ const buildColumn = (item, titleOverrides, parameters) => {
       const pathParts = pathWithoutField.split('_');
       pathParts.shift(); // remove base provider alias
       const pathWithoutBase = pathParts.join('_');
-      fieldName = pathWithoutBase ? `${pathWithoutBase}_${field}` : field;
+      dataFieldName = 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;
+      dataFieldName = metric.metricName;
     }
-    const headerName = interpolateTitle(titleOverrides.metrics[metric.fullPath] || metric.metricTitle || fieldName, parameters);
+    const headerName = interpolateTitle(titleOverrides.metrics[metric.id] || metric.metricTitle || dataFieldName, parameters);
     return {
-      field: fieldName,
+      // `field` is the instance id (unique even for duplicate columns
+      // pointing at the same underlying metric); the actual value is
+      // read from the row via valueGetter using dataFieldName, which is
+      // the key the API response actually uses (shared across duplicates).
+      field: metric.id.replace(/[.#]/g, '_'),
       headerName: headerName,
       flex: 1,
       minWidth: 150,
       type: isNumericType(metricDef?.type) ? 'number' : 'string',
+      valueGetter: (_value, row) => row[dataFieldName],
       renderHeader: () => /*#__PURE__*/gn.createElement(Box, {
         sx: {
           display: 'flex',
@@ -91962,7 +92043,7 @@ const buildColumn = (item, titleOverrides, parameters) => {
 
   // Dimension
   const dim = item.data;
-  let fieldName;
+  let dataFieldName;
   if (dim.relations && dim.relations.length > 0) {
     // From nested provider: drop the base provider alias
     // Example: ft_fa_db.currency -> fa_db_currency
@@ -91974,20 +92055,24 @@ const buildColumn = (item, titleOverrides, parameters) => {
     pathParts.shift(); // Remove base provider alias
     const pathWithoutBase = pathParts.join('_'); // e.g., "fa_db"
 
-    fieldName = pathWithoutBase ? `${pathWithoutBase}_${field}` : field;
+    dataFieldName = 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('.', '_');
+    dataFieldName = dim.fullPath.replace('.', '_');
   }
-  const headerName = interpolateTitle(titleOverrides.dimensions[dim.fullPath] || dim.dimensionTitle || fieldName, parameters);
+  const headerName = interpolateTitle(titleOverrides.dimensions[dim.id] || dim.dimensionTitle || dataFieldName, parameters);
   const dimDef = dim.dimension;
   return {
-    field: fieldName,
+    // Same rationale as the metric branch above: `field` must be unique
+    // per instance, while the value always comes from the one real
+    // underlying row key (dataFieldName), shared by every duplicate.
+    field: dim.id.replace(/[.#]/g, '_'),
     headerName: headerName,
     flex: 1,
     minWidth: 150,
     type: isNumericType(dimDef?.type) ? 'number' : 'string',
+    valueGetter: (_value, row) => row[dataFieldName],
     valueFormatter: value => formatValue(value, dimDef)
   };
 };
@@ -92313,6 +92398,72 @@ const ReportBuilder = ({
     }
   };
 
+  // Reconstructs saved dimensions as independent, individually-identified
+  // instances so that deliberate duplicates (the same field added more than
+  // once) survive a save/reload round trip. Prefers `ordered_dimensions`
+  // (one ref per instance - the nth duplicate of a path is suffixed
+  // `#n`) when present; falls back to one instance per entry in the
+  // (necessarily duplicate-free) `dimensions` path list for reports saved
+  // before this field existed.
+  const reconstructDimensions = (reportDef, providersData) => {
+    const orderByMap = {};
+    if (reportDef.definition?.doc?.query?.order_by) {
+      for (const orderItem of reportDef.definition.doc.query.order_by) {
+        orderByMap[orderItem.name] = orderItem.desc === true ? "desc" : "asc";
+      }
+    }
+    const reconstructed = [];
+    const orderedRefs = (reportDef.definition?.doc?.query?.ordered_dimensions || []).filter(entry => entry.type === "dimension").map(entry => entry.ref);
+    if (orderedRefs.length > 0) {
+      orderedRefs.forEach(ref => {
+        const fullPath = ref.split("#")[0];
+        const dim = reconstructDimensionFromPath(fullPath, providersData, reportDef.provider);
+        if (dim) {
+          dim.id = ref;
+          dim.sortOrder = orderByMap[fullPath] || null;
+          reconstructed.push(dim);
+        }
+      });
+    } else if (reportDef.definition?.doc?.query?.dimensions) {
+      for (const dimPath of reportDef.definition.doc.query.dimensions) {
+        const dim = reconstructDimensionFromPath(dimPath, providersData, reportDef.provider);
+        if (dim) {
+          dim.id = dimPath;
+          dim.sortOrder = orderByMap[dimPath] || null;
+          reconstructed.push(dim);
+        }
+      }
+    }
+    return reconstructed;
+  };
+
+  // Mirrors reconstructDimensions for metrics, using the analogous
+  // `ordered_metrics` field (metrics have no other unified-order concept to
+  // fall back on, so this is always written whenever there are metrics).
+  const reconstructMetrics = (reportDef, providersData) => {
+    const reconstructed = [];
+    const orderedRefs = reportDef.definition?.doc?.query?.ordered_metrics || [];
+    if (orderedRefs.length > 0) {
+      orderedRefs.forEach(ref => {
+        const fullPath = ref.split("#")[0];
+        const metric = reconstructMetricFromPath(fullPath, providersData, reportDef.provider);
+        if (metric) {
+          metric.id = ref;
+          reconstructed.push(metric);
+        }
+      });
+    } else if (reportDef.definition?.doc?.query?.metrics) {
+      for (const metricPath of reportDef.definition.doc.query.metrics) {
+        const metric = reconstructMetricFromPath(metricPath, providersData, reportDef.provider);
+        if (metric) {
+          metric.id = metricPath;
+          reconstructed.push(metric);
+        }
+      }
+    }
+    return reconstructed;
+  };
+
   // Build the unified display/execution order for dimensions + computed
   // dimensions. Prefers the persisted `ordered_dimensions` field; falls back
   // to "dimensions first, then computed dimensions" for report definitions
@@ -92323,7 +92474,7 @@ const ReportBuilder = ({
     const seenComputedKeys = new Set();
     if (Array.isArray(rawOrderedDimensions)) {
       rawOrderedDimensions.forEach(entry => {
-        if (entry.type === "dimension" && dimensions.some(d => d.fullPath === entry.ref)) {
+        if (entry.type === "dimension" && dimensions.some(d => d.id === entry.ref)) {
           dimensionOrder.push({
             type: "dimension",
             key: entry.ref
@@ -92341,10 +92492,10 @@ const ReportBuilder = ({
 
     // Append anything not covered by ordered_dimensions (older reports, or drift)
     dimensions.forEach(d => {
-      if (!seenDimensionKeys.has(d.fullPath)) {
+      if (!seenDimensionKeys.has(d.id)) {
         dimensionOrder.push({
           type: "dimension",
-          key: d.fullPath
+          key: d.id
         });
       }
     });
@@ -92367,12 +92518,12 @@ const ReportBuilder = ({
   // "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 dimensionIds = new Set(dimensions.map(d => d.id));
     const computedNames = new Set(computedDimensions.map(cd => cd.name));
-    const metricPaths = new Set(metrics.map(m => m.fullPath));
+    const metricIds = new Set(metrics.map(m => m.id));
     const columnOrder = [];
     rawOrderedColumns.forEach(entry => {
-      if (entry.type === "dimension" && dimensionPaths.has(entry.ref)) {
+      if (entry.type === "dimension" && dimensionIds.has(entry.ref)) {
         columnOrder.push({
           type: "dimension",
           key: entry.ref
@@ -92382,7 +92533,7 @@ const ReportBuilder = ({
           type: "computed",
           key: entry.ref
         });
-      } else if (entry.type === "metric" && metricPaths.has(entry.ref)) {
+      } else if (entry.type === "metric" && metricIds.has(entry.ref)) {
         columnOrder.push({
           type: "metric",
           key: entry.ref
@@ -92412,43 +92563,10 @@ const ReportBuilder = ({
       // Set the title
       setReportTitle(reportDef.title || "");
 
-      // Reconstruct dimensions
-      const reconstructedDimensions = [];
-      const orderByMap = {}; // Map to store sort order from order_by array
-
-      // First, build a map of fullPath -> sortOrder from order_by
-      if (reportDef.definition?.doc?.query?.order_by) {
-        for (const orderItem of reportDef.definition.doc.query.order_by) {
-          if (orderItem.desc === true) {
-            orderByMap[orderItem.name] = "desc";
-          } else {
-            orderByMap[orderItem.name] = "asc";
-          }
-        }
-      }
-
-      // Now reconstruct dimensions and add sortOrder from the map
-      if (reportDef.definition?.doc?.query?.dimensions) {
-        for (const dimPath of reportDef.definition.doc.query.dimensions) {
-          const dim = reconstructDimensionFromPath(dimPath, providersData, reportDef.provider);
-          if (dim) {
-            // Add sortOrder from order_by if it exists
-            dim.sortOrder = orderByMap[dimPath] || null;
-            reconstructedDimensions.push(dim);
-          }
-        }
-      }
-
-      // Reconstruct metrics
-      const reconstructedMetrics = [];
-      if (reportDef.definition?.doc?.query?.metrics) {
-        for (const metricPath of reportDef.definition.doc.query.metrics) {
-          const metric = reconstructMetricFromPath(metricPath, providersData, reportDef.provider);
-          if (metric) {
-            reconstructedMetrics.push(metric);
-          }
-        }
-      }
+      // Reconstruct dimensions and metrics as independent instances
+      // (preserving deliberate duplicates - see reconstructDimensions/Metrics)
+      const reconstructedDimensions = reconstructDimensions(reportDef, providersData);
+      const reconstructedMetrics = reconstructMetrics(reportDef, providersData);
 
       // Load title overrides if they exist
       const loadedTitleOverrides = {
@@ -92532,43 +92650,10 @@ const ReportBuilder = ({
       // Set the title (already modified with " (Copy)" suffix)
       setReportTitle(reportDef.title || "");
 
-      // Reconstruct dimensions
-      const reconstructedDimensions = [];
-      const orderByMap = {}; // Map to store sort order from order_by array
-
-      // First, build a map of fullPath -> sortOrder from order_by
-      if (reportDef.definition?.doc?.query?.order_by) {
-        for (const orderItem of reportDef.definition.doc.query.order_by) {
-          if (orderItem.desc === true) {
-            orderByMap[orderItem.name] = "desc";
-          } else {
-            orderByMap[orderItem.name] = "asc";
-          }
-        }
-      }
-
-      // Now reconstruct dimensions and add sortOrder from the map
-      if (reportDef.definition?.doc?.query?.dimensions) {
-        for (const dimPath of reportDef.definition.doc.query.dimensions) {
-          const dim = reconstructDimensionFromPath(dimPath, providersData, reportDef.provider);
-          if (dim) {
-            // Add sortOrder from order_by if it exists
-            dim.sortOrder = orderByMap[dimPath] || null;
-            reconstructedDimensions.push(dim);
-          }
-        }
-      }
-
-      // Reconstruct metrics
-      const reconstructedMetrics = [];
-      if (reportDef.definition?.doc?.query?.metrics) {
-        for (const metricPath of reportDef.definition.doc.query.metrics) {
-          const metric = reconstructMetricFromPath(metricPath, providersData, reportDef.provider);
-          if (metric) {
-            reconstructedMetrics.push(metric);
-          }
-        }
-      }
+      // Reconstruct dimensions and metrics as independent instances
+      // (preserving deliberate duplicates - see reconstructDimensions/Metrics)
+      const reconstructedDimensions = reconstructDimensions(reportDef, providersData);
+      const reconstructedMetrics = reconstructMetrics(reportDef, providersData);
 
       // Load title overrides if they exist
       const loadedTitleOverrides = {
@@ -92667,42 +92752,45 @@ const ReportBuilder = ({
     });
     console.log("Selected root provider:", event.target.value);
   };
-  const handleUpdateDimensionTitle = (fullPath, customTitle) => {
+
+  // Keyed by instance id, so two instances of the same dimension can carry
+  // independent custom titles.
+  const handleUpdateDimensionTitle = (id, customTitle) => {
     setTitleOverrides(prev => ({
       ...prev,
       dimensions: {
         ...prev.dimensions,
-        [fullPath]: customTitle
+        [id]: customTitle
       }
     }));
   };
-  const handleResetDimensionTitle = fullPath => {
+  const handleResetDimensionTitle = id => {
     setTitleOverrides(prev => {
       const newDimensions = {
         ...prev.dimensions
       };
-      delete newDimensions[fullPath];
+      delete newDimensions[id];
       return {
         ...prev,
         dimensions: newDimensions
       };
     });
   };
-  const handleUpdateMetricTitle = (fullPath, customTitle) => {
+  const handleUpdateMetricTitle = (id, customTitle) => {
     setTitleOverrides(prev => ({
       ...prev,
       metrics: {
         ...prev.metrics,
-        [fullPath]: customTitle
+        [id]: customTitle
       }
     }));
   };
-  const handleResetMetricTitle = fullPath => {
+  const handleResetMetricTitle = id => {
     setTitleOverrides(prev => {
       const newMetrics = {
         ...prev.metrics
       };
-      delete newMetrics[fullPath];
+      delete newMetrics[id];
       return {
         ...prev,
         metrics: newMetrics
@@ -92737,11 +92825,11 @@ const ReportBuilder = ({
         dimensions: [...prev.dimensions, dimensionData],
         dimensionOrder: [...prev.dimensionOrder, {
           type: "dimension",
-          key: dimensionData.fullPath
+          key: dimensionData.id
         }],
         columnOrder: appendToColumnOrder(prev.columnOrder, {
           type: "dimension",
-          key: dimensionData.fullPath
+          key: dimensionData.id
         })
       };
       console.log("Dimension saved:", dimensionData);
@@ -92749,22 +92837,30 @@ const ReportBuilder = ({
       return newReport;
     });
   };
-  const handleRemoveDimension = fullPath => {
+  const handleRemoveDimension = id => {
     setReport(prev => ({
       ...prev,
-      dimensions: prev.dimensions.filter(d => d.fullPath !== fullPath),
-      dimensionOrder: prev.dimensionOrder.filter(entry => !(entry.type === "dimension" && entry.key === fullPath)),
-      columnOrder: prev.columnOrder.filter(entry => !(entry.type === "dimension" && entry.key === fullPath))
+      dimensions: prev.dimensions.filter(d => d.id !== id),
+      dimensionOrder: prev.dimensionOrder.filter(entry => !(entry.type === "dimension" && entry.key === id)),
+      columnOrder: prev.columnOrder.filter(entry => !(entry.type === "dimension" && entry.key === id))
     }));
   };
-  const handleUpdateDimensionSortOrder = (fullPath, sortOrder) => {
-    setReport(prev => ({
-      ...prev,
-      dimensions: prev.dimensions.map(d => d.fullPath === fullPath ? {
-        ...d,
-        sortOrder
-      } : d)
-    }));
+
+  // sortOrder is fundamentally a per-field (query-level) setting - SQL can
+  // only sort by a given column once - so toggling it on any instance of a
+  // duplicated dimension applies to every instance sharing that fullPath.
+  const handleUpdateDimensionSortOrder = (id, sortOrder) => {
+    setReport(prev => {
+      const target = prev.dimensions.find(d => d.id === id);
+      if (!target) return prev;
+      return {
+        ...prev,
+        dimensions: prev.dimensions.map(d => d.fullPath === target.fullPath ? {
+          ...d,
+          sortOrder
+        } : d)
+      };
+    });
   };
 
   // Reorders the single unified dimensions + computed-dimensions list;
@@ -92819,7 +92915,7 @@ const ReportBuilder = ({
         metrics: [...prev.metrics, metricData],
         columnOrder: appendToColumnOrder(prev.columnOrder, {
           type: "metric",
-          key: metricData.fullPath
+          key: metricData.id
         })
       };
       console.log("Metric saved:", metricData);
@@ -92827,15 +92923,12 @@ const ReportBuilder = ({
       return newReport;
     });
   };
-  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 handleRemoveMetric = id => {
+    setReport(prev => ({
+      ...prev,
+      metrics: prev.metrics.filter(m => m.id !== id),
+      columnOrder: prev.columnOrder.filter(entry => !(entry.type === "metric" && entry.key === id))
+    }));
   };
   const handleReorderMetrics = newOrder => {
     setReport(prev => ({
@@ -92890,13 +92983,30 @@ const ReportBuilder = ({
   // persisted `ordered_dimensions` field all stay consistent with whatever
   // order the user arranged on screen.
   const buildQueryObject = () => {
-    const dimensionByPath = Object.fromEntries(report.dimensions.map(d => [d.fullPath, d]));
+    const dimensionById = Object.fromEntries(report.dimensions.map(d => [d.id, d]));
     const computedByName = Object.fromEntries(report.computedDimensions.map(cd => [cd.name, cd]));
-    const orderedDimensionsOnly = report.dimensionOrder.filter(entry => entry.type === "dimension").map(entry => dimensionByPath[entry.key]).filter(Boolean);
+
+    // May contain more than one instance of the same fullPath (deliberate
+    // duplicates), kept in dimensionOrder's display order.
+    const orderedDimensionsOnly = report.dimensionOrder.filter(entry => entry.type === "dimension").map(entry => dimensionById[entry.key]).filter(Boolean);
     const orderedComputedOnly = report.dimensionOrder.filter(entry => entry.type === "computed").map(entry => computedByName[entry.key]).filter(Boolean);
 
+    // The API keys each result row by fullPath, so duplicate instances of
+    // the same field can only ever carry one value/one sort direction at
+    // the query level - dedupe by fullPath (keeping first-occurrence order)
+    // before sending. The builder still shows/orders/titles each instance
+    // independently; they just read from the same underlying query column.
+    const uniqueDimensionsByPath = [];
+    const seenDimensionPaths = new Set();
+    orderedDimensionsOnly.forEach(dim => {
+      if (!seenDimensionPaths.has(dim.fullPath)) {
+        seenDimensionPaths.add(dim.fullPath);
+        uniqueDimensionsByPath.push(dim);
+      }
+    });
+
     // Build order_by array - include all dimensions, add desc property only when needed
-    const orderBy = orderedDimensionsOnly.map(dim => {
+    const orderBy = uniqueDimensionsByPath.map(dim => {
       const orderItem = {
         name: dim.fullPath
       };
@@ -92951,9 +93061,20 @@ const ReportBuilder = ({
     if (Object.keys(titleOverrides.filters).length > 0) {
       titles.filters = titleOverrides.filters;
     }
+
+    // Same dedupe rationale as dimensions above: the query only needs each
+    // metric fullPath once, however many display instances reference it.
+    const uniqueMetricPaths = [];
+    const seenMetricPaths = new Set();
+    report.metrics.forEach(metric => {
+      if (!seenMetricPaths.has(metric.fullPath)) {
+        seenMetricPaths.add(metric.fullPath);
+        uniqueMetricPaths.push(metric.fullPath);
+      }
+    });
     const queryObj = {
-      dimensions: orderedDimensionsOnly.map(dim => dim.fullPath),
-      metrics: report.metrics.map(metric => metric.fullPath),
+      dimensions: uniqueDimensionsByPath.map(dim => dim.fullPath),
+      metrics: uniqueMetricPaths,
       order_by: orderBy
     };
 
@@ -92967,7 +93088,9 @@ const ReportBuilder = ({
 
     // Persist the unified dimension + computed-dimension order so it can be
     // reconstructed on reload and so executed reports render columns in the
-    // same order they were arranged in the builder.
+    // same order they were arranged in the builder. Entries use each
+    // dimension's instance id as `ref`, so deliberate duplicates (the nth
+    // occurrence of a fullPath is suffixed `#n`) round-trip correctly.
     if (report.dimensionOrder.length > 0) {
       queryObj.ordered_dimensions = report.dimensionOrder.map(entry => ({
         type: entry.type,
@@ -92975,6 +93098,12 @@ const ReportBuilder = ({
       }));
     }
 
+    // Persist metric instance order/identity the same way (metrics have no
+    // other unified-order field to piggyback on).
+    if (report.metrics.length > 0) {
+      queryObj.ordered_metrics = report.metrics.map(metric => metric.id);
+    }
+
     // 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
@@ -93144,11 +93273,11 @@ const ReportBuilder = ({
 
   // Resolve the unified dimensionOrder into actual dimension/computed-dimension
   // objects so the results grid can render columns in that same order.
-  const dimensionByFullPath = Object.fromEntries(report.dimensions.map(d => [d.fullPath, d]));
+  const dimensionById = Object.fromEntries(report.dimensions.map(d => [d.id, d]));
   const computedDimensionByName = Object.fromEntries(report.computedDimensions.map(cd => [cd.name, cd]));
   const orderedDimensionItems = report.dimensionOrder.map(entry => entry.type === "dimension" ? {
     kind: "dimension",
-    data: dimensionByFullPath[entry.key]
+    data: dimensionById[entry.key]
   } : {
     kind: "computed",
     data: computedDimensionByName[entry.key]