@quillsql/react 2.16.79 → 2.16.80

package/dist/index.js

@@ -15076,46 +15076,12 @@ function parseQueryDateRangeByDatabaseType(minRange, maxRange, databaseType) {
   }
 }
 function getDateFormatFromBucket(dateBucket) {
-  let format9 = "MMM_yyyy";
-  switch (dateBucket) {
-    case "day":
-      format9 = "MMM_dd";
-      break;
-    case "week":
-      format9 = "MMM_dd-MMM_dd";
-      break;
-    case "month":
-      format9 = "MMM_yyyy";
-      break;
-    case "year":
-      format9 = "yyyy";
-      break;
-    default:
-      format9 = "MMM_yyyy";
-      break;
-  }
-  return format9;
+  return DATE_BUCKET_AXIS_FORMATS[dateBucket] ?? "MMM_yyyy";
 }
 function getDateString(value, dateRange, dateBucket, databaseType) {
   let format9;
   if (dateBucket) {
-    switch (dateBucket) {
-      case "day":
-        format9 = "MMM_dd";
-        break;
-      case "week":
-        format9 = "MMM_dd-MMM_dd";
-        break;
-      case "month":
-        format9 = "MMM_yyyy";
-        break;
-      case "year":
-        format9 = "yyyy";
-        break;
-      default:
-        format9 = "MMM_yyyy";
-        break;
-    }
+    format9 = getDateFormatFromBucket(dateBucket);
   } else {
     if (!dateRange) {
       format9 = "MMM_yyyy";
@@ -15204,12 +15170,19 @@ function getExclusiveDateBucketRange(startInput, bucket) {
     endExclusive: endExclusive.toISOString()
   };
 }
+var DATE_BUCKET_AXIS_FORMATS;
 var init_dates = __esm({
   "src/utils/dates.ts"() {
     "use strict";
     init_dateRangePickerUtils();
     init_inMemoryPivotEngine();
     init_valueFormatter();
+    DATE_BUCKET_AXIS_FORMATS = {
+      day: "MMM_dd_yyyy",
+      week: "MMM_dd-MMM_dd",
+      month: "MMM_yyyy",
+      year: "yyyy"
+    };
   }
 });
 
@@ -21354,6 +21327,22 @@ init_dates();
 init_pivotConstructor();
 init_columnProcessing();
 init_paginationProcessing();
+
+// src/utils/dashboardProfiler.ts
+function profileDashboard(event, data) {
+  if (typeof window === "undefined") return;
+  const profileWindow = window;
+  if (!profileWindow.__QUILL_DASHBOARD_PROFILE__) return;
+  const entry = {
+    at: Math.round(performance.now() * 10) / 10,
+    event,
+    data
+  };
+  profileWindow.__QUILL_DASHBOARD_TRACE__ ??= [];
+  profileWindow.__QUILL_DASHBOARD_TRACE__.push(entry);
+}
+
+// src/utils/dashboard.ts
 var defaultDashboardItem = {
   id: "",
   name: "",
@@ -21439,6 +21428,15 @@ async function cleanDashboardItem({
     const pivotChartProcessing = {
       page: DEFAULT_PAGINATION
     };
+    profileDashboard("clean-dashboard-pivot-path", {
+      reportId: item._id ?? item.id ?? null,
+      chartType: item.chartType,
+      skipPivotFetch: !!skipPivotFetch,
+      hasRows: !!item.rows,
+      rowCount: item.rows?.length ?? 0,
+      hasFields: !!item.fields,
+      path: item.pivot && skipPivotFetch && item.rows && item.fields ? "process-locally" : "get-pivot-table"
+    });
     if (item.pivot && skipPivotFetch && item.rows && item.fields) {
       const pivotSourceRows = item.rows.map((row) => ({ ...row }));
       const dateFilter = dashboardFilters?.find(
@@ -21546,6 +21544,7 @@ async function cleanDashboardItem({
     pivotColumns: pivotTable ? pivotTable.columns : void 0,
     compareRows: item.compareRows,
     showLegend: item.showLegend ?? false,
+    chartSort: item.chartSort,
     columns: processedColumns.map((column) => {
       return {
         field: column.field,
@@ -21746,6 +21745,32 @@ init_filterProcessing();
 
 // src/utils/chartBuilder.ts
 init_textProcessing();
+var MAX_CHART_ROWS = 500;
+var MAX_CHART_MARKS = 5e3;
+var UNLIMITED_CHART_TYPES = /* @__PURE__ */ new Set([
+  "metric",
+  "table",
+  "gauge",
+  "us map",
+  "world map"
+]);
+function getChartRenderLimitError(report) {
+  if (!report) return void 0;
+  if (UNLIMITED_CHART_TYPES.has(report.chartType?.toLowerCase() ?? "")) {
+    return void 0;
+  }
+  const rowCount = report.pivot ? report.pivotRowCount ?? report.pivotRows?.length ?? report.rows?.length : report.rowCount ?? report.rows?.length;
+  if (rowCount !== void 0 && rowCount > MAX_CHART_ROWS) {
+    return `Charts can only display ${MAX_CHART_ROWS} rows. Please modify the query.`;
+  }
+  const renderedRows = report.rows?.length ?? 0;
+  const renderedSeries = Math.max(report.yAxisFields?.length ?? 0, 1);
+  const renderedMarks = renderedRows * renderedSeries;
+  if (renderedMarks > MAX_CHART_MARKS) {
+    return `Charts can only render ${MAX_CHART_MARKS.toLocaleString()} data points. This chart would render ${renderedMarks.toLocaleString()}. Please reduce the number of rows or series.`;
+  }
+  return void 0;
+}
 function isStackedChartType(chartType) {
   const normalized = chartType?.toLowerCase();
   return normalized === "stacked" || normalized === "stacked bar";
@@ -22348,6 +22373,376 @@ async function fetchPivotTemplateReportForUseForm({
   }
 }
 
+// src/utils/color.ts
+var DEFAULT_GRADIENT_COLORS = [
+  "#4E80EE",
+  // vivid indigo
+  "#586FF4",
+  "#6464FA",
+  "#715AFE",
+  "#8450FF",
+  "#9B48FF",
+  "#B33FFF",
+  "#CA37F3",
+  "#DE2FE1",
+  "#F028CB",
+  "#FF20B5"
+];
+function generateArrayFromColor(colors, length) {
+  if (length <= 0) {
+    return [];
+  }
+  if (typeof colors === "string") {
+    const trimmedColor = colors.trim();
+    return monochromaticInterpolation(
+      trimmedColor.length > 0 ? trimmedColor : DEFAULT_GRADIENT_COLORS[0],
+      length
+    );
+  }
+  const normalizedColors = colors.filter((color) => typeof color === "string").map((color) => color.trim()).filter((color) => color.length > 0);
+  const baseColors = normalizedColors.length > 0 ? normalizedColors : DEFAULT_GRADIENT_COLORS;
+  if (baseColors.length === 1) {
+    return monochromaticInterpolation(baseColors[0], length);
+  }
+  if (length <= baseColors.length) {
+    return baseColors.slice(0, length);
+  }
+  const pairs = baseColors.length - 1;
+  if (pairs <= 0) {
+    return [baseColors[0]];
+  }
+  const needed = length - baseColors.length;
+  const baseAmount = Math.floor(needed / pairs);
+  const extras = needed % pairs;
+  let result = [];
+  let i = 0;
+  let j = 1;
+  while (j < baseColors.length) {
+    const additional = i < extras ? 1 : 0;
+    const interpLength = 2 + baseAmount + additional;
+    const interp = interpolateBetween(
+      baseColors[i],
+      baseColors[j],
+      interpLength
+    );
+    const lastIndex = j === baseColors.length - 1 ? void 0 : -1;
+    result = result.concat(interp.slice(0, lastIndex));
+    i++;
+    j++;
+  }
+  return result;
+}
+function buildSeriesColorMap(keys, colors) {
+  const uniqueKeys = [
+    ...new Set(keys.map((key) => key.replace("comparison_", "")))
+  ].sort();
+  const palette = generateArrayFromColor(colors, uniqueKeys.length);
+  return Object.fromEntries(
+    uniqueKeys.map((key, index) => [key, palette[index]])
+  );
+}
+function hexToRgb(hex) {
+  const r = parseInt(hex.substring(1, 3), 16);
+  const g = parseInt(hex.substring(3, 5), 16);
+  const b = parseInt(hex.substring(5, 7), 16);
+  return { r, g, b };
+}
+function rgbToHex(rgb) {
+  const rHex = rgb.r.toString(16).padStart(2, "0");
+  const gHex = rgb.g.toString(16).padStart(2, "0");
+  const bHex = rgb.b.toString(16).padStart(2, "0");
+  return `#${rHex}${gHex}${bHex}`;
+}
+function colorToHSL(color) {
+  const colorHex = namedColorToHex(color);
+  const { r, g, b } = hexToRgb(colorHex);
+  return rgbToHsl(r, g, b);
+}
+function interpolateBetween(leftColor, rightColor, length = 3) {
+  const [h, s, _l] = colorToHSL(leftColor);
+  const [h2, s2, _l2] = colorToHSL(rightColor);
+  const hues = linspace(h, h2, length);
+  const saturations = linspace(s, s2, length);
+  const lightnesses = linspace(_l, _l2, length);
+  return Array.from({ length }).map((_, i) => {
+    const [r, g, b] = HSLtoRGB(hues[i], saturations[i], lightnesses[i]);
+    return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+  });
+}
+function monochromaticInterpolation(color, length) {
+  const [h, s] = colorToHSL(color);
+  const hues = linspace(h, h, length);
+  const saturations = linspace(s, s, length);
+  const lightnesses = linspace(0.6, 0.9, length);
+  return Array.from({ length }).map((_, i) => {
+    const [r, g, b] = HSLtoRGB(hues[i], saturations[i], lightnesses[i]);
+    return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
+  });
+}
+function linspace(start, end, num) {
+  if (num <= 1) return [start];
+  const step = (end - start) / (num - 1);
+  const result = new Array(num);
+  for (let i = 0; i < num; i++) {
+    result[i] = start + step * i;
+  }
+  return result;
+}
+function stableColorIndex(field) {
+  let hash = 0;
+  for (const character of field.replace("comparison_", "")) {
+    hash = Math.imul(hash, 31) + character.charCodeAt(0) >>> 0;
+  }
+  return hash;
+}
+function selectColor(element, colors, index) {
+  if (!element?.field) return "gray";
+  const isComparison = element.field.includes("comparison_");
+  const color = colors[index % colors.length] ?? "";
+  if (!isComparison) {
+    return color;
+  }
+  if (Object.keys(COLOR_TO_HEX).includes(color)) {
+    const colorHex = COLOR_TO_HEX[color];
+    const rgbArray = hexToRGB(colorHex);
+    return toGrayscale(rgbArray);
+  }
+  if (color?.startsWith("#")) {
+    const rgbArray = hexToRGB(color);
+    return toGrayscale(rgbArray);
+  }
+  return "gray";
+}
+function hexToRGB(hex) {
+  const regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i;
+  const result = regex.exec(hex);
+  if (result) {
+    return [
+      parseInt(result[1], 16),
+      // index 0 is whole string, then ()'s
+      parseInt(result[2], 16),
+      parseInt(result[3], 16),
+      ...result[4] ? [parseInt(result[4], 16)] : []
+      // <- alpha channel
+    ];
+  }
+  const rgba = hex.match(/[0-9.]+/g);
+  if (rgba) {
+    return [
+      Number(rgba[0]),
+      Number(rgba[1]),
+      Number(rgba[2]),
+      ...rgba[3] ? [Number(rgba[3])] : []
+    ];
+  }
+  return [128, 128, 128];
+}
+function toGrayscale(rgba) {
+  if (rgba.length < 3) return "rbg(128, 128, 128)";
+  let sum = 0;
+  sum += Number(rgba[0] * 0.89);
+  sum += Number(rgba[1] * 1.77);
+  sum += Number(rgba[2] * 0.33);
+  const avg = (sum / 3).toFixed(2);
+  return `rgb(${avg}, ${avg}, ${avg})`;
+}
+function namedColorToHex(color) {
+  if (Object.keys(COLOR_TO_HEX).includes(color)) {
+    return COLOR_TO_HEX[color];
+  }
+  return color;
+}
+var COLOR_TO_HEX = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgrey: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370d8",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#d87093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+function rgbToHsl(r, g, b) {
+  r /= 255, g /= 255, b /= 255;
+  const max2 = Math.max(r, g, b), min2 = Math.min(r, g, b);
+  let h = (max2 + min2) / 2;
+  let s = (max2 + min2) / 2;
+  const l = (max2 + min2) / 2;
+  if (max2 == min2) {
+    h = s = 0;
+  } else {
+    const d = max2 - min2;
+    s = l > 0.5 ? d / (2 - max2 - min2) : d / (max2 + min2);
+    switch (max2) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return [h, s, l];
+}
+function HSLtoRGB(h, s, l) {
+  let r, g, b;
+  if (s == 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return [r * 255, g * 255, b * 255];
+}
+
 // src/utils/report.ts
 init_columnProcessing();
 init_dataFetcher();
@@ -22361,90 +22756,514 @@ init_valueFormatter();
 init_astFilterProcessing();
 init_reportBuilder();
 init_astProcessing();
-function extractAllReportValuesFromQuillInternalReport(reportInternal) {
-  return {
-    id: reportInternal.id,
-    name: reportInternal.name,
-    dashboardName: reportInternal.dashboardName,
-    // section: reportInternal.section,
-    pagination: reportInternal.pagination,
-    sort: reportInternal.sort,
-    rows: reportInternal.rows,
-    columns: reportInternal.columns,
-    chartType: reportInternal.chartType,
-    dateField: reportInternal.dateField,
-    pivot: reportInternal.pivot,
-    xAxisLabel: reportInternal.xAxisLabel,
-    xAxisField: reportInternal.xAxisField,
-    xAxisFormat: reportInternal.xAxisFormat,
-    yAxisFields: reportInternal.yAxisFields,
-    order: reportInternal.order,
-    compareRows: reportInternal.compareRows,
-    filtersApplied: reportInternal.filtersApplied,
-    queryString: reportInternal.queryString,
-    rowCount: reportInternal.rowCount,
-    template: reportInternal.template,
-    referenceLineYValues: reportInternal.referenceLineYValues,
-    referenceLines: reportInternal.referenceLines,
-    includeCustomFields: reportInternal.includeCustomFields,
-    columnsWithCustomFields: reportInternal.columnsWithCustomFields,
-    pivotRows: reportInternal.pivotRows,
-    pivotColumns: reportInternal.pivotColumns,
-    pivotRowCount: reportInternal.pivotRowCount,
-    filterMap: reportInternal.filterMap,
-    showLegend: reportInternal.showLegend
-  };
+
+// src/utils/chartSort.ts
+init_columnProcessing();
+
+// src/utils/pivotAggregations.ts
+function getPivotAggregations(report) {
+  const pivot = report.pivot;
+  if (!pivot) return [];
+  if ("aggregations" in pivot && Array.isArray(pivot.aggregations)) {
+    return pivot.aggregations;
+  }
+  if ("aggregationType" in pivot && pivot.aggregationType) {
+    return [
+      {
+        aggregationType: pivot.aggregationType,
+        valueField: pivot.valueField,
+        valueField2: pivot.valueField2,
+        valueField2Type: pivot.valueField2Type,
+        valueFieldType: pivot.valueFieldType
+      }
+    ];
+  }
+  return [];
 }
-async function fetchReportRows({
-  reportId,
-  client,
-  tenants,
-  filters = [],
-  getToken,
-  abortSignal,
-  additionalProcessing,
-  overwriteCache = false
-}) {
-  const fetchResp = await quillFetch({
-    client,
-    task: "report",
-    metadata: {
-      reportId,
-      clientId: client.id,
-      databaseType: client.databaseType,
-      filters: filters.map((filter) => ({ ...filter, options: void 0 })),
-      useNewNodeSql: true,
-      tenants,
-      additionalProcessing,
-      overwriteCache
-    },
-    abortSignal,
-    getToken
-  });
-  const resp = await parseFetchResponse(client, "report", fetchResp, getToken);
-  if (client.databaseType?.toLowerCase() === "bigquery") {
-    parseValueFromBigQueryDates(resp.rows, resp.fields);
+function getAggregationFieldKey(aggregation, hasMultipleAggregations) {
+  if (!aggregation.aggregationType) return null;
+  if (!aggregation.valueField && aggregation.aggregationType === "percentage") {
+    return "percentage";
   }
-  return {
-    rows: resp.rows || [],
-    rowCount: resp.rowCount || 0,
-    columns: resp.columns || [],
-    fields: resp.fields || []
-  };
+  if (aggregation.valueField) {
+    return hasMultipleAggregations ? `${aggregation.valueField}_${aggregation.aggregationType}` : aggregation.valueField;
+  }
+  return hasMultipleAggregations ? `${aggregation.aggregationType}_${aggregation.aggregationType}` : aggregation.aggregationType;
 }
-async function fetchReport({
-  reportId,
-  client,
-  tenants,
-  flags,
-  useReportTask = true,
-  filters = [],
-  additionalProcessing,
-  dateBucket,
-  customFields,
-  rowsOnly,
-  rowCountOnly,
-  abortSignal,
+function getAggregationIdentityKey(aggregation) {
+  if (!aggregation) return "";
+  const aggregationType = String(aggregation.aggregationType ?? "").trim().toLowerCase();
+  const valueField = String(aggregation.valueField ?? "").trim().toLowerCase();
+  return `${aggregationType}::${valueField}`;
+}
+function trimFieldSuffix(value, suffix) {
+  const normalizedSuffix = String(suffix ?? "").trim();
+  if (!normalizedSuffix) return value;
+  for (const separator of ["_", ":"]) {
+    const ending = `${separator}${normalizedSuffix}`;
+    if (value.endsWith(ending)) {
+      return value.slice(0, -ending.length);
+    }
+  }
+  return value;
+}
+function getPivotColumnValueForSeries(field, aggregation, hasMultipleAggregations) {
+  let value = String(field ?? "").replace(/^comparison_/, "").trim();
+  if (hasMultipleAggregations) {
+    value = trimFieldSuffix(value, aggregation.aggregationType);
+  }
+  return trimFieldSuffix(value, aggregation.valueField);
+}
+function trailingPivotMeasureSegmentBeforeAggType(normalizedField, normalizedAggregationType) {
+  const suffix = `_${normalizedAggregationType}`;
+  if (!normalizedField.endsWith(suffix)) return null;
+  const base = normalizedField.slice(0, -suffix.length);
+  const lastUnderscore = base.lastIndexOf("_");
+  if (lastUnderscore < 0) return null;
+  const candidate = base.slice(lastUnderscore + 1).trim();
+  return candidate || null;
+}
+var PIVOT_FIELD_AGG_MATCH_TIER = {
+  looseAggSuffix: 1,
+  rawValueField: 2,
+  pivotWideValueAndAggSuffix: 3,
+  canonicalValueAggOrCount: 4
+};
+function matchPivotFieldToAggregationTier(normalizedField, aggregation) {
+  const aggregationType = String(aggregation.aggregationType ?? "").trim();
+  if (!aggregationType) return null;
+  const type = aggregationType.toLowerCase();
+  const valueField = String(aggregation.valueField ?? "").trim().toLowerCase();
+  if (!valueField && normalizedField === type) {
+    return PIVOT_FIELD_AGG_MATCH_TIER.canonicalValueAggOrCount;
+  }
+  if (valueField && normalizedField === valueField) {
+    return PIVOT_FIELD_AGG_MATCH_TIER.rawValueField;
+  }
+  if (valueField && normalizedField === `${valueField}_${type}`) {
+    return PIVOT_FIELD_AGG_MATCH_TIER.canonicalValueAggOrCount;
+  }
+  if (valueField && normalizedField.endsWith(`_${valueField}_${type}`)) {
+    return PIVOT_FIELD_AGG_MATCH_TIER.pivotWideValueAndAggSuffix;
+  }
+  if (normalizedField.endsWith(`_${type}`) || normalizedField.endsWith(`:${type}`)) {
+    const embeddedMeasure = trailingPivotMeasureSegmentBeforeAggType(
+      normalizedField,
+      type
+    );
+    if (embeddedMeasure && valueField && embeddedMeasure !== valueField) {
+      return null;
+    }
+    return PIVOT_FIELD_AGG_MATCH_TIER.looseAggSuffix;
+  }
+  return null;
+}
+function findAggregationForFieldStrict(field, aggregations) {
+  const normalizedField = String(field ?? "").trim().toLowerCase();
+  let best;
+  for (let index = 0; index < aggregations.length; index++) {
+    const aggregation = aggregations[index];
+    const tier = matchPivotFieldToAggregationTier(normalizedField, aggregation);
+    if (tier == null) continue;
+    if (!best || tier > best.tier || tier === best.tier && index < best.index) {
+      best = { aggregation, tier, index };
+    }
+  }
+  return best?.aggregation;
+}
+
+// src/utils/chartSort.ts
+var ROW_SORT_CHART_TYPES = /* @__PURE__ */ new Set([
+  "column",
+  "stacked",
+  "stacked bar",
+  "line",
+  "radar",
+  "bar",
+  "pie"
+]);
+var TWO_DIMENSIONAL_SORT_CHART_TYPES = /* @__PURE__ */ new Set([
+  "column",
+  "stacked",
+  "stacked bar",
+  "line",
+  "radar"
+]);
+var directionLabel = (direction) => direction === "DESC" ? "descending" : "ascending";
+function dimensionOrderLabel(report, field, direction) {
+  const fieldType = String(
+    field === report.pivot?.rowField ? report.pivot.rowFieldType : field === report.pivot?.columnField ? report.pivot.columnFieldType : ""
+  ).toLowerCase();
+  const format9 = field === report.xAxisField ? String(report.xAxisFormat ?? "") : "";
+  const isDate = /date|time/.test(fieldType) || /^(date|yyyy|MMM_|hh_)/.test(format9);
+  const isNumber = /int|number|numeric|decimal|float|double/.test(fieldType) || /^(whole_number|one_decimal_place|two_decimal_places|percent|dollar_)/.test(
+    format9
+  );
+  if (isDate) {
+    return direction === "ASC" ? "oldest to newest" : "newest to oldest";
+  }
+  if (isNumber) {
+    return direction === "ASC" ? "low to high" : "high to low";
+  }
+  return direction === "ASC" ? "A to Z" : "Z to A";
+}
+function formatChartSortValue(chartSort) {
+  if (!chartSort?.field) return "";
+  return `${chartSort.target}:${chartSort.field} ${directionLabel(
+    chartSort.direction
+  )}`;
+}
+function parseChartSortValue(value) {
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) return void 0;
+  const match = trimmed.match(/^(rows|series):(.*)\s+(ascending|descending)$/i);
+  if (!match) return void 0;
+  const target = String(match[1]).toLowerCase();
+  const field = String(match[2] ?? "").trim();
+  if (!field) return void 0;
+  return {
+    target,
+    field,
+    direction: String(match[3]).toLowerCase() === "descending" ? "DESC" : "ASC"
+  };
+}
+function getSupportedChartSortTargets(report) {
+  const chartType = String(report.chartType ?? "").toLowerCase();
+  const rowField = String(report.pivot?.rowField ?? "").trim();
+  const columnField = String(report.pivot?.columnField ?? "").trim();
+  if (report.pivot && !rowField) return [];
+  if (rowField && columnField) {
+    return TWO_DIMENSIONAL_SORT_CHART_TYPES.has(chartType) ? ["rows", "series"] : [];
+  }
+  return ROW_SORT_CHART_TYPES.has(chartType) ? ["rows"] : [];
+}
+function getChartSortOptions(report) {
+  if (!report || getSupportedChartSortTargets(report).length === 0) return [];
+  const rowField = String(
+    report.pivot?.rowField || report.xAxisField || ""
+  ).trim();
+  const columnField = String(report.pivot?.columnField ?? "").trim();
+  const isTwoDimensional = Boolean(rowField && columnField);
+  const aggregations = getPivotAggregations(report);
+  const totals = aggregations.flatMap((aggregation) => {
+    const field = getAggregationFieldKey(aggregation, aggregations.length > 1);
+    return field ? [
+      {
+        field,
+        label: `Total ${getPivotAggregationLabel(report, aggregation)}`
+      }
+    ] : [];
+  });
+  const groups = isTwoDimensional ? [
+    {
+      target: "rows",
+      targetField: rowField,
+      targetLabel: getReportFieldLabel(report, rowField),
+      fields: [
+        { field: rowField, label: getReportFieldLabel(report, rowField) },
+        ...totals
+      ]
+    },
+    {
+      target: "series",
+      targetField: columnField,
+      targetLabel: getReportFieldLabel(report, columnField),
+      fields: [
+        {
+          field: columnField,
+          label: getReportFieldLabel(report, columnField)
+        },
+        ...totals
+      ]
+    }
+  ] : [
+    {
+      target: "rows",
+      targetField: rowField,
+      targetLabel: report.pivot?.rowField ? getReportFieldLabel(report, rowField) : String(report.xAxisLabel || rowField).trim(),
+      fields: [
+        {
+          field: rowField,
+          label: report.pivot?.rowField ? getReportFieldLabel(report, rowField) : String(report.xAxisLabel || rowField).trim()
+        },
+        ...(report.yAxisFields ?? []).filter(({ field }) => !String(field).startsWith("comparison_")).map(({ field, label }) => ({
+          field: String(field ?? "").trim(),
+          label: String(label || field || "").trim()
+        }))
+      ]
+    }
+  ];
+  return groups.flatMap(
+    ({ target, targetField, targetLabel, fields }) => Array.from(
+      new Map(
+        fields.filter(({ field }) => Boolean(field)).map((field) => [field.field, field])
+      ).values()
+    ).flatMap(
+      ({ field, label }) => ["ASC", "DESC"].map((direction) => ({
+        label: field === targetField ? `${targetLabel} \u2014 ${dimensionOrderLabel(
+          report,
+          targetField,
+          direction
+        )}` : `${targetLabel} by ${label || field} \u2014 ${direction === "ASC" ? "low to high" : "high to low"}`,
+        value: formatChartSortValue({ target, field, direction })
+      }))
+    )
+  );
+}
+function getReportFieldLabel(report, field) {
+  const pivotFilter = field === report.pivot?.rowField ? report.pivot.rowFilter : field === report.pivot?.columnField ? report.pivot.columnFilter : null;
+  if (pivotFilter?.label) return pivotFilter.label;
+  return report.columns.find(
+    (column) => column.field === field || column.field.endsWith(`.${field}`)
+  )?.label ?? field.split(".").pop().replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function getPivotAggregationLabel(report, aggregation) {
+  const aggregationLabel = aggregation.aggregationType ? formatAggregationTypeForDisplay(
+    aggregation.aggregationType
+  ) : "Value";
+  const valueField = String(aggregation.valueField ?? "").trim();
+  if (!valueField) return aggregationLabel;
+  const valueLabel = report.columns.find(({ field }) => field === valueField)?.label || valueField.replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+  if (aggregation.aggregationType === "sum") return valueLabel;
+  return `${aggregationLabel} ${valueLabel}`;
+}
+function isEmpty(value) {
+  return value === null || value === void 0 || value === "";
+}
+function getNumericValue(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  const normalized = String(value ?? "").trim().replace(/[$£€¥,%\s,]/g, "");
+  if (!normalized) return void 0;
+  const parsed = Number(normalized);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function compareValues2(left, right) {
+  const leftNumber = getNumericValue(left);
+  const rightNumber = getNumericValue(right);
+  if (leftNumber !== void 0 && rightNumber !== void 0) {
+    return leftNumber - rightNumber;
+  }
+  return String(left).localeCompare(String(right), void 0, {
+    numeric: true,
+    sensitivity: "base"
+  });
+}
+function getPivotSeries(report) {
+  const aggregations = getPivotAggregations(report);
+  const hasMultipleAggregations = aggregations.length > 1;
+  return report.yAxisFields.map((axis, index) => {
+    const normalizedField = axis.field.replace(/^comparison_/, "");
+    const aggregation = aggregations.length === 1 ? aggregations[0] : findAggregationForFieldStrict(normalizedField, aggregations);
+    return {
+      axis,
+      index,
+      aggregationIdentity: getAggregationIdentityKey(aggregation),
+      columnValue: aggregation ? getPivotColumnValueForSeries(
+        normalizedField,
+        aggregation,
+        hasMultipleAggregations
+      ) : normalizedField
+    };
+  });
+}
+function compareText(left, right) {
+  return left.localeCompare(right, void 0, {
+    numeric: true,
+    sensitivity: "base"
+  });
+}
+function applyTwoDimensionalPivotSeriesSort(report, chartSort) {
+  const columnField = String(report.pivot?.columnField ?? "").trim();
+  if (!columnField) return report;
+  const multiplier = chartSort.direction === "DESC" ? -1 : 1;
+  const series = getPivotSeries(report);
+  const aggregations = getPivotAggregations(report);
+  let compareColumnValues;
+  if (chartSort.field === columnField) {
+    compareColumnValues = (left, right) => compareText(left, right) * multiplier;
+  } else {
+    const selectedAggregation = aggregations.find(
+      (aggregation) => getAggregationFieldKey(aggregation, aggregations.length > 1) === chartSort.field
+    );
+    if (!selectedAggregation) return report;
+    const selectedIdentity = getAggregationIdentityKey(selectedAggregation);
+    const totals = /* @__PURE__ */ new Map();
+    for (const entry of series) {
+      if (entry.axis.field.startsWith("comparison_") || entry.aggregationIdentity !== selectedIdentity) {
+        continue;
+      }
+      const total = report.rows.reduce(
+        (sum, row) => sum + (getNumericValue(row[entry.axis.field]) ?? 0),
+        0
+      );
+      totals.set(entry.columnValue, total);
+    }
+    compareColumnValues = (left, right) => {
+      const compared = (totals.get(left) ?? 0) - (totals.get(right) ?? 0);
+      return compared === 0 ? compareText(left, right) : compared * multiplier;
+    };
+  }
+  const yAxisFields = [...series].sort((left, right) => {
+    const compared = compareColumnValues(left.columnValue, right.columnValue);
+    return compared === 0 ? left.index - right.index : compared;
+  }).map(({ axis }) => axis);
+  return {
+    ...report,
+    chartSort,
+    yAxisFields
+  };
+}
+function applyChartRowSort(report, chartSort) {
+  const { field, direction } = chartSort;
+  const multiplier = direction === "DESC" ? -1 : 1;
+  const rowField = String(
+    report.pivot?.rowField || report.xAxisField || ""
+  ).trim();
+  const aggregations = getPivotAggregations(report);
+  const selectedAggregation = aggregations.find(
+    (aggregation) => getAggregationFieldKey(aggregation, aggregations.length > 1) === field
+  );
+  const selectedIdentity = getAggregationIdentityKey(selectedAggregation);
+  const totalSeries = selectedAggregation ? getPivotSeries(report).filter(
+    (series) => !series.axis.field.startsWith("comparison_") && series.aggregationIdentity === selectedIdentity
+  ) : [];
+  const getSortValue = (row) => {
+    const rawDate = row.__quillRawDate;
+    if (field === rowField && rawDate !== null && rawDate !== void 0 && rawDate !== "") {
+      return rawDate;
+    }
+    if (selectedAggregation && report.pivot?.columnField) {
+      return totalSeries.reduce(
+        (total, series) => total + (getNumericValue(row[series.axis.field]) ?? 0),
+        0
+      );
+    }
+    return row[field];
+  };
+  const rows = report.rows.map((row, index) => ({ row, index })).sort((left, right) => {
+    const leftValue = getSortValue(left.row);
+    const rightValue = getSortValue(right.row);
+    if (isEmpty(leftValue) && isEmpty(rightValue)) {
+      return left.index - right.index;
+    }
+    if (isEmpty(leftValue)) return 1;
+    if (isEmpty(rightValue)) return -1;
+    const compared = compareValues2(leftValue, rightValue);
+    return compared === 0 ? left.index - right.index : compared * multiplier;
+  }).map(({ row }) => row);
+  return {
+    ...report,
+    chartSort,
+    rows
+  };
+}
+function applyChartSort(report, chartSort = report.chartSort) {
+  if (!chartSort?.field || !Array.isArray(report.rows)) return report;
+  const validOption = getChartSortOptions(report).some(
+    ({ value }) => value === formatChartSortValue(chartSort)
+  );
+  if (!validOption) return report;
+  if (chartSort.target === "series") {
+    return applyTwoDimensionalPivotSeriesSort(report, chartSort);
+  }
+  return applyChartRowSort(report, chartSort);
+}
+
+// src/utils/report.ts
+function extractAllReportValuesFromQuillInternalReport(reportInternal) {
+  return {
+    id: reportInternal.id,
+    name: reportInternal.name,
+    dashboardName: reportInternal.dashboardName,
+    // section: reportInternal.section,
+    pagination: reportInternal.pagination,
+    sort: reportInternal.sort,
+    rows: reportInternal.rows,
+    columns: reportInternal.columns,
+    chartType: reportInternal.chartType,
+    dateField: reportInternal.dateField,
+    pivot: reportInternal.pivot,
+    xAxisLabel: reportInternal.xAxisLabel,
+    xAxisField: reportInternal.xAxisField,
+    xAxisFormat: reportInternal.xAxisFormat,
+    yAxisFields: reportInternal.yAxisFields,
+    order: reportInternal.order,
+    compareRows: reportInternal.compareRows,
+    filtersApplied: reportInternal.filtersApplied,
+    queryString: reportInternal.queryString,
+    rowCount: reportInternal.rowCount,
+    template: reportInternal.template,
+    referenceLineYValues: reportInternal.referenceLineYValues,
+    referenceLines: reportInternal.referenceLines,
+    includeCustomFields: reportInternal.includeCustomFields,
+    columnsWithCustomFields: reportInternal.columnsWithCustomFields,
+    pivotRows: reportInternal.pivotRows,
+    pivotColumns: reportInternal.pivotColumns,
+    pivotRowCount: reportInternal.pivotRowCount,
+    filterMap: reportInternal.filterMap,
+    showLegend: reportInternal.showLegend,
+    chartSort: reportInternal.chartSort
+  };
+}
+async function fetchReportRows({
+  reportId,
+  client,
+  tenants,
+  filters = [],
+  getToken,
+  abortSignal,
+  additionalProcessing,
+  overwriteCache = false
+}) {
+  const startedAt = performance.now();
+  profileDashboard("raw-report-rows-fetch-start", { reportId });
+  const fetchResp = await quillFetch({
+    client,
+    task: "report",
+    metadata: {
+      reportId,
+      clientId: client.id,
+      databaseType: client.databaseType,
+      filters: filters.map((filter) => ({ ...filter, options: void 0 })),
+      useNewNodeSql: true,
+      tenants,
+      additionalProcessing,
+      overwriteCache
+    },
+    abortSignal,
+    getToken
+  });
+  const resp = await parseFetchResponse(client, "report", fetchResp, getToken);
+  profileDashboard("raw-report-rows-fetch-finish", {
+    reportId,
+    elapsedMs: Math.round(performance.now() - startedAt),
+    rowCount: resp.rows?.length ?? 0
+  });
+  if (client.databaseType?.toLowerCase() === "bigquery") {
+    parseValueFromBigQueryDates(resp.rows, resp.fields);
+  }
+  return {
+    rows: resp.rows || [],
+    rowCount: resp.rowCount || 0,
+    columns: resp.columns || [],
+    fields: resp.fields || []
+  };
+}
+async function fetchReport({
+  reportId,
+  client,
+  tenants,
+  flags,
+  useReportTask = true,
+  filters = [],
+  additionalProcessing,
+  dateBucket,
+  customFields,
+  rowsOnly,
+  rowCountOnly,
+  abortSignal,
   getToken,
   eventTracking,
   usePivotTask = false,
@@ -22457,8 +23276,16 @@ async function fetchReport({
 }) {
   let reportInfo = void 0;
   let errorMessage = void 0;
+  const startedAt = performance.now();
   try {
     const task = usePivotTask ? "pivot-template" : useReportTask ? "report" : "item";
+    profileDashboard("fetch-report-start", {
+      reportId: reportId ?? null,
+      task,
+      usePivotTask,
+      skipPivotFetch: skipPivotFetch ?? null,
+      shareRequest
+    });
     let pivotForRequest = pivot ?? void 0;
     let reportBuilderStateForRequest = reportBuilderState ?? void 0;
     if (usePivotTask && (pivotForRequest != null || reportBuilderStateForRequest?.pivot != null)) {
@@ -22501,6 +23328,16 @@ async function fetchReport({
       getToken
     });
     const resp = await parseFetchResponse(client, task, fetchResp, getToken);
+    profileDashboard("fetch-report-response", {
+      reportId: reportId ?? null,
+      task,
+      elapsedMs: Math.round(performance.now() - startedAt),
+      hasRows: !!resp?.rows,
+      rowCount: resp?.rows?.length ?? 0,
+      hasFields: !!resp?.fields,
+      hasPivotRows: !!resp?.pivotRows,
+      pivotRowCount: resp?.pivotRows?.length ?? 0
+    });
     reportInfo = await processReportResponse({
       resp,
       client,
@@ -22516,6 +23353,13 @@ async function fetchReport({
       skipPivotFetch: skipPivotFetch ?? !usePivotTask,
       overwriteCache
     });
+    profileDashboard("fetch-report-processed", {
+      reportId: reportId ?? null,
+      task,
+      elapsedMs: Math.round(performance.now() - startedAt),
+      rowCount: reportInfo.rows?.length ?? 0,
+      pivotRowCount: reportInfo.pivotRows?.length ?? 0
+    });
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
       throw error;
@@ -22568,6 +23412,15 @@ async function processReportResponse({
   overwriteCache
 }) {
   const shouldSkipPivotFetch = skipPivotFetch || !!resp?.pivotRows && !!resp?.fields;
+  profileDashboard("process-report-pivot-decision", {
+    reportId: resp?._id ?? resp?.id ?? null,
+    requestedSkipPivotFetch: skipPivotFetch,
+    hasPivot: !!resp?.pivot,
+    hasRows: !!resp?.rows,
+    hasFields: !!resp?.fields,
+    hasPivotRows: !!resp?.pivotRows,
+    shouldSkipPivotFetch
+  });
   const dashboardItem = {
     ...resp,
     filtersApplied: filters?.filter(
@@ -22814,6 +23667,51 @@ function formattedPivotRowsAndColumns(report, dashboardFilters = [], options = {
     rowCount: report.chartType === "table" ? report.pivotRowCount ?? report.rowCount : rows ? rows.length : 0
   };
 }
+function hasPreformattedDateBucketLabels(report) {
+  const pivot = report.pivot;
+  if (!pivot?.dateBucket) return false;
+  if (report.chartType?.toLowerCase() === "table") return false;
+  return report.xAxisField?.trim() === pivot.rowField?.trim();
+}
+function prepareStaticChartReport(report, { removePagination }) {
+  const config = report.pivot ? {
+    ...report,
+    ...formattedPivotRowsAndColumns(report, [], { formatRows: false })
+  } : { ...report };
+  if (removePagination) {
+    config.pagination = void 0;
+  }
+  if (hasPreformattedDateBucketLabels(config)) {
+    config.xAxisFormat = "string";
+  }
+  return applyChartSort(config);
+}
+function getReportSeriesFields(report) {
+  const drilldownFields = report?.pivot?.columnFilter?.options.map(({ value }) => value) ?? [];
+  if (drilldownFields.length > 0) {
+    return drilldownFields;
+  }
+  if (report?.pivot?.columnValues?.length) {
+    return report.pivot.columnValues;
+  }
+  return report?.yAxisFields?.map(({ field }) => field) ?? [];
+}
+function resolveReportColorMap(report, colors, overrides = {}) {
+  const seriesColors = buildSeriesColorMap(
+    getReportSeriesFields(report),
+    colors
+  );
+  const generated = Object.fromEntries(
+    Object.entries(seriesColors).map(([field, color]) => [
+      field,
+      { primary: color, comparison: color }
+    ])
+  );
+  return {
+    ...generated,
+    ...overrides
+  };
+}
 function convertInternalReportToReport(report, dashboardFilters, eventTracking, initiator) {
   try {
     if (!report) {
@@ -22837,7 +23735,7 @@ function convertInternalReportToReport(report, dashboardFilters, eventTracking,
         ...pivotFormatted
       };
       pivotReport.formattedBaseRows = formattedBaseRows;
-      return pivotReport;
+      return applyChartSort(pivotReport);
     }
     let rows = report.rows;
     if (report.chartType === "metric") {
@@ -22849,11 +23747,11 @@ function convertInternalReportToReport(report, dashboardFilters, eventTracking,
     } else if (report.chartType === "table" && initiator !== "useDashboardReport") {
       rows = formatRowsFromReport(report);
     }
-    return {
+    return applyChartSort({
       ...extractAllReportValuesFromQuillInternalReport(formattedReport),
       rows,
       yAxisFields: shouldPreserveYAxisFields ? report.yAxisFields : getYAxisFields(report, dashboardFilters)
-    };
+    });
   } catch (error) {
     eventTracking?.logError?.({
       type: "bug",
@@ -25850,8 +26748,14 @@ var reportsReducer = (state = {}, action) => {
 };
 var reportsLoadingStateReducer = (state = {}, action) => {
   switch (action.type) {
-    case "SET_REPORT_LOADING":
+    case "SET_REPORT_LOADING": {
+      profileDashboard("report-loading-state", {
+        reportId: action.id,
+        previous: state[action.id] ?? false,
+        next: action.data
+      });
       return { ...state, [action.id]: action.data };
+    }
     default:
       return state;
   }
@@ -25867,6 +26771,11 @@ var ReportsContext = createContext({
 var customReportFiltersReducer = (state, action) => {
   switch (action.type) {
     case "ADD_CUSTOM_REPORT_FILTERS":
+      profileDashboard("custom-report-filters-add", {
+        reportId: action.reportId,
+        filterCount: action.data?.length ?? 0,
+        removesEntry: !action.data
+      });
       if (!action.data) {
         const newState = { ...state };
         delete newState[action.reportId];
@@ -26142,7 +27051,14 @@ var ContextProvider = ({
   const mappedTenantsRequests = useRef(/* @__PURE__ */ new Set());
   const loadDashboardProcessId = useRef({});
   useEffect(() => {
+    profileDashboard("custom-report-filters-changed", {
+      reportIds: Object.keys(customReportFilters),
+      currentLoadedFlag: customFiltersLoaded
+    });
     if (Object.keys(customReportFilters).length) {
+      profileDashboard("custom-filters-loaded-set", {
+        next: true
+      });
       setCustomFiltersLoaded(true);
     }
   }, [customReportFilters]);
@@ -27727,6 +28643,7 @@ init_dataFetcher();
 init_tableProcessing();
 init_paginationProcessing();
 init_inMemoryPivotEngine();
+init_pivotConstructor();
 
 // src/utils/dashboardPagination.ts
 function isDashboardPivotTable(report) {
@@ -28441,6 +29358,7 @@ var useDashboard = (dashboardName, config) => {
   const { getCacheCab } = useContext(CacheCabContext);
   const reportRequestIds = useRef2({});
   const reportFetchAbortController = useRef2(null);
+  const dashboardFetchGeneration = useRef2(0);
   const lastDashboardName = useRef2(null);
   const pendingNameChangeReload = useRef2(false);
   const [loadedDashes, setLoadedDashes] = useState2([]);
@@ -28450,12 +29368,6 @@ var useDashboard = (dashboardName, config) => {
     () => getCacheCab(config?.cacheType),
     [getCacheCab, config?.cacheType]
   );
-  useEffect2(() => {
-    return () => {
-      reportFetchAbortController.current?.abort();
-      reportFetchAbortController.current = null;
-    };
-  }, [dashboardName]);
   useEffect2(() => {
     const nameChanged = dashboardName !== lastDashboardName.current;
     if (nameChanged) {
@@ -28518,15 +29430,42 @@ var useDashboard = (dashboardName, config) => {
     );
   }, [dashboardFilters]);
   useEffect2(() => {
+    profileDashboard("initial-fetch-effect", {
+      dashboardName,
+      fetchedInitialReports: fetchedInitialReports.current,
+      hasData: !!data,
+      dashboardFiltersReady: dashboardFilters !== null,
+      customFiltersLoaded,
+      customReportFilterIds: Object.keys(customReportFilters)
+    });
     if (!fetchedInitialReports.current && data && dashboardFilters !== null) {
       fetchedInitialReports.current = true;
-      fetchReports([], dashboardFilters ?? [], config?.pageSize);
+      void fetchReports(
+        [],
+        dashboardFilters ?? [],
+        config?.pageSize,
+        false,
+        "initial-effect"
+      );
     }
   }, [fetchedInitialReports, data, dashboardFilters, customFiltersLoaded]);
   useEffect2(() => {
+    profileDashboard("custom-filter-fetch-effect", {
+      dashboardName,
+      customFiltersLoaded,
+      hasData: !!data,
+      dashboardFiltersReady: dashboardFilters !== null,
+      customReportFilterIds: Object.keys(customReportFilters)
+    });
     if (customFiltersLoaded && data && dashboardFilters !== null) {
       fetchedInitialReports.current = true;
-      fetchReports([], dashboardFilters ?? [], config?.pageSize);
+      void fetchReports(
+        [],
+        dashboardFilters ?? [],
+        config?.pageSize,
+        false,
+        "custom-filters-effect"
+      );
     }
   }, [customFiltersLoaded]);
   const applyDashboardFilters = (filtersToUpdate) => {
@@ -28637,11 +29576,23 @@ var useDashboard = (dashboardName, config) => {
     const customFilters = filters2.filter(isFilter2);
     const newCustomFilters = applyCustomFilters(customFilters);
     const newDashboardFilters = applyDashboardFilters(dashboardFilters2);
-    fetchReports(newCustomFilters, newDashboardFilters);
+    void fetchReports(
+      newCustomFilters,
+      newDashboardFilters,
+      void 0,
+      false,
+      "apply-filters"
+    );
   };
   const forceCacheRefresh = () => {
     if (!cacheEnabled) return;
-    fetchReports([], dashboardFilters ?? [], config?.pageSize, true);
+    void fetchReports(
+      [],
+      dashboardFilters ?? [],
+      config?.pageSize,
+      true,
+      "force-cache-refresh"
+    );
   };
   const primeReportSource = async (reportId) => {
     const reportInfo = allReportsById[reportId];
@@ -28683,9 +29634,36 @@ var useDashboard = (dashboardName, config) => {
       }
     );
   };
-  const fetchReports = async (customFilters, dashboardFilters2, pageSize, forceCacheToRefresh = false) => {
-    if (!client || !sections) return;
-    reportFetchAbortController.current?.abort();
+  const fetchReports = async (customFilters, dashboardFilters2, pageSize, forceCacheToRefresh = false, reason = "unknown") => {
+    if (!client || !sections) {
+      profileDashboard("dashboard-fetch-skipped", {
+        dashboardName,
+        reason,
+        hasClient: !!client,
+        hasSections: !!sections
+      });
+      return;
+    }
+    const generation = dashboardFetchGeneration.current + 1;
+    dashboardFetchGeneration.current = generation;
+    const previousController = reportFetchAbortController.current;
+    profileDashboard("dashboard-fetch-start", {
+      dashboardName,
+      generation,
+      reason,
+      reportCount: Object.values(sections).flat().length,
+      customFilterCount: customFilters.length,
+      customReportFilterIds: Object.keys(customReportFilters),
+      abortsPreviousGeneration: !!previousController
+    });
+    if (previousController) {
+      profileDashboard("dashboard-fetch-abort-previous", {
+        dashboardName,
+        generation,
+        reason
+      });
+      previousController.abort();
+    }
     const abortController = new AbortController();
     reportFetchAbortController.current = abortController;
     const abortSignal = abortController.signal;
@@ -28697,6 +29675,32 @@ var useDashboard = (dashboardName, config) => {
         const reportId = reportInfo.id;
         const requestId = (reportRequestIds.current[reportId] ?? 0) + 1;
         reportRequestIds.current[reportId] = requestId;
+        const reportStartedAt = performance.now();
+        profileDashboard("report-fetch-start", {
+          dashboardName,
+          generation,
+          reason,
+          reportId,
+          requestId,
+          chartType: reportInfo.chartType,
+          pivot: !!reportInfo.pivot,
+          customFilterCount: customReportFilters[reportId]?.length ?? 0
+        });
+        abortSignal.addEventListener(
+          "abort",
+          () => {
+            profileDashboard("report-fetch-aborted", {
+              dashboardName,
+              generation,
+              reason,
+              reportId,
+              requestId,
+              elapsedMs: Math.round(performance.now() - reportStartedAt),
+              currentRequestId: reportRequestIds.current[reportId]
+            });
+          },
+          { once: true }
+        );
         reportsLoadingStateDispatch({
           type: "SET_REPORT_LOADING",
           id: reportId,
@@ -28923,20 +29927,65 @@ var useDashboard = (dashboardName, config) => {
             additionalProcessing: reportAdditionalProcessing
           }
         ];
-        const fetchDashboardReport = () => fetchReport({
-          reportId,
-          client,
-          tenants,
-          flags,
-          additionalProcessing: reportAdditionalProcessing,
-          filters: allFilters,
-          getToken,
-          eventTracking,
-          abortSignal,
-          usePivotTask,
-          overwriteCache: forceCacheToRefresh,
-          shareRequest: !forceCacheToRefresh
-        });
+        const fetchDashboardReport = async () => {
+          if (usePivotTask && reportInfo.pivot) {
+            try {
+              const dateFilter = allFilters.find(
+                (filter) => filter.filterType === "date_range" /* Date */ || filter.operator === "BETWEEN"
+              );
+              const pivotData = await generatePivotWithSQL({
+                pivot: reportInfo.pivot,
+                report: reportInfo,
+                client,
+                dateBucket: reportInfo.pivot.dateBucket,
+                dateFilter,
+                dashboardName,
+                dashboardFilters: allFilters,
+                tenants,
+                additionalProcessing: reportAdditionalProcessing,
+                getToken,
+                overwriteCache: forceCacheToRefresh,
+                abortSignal
+              });
+              return {
+                report: {
+                  ...reportInfo,
+                  rows: [],
+                  columnInternal: pivotData.columns,
+                  pivotRows: pivotData.rows,
+                  pivotColumns: pivotData.columns,
+                  pivotRowCount: pivotData.rowCount,
+                  pivotQuery: pivotData.pivotQuery,
+                  comparisonPivotQuery: pivotData.comparisonPivotQuery
+                },
+                error: void 0
+              };
+            } catch (error2) {
+              if (abortSignal.aborted || error2 instanceof Error && error2.name === "AbortError") {
+                const abortError = new Error("Dashboard report fetch aborted");
+                abortError.name = "AbortError";
+                throw abortError;
+              }
+              return {
+                report: reportInfo,
+                error: error2 instanceof Error ? error2.message : String(error2 ?? "Failed to fetch pivot report")
+              };
+            }
+          }
+          return fetchReport({
+            reportId,
+            client,
+            tenants,
+            flags,
+            additionalProcessing: reportAdditionalProcessing,
+            filters: allFilters,
+            getToken,
+            eventTracking,
+            abortSignal,
+            overwriteCache: forceCacheToRefresh,
+            shareRequest: !forceCacheToRefresh
+          });
+        };
         const result = forceCacheToRefresh ? await fetchDashboardReport() : await queryClient.fetchQuery({
           queryKey,
           queryFn: fetchDashboardReport,
@@ -29015,10 +30064,25 @@ var useDashboard = (dashboardName, config) => {
         return report;
       })
     ).catch((error) => {
+      profileDashboard("dashboard-fetch-rejected", {
+        dashboardName,
+        generation,
+        reason,
+        errorName: error instanceof Error ? error.name : typeof error,
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
       if (!(error instanceof Error) || error.name !== "AbortError") {
         throw error;
       }
     });
+    profileDashboard("dashboard-fetch-settled", {
+      dashboardName,
+      generation,
+      reason,
+      elapsedMs: Date.now() - fetchStartTime,
+      aborted: abortSignal.aborted,
+      latestGeneration: dashboardFetchGeneration.current
+    });
     if (!loadedDashes.includes(dashboardName) || !cacheEnabled || forceCacheToRefresh) {
       setLoadedDashes(
         (prev) => prev.includes(dashboardName) ? prev : [...prev, dashboardName]
@@ -29746,637 +30810,274 @@ function QuillCustomDocumentComponent({
                   }),
                   /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsx2("td", { colSpan: report.columns.length, children: "\xA0" }) }),
                   /* @__PURE__ */ jsx2("tr", { children: /* @__PURE__ */ jsxs(
-                    "td",
-                    {
-                      style: {
-                        fontSize: "8px",
-                        textAlign: "left",
-                        whiteSpace: "nowrap",
-                        overflow: "hidden",
-                        textOverflow: "ellipsis",
-                        width: "100%",
-                        margin: 0
-                      },
-                      colSpan: report.columns.length,
-                      children: [
-                        "Page ",
-                        pageNumber,
-                        " of ",
-                        numberOfPages
-                      ]
-                    }
-                  ) })
-                ] })
-              ]
-            }
-          )
-        }
-      ) })
-    }
-  );
-}
-
-// src/Chart.tsx
-import { differenceInHours } from "date-fns";
-
-// src/components/Chart/BarList.tsx
-init_valueFormatter();
-init_chart();
-import React2 from "react";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-var getWidthsFromValues = (dataValues) => {
-  let maxValue = -Infinity;
-  dataValues.forEach((value) => {
-    maxValue = Math.max(maxValue, value);
-  });
-  return dataValues.map((value) => {
-    if (value === 0) return 0;
-    return Math.max(value / maxValue * 100, 1);
-  });
-};
-function getColors(colorMap, xAxisField, colors) {
-  if (colorMap && colorMap[xAxisField] && colorMap[xAxisField]["primary"]) {
-    return colorMap[xAxisField]["primary"];
-  } else if (colors) {
-    return hexToRgbaWith10PercentAlpha(colors[0]);
-  }
-  return hexToRgbaWith10PercentAlpha(void 0);
-}
-var BarList = React2.forwardRef((props, ref) => {
-  const {
-    data = [],
-    yAxisFields,
-    xAxisField,
-    xAxisFormat,
-    colors,
-    colorMap = {},
-    // valueFormatter = (value: any) => value,valueFormatter
-    showAnimation = true,
-    className,
-    containerStyle,
-    theme,
-    onClickChartElement,
-    scrollable,
-    ...other
-  } = props;
-  const widths = getWidthsFromValues(
-    data.map((item) => {
-      if (yAxisFields && yAxisFields[0] && yAxisFields[0].field) {
-        return item[yAxisFields[0].field];
-      }
-      return 0;
-    })
-  );
-  const NUM_TO_SHOW = scrollable ? 500 : 5;
-  if (!data || data.length === 0) {
-    return /* @__PURE__ */ jsx3(
-      "div",
-      {
-        style: {
-          display: "flex",
-          flex: "1 0 auto",
-          // height: '100%',
-          margin: "auto",
-          justifyContent: "center",
-          alignItems: "center",
-          fontSize: 13,
-          fontFamily: theme?.fontFamily,
-          color: theme.secondaryTextColor,
-          ...containerStyle
-        },
-        className,
-        children: "No results"
-      }
-    );
-  }
-  return /* @__PURE__ */ jsx3(
-    "div",
-    {
-      ref,
-      className,
-      style: {
-        // width: '100%',
-        boxSizing: "content-box",
-        height: "100%",
-        // marginLeft: 25,
-        // background: 'red',
-        // paddingRight: 25,
-        // paddingRight: 25,
-        ...containerStyle
-      },
-      ...other,
-      children: /* @__PURE__ */ jsxs2(
-        "div",
-        {
-          style: {
-            display: "flex",
-            justifyContent: "space-between",
-            boxSizing: "content-box",
-            overflow: scrollable ? "scroll" : "hidden",
-            width: "100%",
-            height: "100%"
-          },
-          children: [
-            /* @__PURE__ */ jsxs2(
-              "div",
-              {
-                style: {
-                  width: "100%",
-                  boxSizing: "content-box",
-                  height: "100%",
-                  position: "relative",
-                  paddingRight: 25
-                },
-                children: [
-                  data.slice(0, NUM_TO_SHOW).map((item, idx) => {
-                    return /* @__PURE__ */ jsx3(
-                      "div",
-                      {
-                        style: {
-                          width: `${widths[idx]}%`,
-                          transition: showAnimation ? "all 2s" : "",
-                          boxSizing: "content-box",
-                          backgroundColor: getColors(colorMap, xAxisField, colors),
-                          display: "flex",
-                          alignItems: "center",
-                          height: "36px",
-                          marginBottom: "8px",
-                          borderRadius: "4px"
-                        },
-                        onClick: () => onClickChartElement?.(item),
-                        children: /* @__PURE__ */ jsx3(
-                          "div",
-                          {
-                            style: {
-                              boxSizing: "content-box",
-                              position: "absolute",
-                              maxWidth: "100%",
-                              display: "flex",
-                              marginLeft: "8px"
-                            },
-                            children: /* @__PURE__ */ jsx3(
-                              "p",
-                              {
-                                style: {
-                                  color: theme?.chartLabelColor,
-                                  boxSizing: "content-box",
-                                  whiteSpace: "nowrap",
-                                  overflow: "hidden",
-                                  textOverflow: "ellipsis",
-                                  fontFamily: theme?.chartLabelFontFamily || theme?.fontFamily,
-                                  fontSize: theme?.fontSizeSmall || "14px"
-                                },
-                                children: valueFormatter({
-                                  value: item[xAxisField] ?? item[`comparison_${xAxisField}`],
-                                  field: xAxisField,
-                                  // @ts-ignore
-                                  fields: [{ field: xAxisField, format: xAxisFormat }]
-                                })
-                              }
-                            )
-                          }
-                        )
-                      },
-                      item[xAxisField] + "label" + idx
-                    );
-                  }),
-                  data.length > NUM_TO_SHOW && /* @__PURE__ */ jsxs2(
-                    "div",
-                    {
-                      style: {
-                        color: theme?.chartLabelColor,
-                        boxSizing: "content-box",
-                        fontFamily: theme?.chartLabelFontFamily || theme?.fontFamily,
-                        fontSize: theme?.fontSizeSmall || "14px"
-                      },
-                      children: [
-                        "...",
-                        data.length - NUM_TO_SHOW,
-                        " more"
-                      ]
-                    }
-                  )
-                ]
-              }
-            ),
-            /* @__PURE__ */ jsx3(
-              "div",
-              {
-                style: {
-                  boxSizing: "content-box",
-                  textAlign: "right",
-                  minWidth: "min-content",
-                  paddingLeft: 10
-                },
-                children: data.slice(0, NUM_TO_SHOW).map((item, idx) => /* @__PURE__ */ jsx3(
-                  "div",
-                  {
-                    style: {
-                      boxSizing: "content-box",
-                      display: "flex",
-                      alignItems: "center",
-                      justifyContent: "flex-end",
-                      marginBottom: idx === data.length - 1 ? 0 : "8px",
-                      height: "36px"
-                    },
-                    children: /* @__PURE__ */ jsx3(
-                      "p",
-                      {
-                        style: {
-                          color: theme?.chartLabelColor,
-                          boxSizing: "content-box",
-                          fontFamily: theme?.chartLabelFontFamily || theme?.fontFamily,
-                          whiteSpace: "nowrap",
-                          overflow: "hidden",
-                          textOverflow: "ellipsis",
-                          fontSize: theme?.fontSizeSmall || "14px"
-                        },
-                        children: valueFormatter({
-                          value: yAxisFields && yAxisFields[0] && item[yAxisFields[0].field] ? item[yAxisFields[0].field] : 0,
-                          field: yAxisFields && yAxisFields[0] && yAxisFields[0].field,
-                          fields: yAxisFields
-                        })
-                      }
-                    )
-                  },
-                  item[xAxisField] + "value" + idx
-                ))
-              }
-            )
-          ]
-        }
-      )
-    }
-  );
-});
-var BarList_default = BarList;
-
-// src/components/Chart/PieChart.tsx
-import React4, { useMemo as useMemo4 } from "react";
-import { Legend, Pie, PieChart, ResponsiveContainer, Tooltip } from "recharts";
-
-// src/utils/color.ts
-var DEFAULT_GRADIENT_COLORS = [
-  "#4E80EE",
-  // vivid indigo
-  "#586FF4",
-  "#6464FA",
-  "#715AFE",
-  "#8450FF",
-  "#9B48FF",
-  "#B33FFF",
-  "#CA37F3",
-  "#DE2FE1",
-  "#F028CB",
-  "#FF20B5"
-];
-function generateArrayFromColor(colors, length) {
-  if (length <= 0) {
-    return [];
-  }
-  if (typeof colors === "string") {
-    const trimmedColor = colors.trim();
-    return monochromaticInterpolation(
-      trimmedColor.length > 0 ? trimmedColor : DEFAULT_GRADIENT_COLORS[0],
-      length
-    );
-  }
-  const normalizedColors = colors.filter((color) => typeof color === "string").map((color) => color.trim()).filter((color) => color.length > 0);
-  const baseColors = normalizedColors.length > 0 ? normalizedColors : DEFAULT_GRADIENT_COLORS;
-  if (baseColors.length === 1) {
-    return monochromaticInterpolation(baseColors[0], length);
-  }
-  if (length <= baseColors.length) {
-    return baseColors.slice(0, length);
-  }
-  const pairs = baseColors.length - 1;
-  if (pairs <= 0) {
-    return [baseColors[0]];
-  }
-  const needed = length - baseColors.length;
-  const baseAmount = Math.floor(needed / pairs);
-  const extras = needed % pairs;
-  let result = [];
-  let i = 0;
-  let j = 1;
-  while (j < baseColors.length) {
-    const additional = i < extras ? 1 : 0;
-    const interpLength = 2 + baseAmount + additional;
-    const interp = interpolateBetween(
-      baseColors[i],
-      baseColors[j],
-      interpLength
-    );
-    const lastIndex = j === baseColors.length - 1 ? void 0 : -1;
-    result = result.concat(interp.slice(0, lastIndex));
-    i++;
-    j++;
-  }
-  return result;
-}
-function hexToRgb(hex) {
-  const r = parseInt(hex.substring(1, 3), 16);
-  const g = parseInt(hex.substring(3, 5), 16);
-  const b = parseInt(hex.substring(5, 7), 16);
-  return { r, g, b };
-}
-function rgbToHex(rgb) {
-  const rHex = rgb.r.toString(16).padStart(2, "0");
-  const gHex = rgb.g.toString(16).padStart(2, "0");
-  const bHex = rgb.b.toString(16).padStart(2, "0");
-  return `#${rHex}${gHex}${bHex}`;
-}
-function colorToHSL(color) {
-  const colorHex = namedColorToHex(color);
-  const { r, g, b } = hexToRgb(colorHex);
-  return rgbToHsl(r, g, b);
-}
-function interpolateBetween(leftColor, rightColor, length = 3) {
-  const [h, s, _l] = colorToHSL(leftColor);
-  const [h2, s2, _l2] = colorToHSL(rightColor);
-  const hues = linspace(h, h2, length);
-  const saturations = linspace(s, s2, length);
-  const lightnesses = linspace(_l, _l2, length);
-  return Array.from({ length }).map((_, i) => {
-    const [r, g, b] = HSLtoRGB(hues[i], saturations[i], lightnesses[i]);
-    return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
-  });
-}
-function monochromaticInterpolation(color, length) {
-  const [h, s] = colorToHSL(color);
-  const hues = linspace(h, h, length);
-  const saturations = linspace(s, s, length);
-  const lightnesses = linspace(0.6, 0.9, length);
-  return Array.from({ length }).map((_, i) => {
-    const [r, g, b] = HSLtoRGB(hues[i], saturations[i], lightnesses[i]);
-    return rgbToHex({ r: Math.round(r), g: Math.round(g), b: Math.round(b) });
-  });
-}
-function linspace(start, end, num) {
-  if (num <= 1) return [start];
-  const step = (end - start) / (num - 1);
-  const result = new Array(num);
-  for (let i = 0; i < num; i++) {
-    result[i] = start + step * i;
-  }
-  return result;
-}
-function stableColorIndex(field) {
-  let hash = 0;
-  for (const character of field.replace("comparison_", "")) {
-    hash = Math.imul(hash, 31) + character.charCodeAt(0) >>> 0;
-  }
-  return hash;
-}
-function selectColor(element, colors, index) {
-  if (!element?.field) return "gray";
-  const isComparison = element.field.includes("comparison_");
-  const color = colors[index % colors.length] ?? "";
-  if (!isComparison) {
-    return color;
-  }
-  if (Object.keys(COLOR_TO_HEX).includes(color)) {
-    const colorHex = COLOR_TO_HEX[color];
-    const rgbArray = hexToRGB(colorHex);
-    return toGrayscale(rgbArray);
-  }
-  if (color?.startsWith("#")) {
-    const rgbArray = hexToRGB(color);
-    return toGrayscale(rgbArray);
-  }
-  return "gray";
-}
-function hexToRGB(hex) {
-  const regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i;
-  const result = regex.exec(hex);
-  if (result) {
-    return [
-      parseInt(result[1], 16),
-      // index 0 is whole string, then ()'s
-      parseInt(result[2], 16),
-      parseInt(result[3], 16),
-      ...result[4] ? [parseInt(result[4], 16)] : []
-      // <- alpha channel
-    ];
-  }
-  const rgba = hex.match(/[0-9.]+/g);
-  if (rgba) {
-    return [
-      Number(rgba[0]),
-      Number(rgba[1]),
-      Number(rgba[2]),
-      ...rgba[3] ? [Number(rgba[3])] : []
-    ];
-  }
-  return [128, 128, 128];
-}
-function toGrayscale(rgba) {
-  if (rgba.length < 3) return "rbg(128, 128, 128)";
-  let sum = 0;
-  sum += Number(rgba[0] * 0.89);
-  sum += Number(rgba[1] * 1.77);
-  sum += Number(rgba[2] * 0.33);
-  const avg = (sum / 3).toFixed(2);
-  return `rgb(${avg}, ${avg}, ${avg})`;
-}
-function namedColorToHex(color) {
-  if (Object.keys(COLOR_TO_HEX).includes(color)) {
-    return COLOR_TO_HEX[color];
-  }
-  return color;
-}
-var COLOR_TO_HEX = {
-  aliceblue: "#f0f8ff",
-  antiquewhite: "#faebd7",
-  aqua: "#00ffff",
-  aquamarine: "#7fffd4",
-  azure: "#f0ffff",
-  beige: "#f5f5dc",
-  bisque: "#ffe4c4",
-  black: "#000000",
-  blanchedalmond: "#ffebcd",
-  blue: "#0000ff",
-  blueviolet: "#8a2be2",
-  brown: "#a52a2a",
-  burlywood: "#deb887",
-  cadetblue: "#5f9ea0",
-  chartreuse: "#7fff00",
-  chocolate: "#d2691e",
-  coral: "#ff7f50",
-  cornflowerblue: "#6495ed",
-  cornsilk: "#fff8dc",
-  crimson: "#dc143c",
-  cyan: "#00ffff",
-  darkblue: "#00008b",
-  darkcyan: "#008b8b",
-  darkgoldenrod: "#b8860b",
-  darkgray: "#a9a9a9",
-  darkgreen: "#006400",
-  darkkhaki: "#bdb76b",
-  darkmagenta: "#8b008b",
-  darkolivegreen: "#556b2f",
-  darkorange: "#ff8c00",
-  darkorchid: "#9932cc",
-  darkred: "#8b0000",
-  darksalmon: "#e9967a",
-  darkseagreen: "#8fbc8f",
-  darkslateblue: "#483d8b",
-  darkslategray: "#2f4f4f",
-  darkturquoise: "#00ced1",
-  darkviolet: "#9400d3",
-  deeppink: "#ff1493",
-  deepskyblue: "#00bfff",
-  dimgray: "#696969",
-  dodgerblue: "#1e90ff",
-  firebrick: "#b22222",
-  floralwhite: "#fffaf0",
-  forestgreen: "#228b22",
-  fuchsia: "#ff00ff",
-  gainsboro: "#dcdcdc",
-  ghostwhite: "#f8f8ff",
-  gold: "#ffd700",
-  goldenrod: "#daa520",
-  gray: "#808080",
-  green: "#008000",
-  greenyellow: "#adff2f",
-  honeydew: "#f0fff0",
-  hotpink: "#ff69b4",
-  indianred: "#cd5c5c",
-  indigo: "#4b0082",
-  ivory: "#fffff0",
-  khaki: "#f0e68c",
-  lavender: "#e6e6fa",
-  lavenderblush: "#fff0f5",
-  lawngreen: "#7cfc00",
-  lemonchiffon: "#fffacd",
-  lightblue: "#add8e6",
-  lightcoral: "#f08080",
-  lightcyan: "#e0ffff",
-  lightgoldenrodyellow: "#fafad2",
-  lightgrey: "#d3d3d3",
-  lightgreen: "#90ee90",
-  lightpink: "#ffb6c1",
-  lightsalmon: "#ffa07a",
-  lightseagreen: "#20b2aa",
-  lightskyblue: "#87cefa",
-  lightslategray: "#778899",
-  lightsteelblue: "#b0c4de",
-  lightyellow: "#ffffe0",
-  lime: "#00ff00",
-  limegreen: "#32cd32",
-  linen: "#faf0e6",
-  magenta: "#ff00ff",
-  maroon: "#800000",
-  mediumaquamarine: "#66cdaa",
-  mediumblue: "#0000cd",
-  mediumorchid: "#ba55d3",
-  mediumpurple: "#9370d8",
-  mediumseagreen: "#3cb371",
-  mediumslateblue: "#7b68ee",
-  mediumspringgreen: "#00fa9a",
-  mediumturquoise: "#48d1cc",
-  mediumvioletred: "#c71585",
-  midnightblue: "#191970",
-  mintcream: "#f5fffa",
-  mistyrose: "#ffe4e1",
-  moccasin: "#ffe4b5",
-  navajowhite: "#ffdead",
-  navy: "#000080",
-  oldlace: "#fdf5e6",
-  olive: "#808000",
-  olivedrab: "#6b8e23",
-  orange: "#ffa500",
-  orangered: "#ff4500",
-  orchid: "#da70d6",
-  palegoldenrod: "#eee8aa",
-  palegreen: "#98fb98",
-  paleturquoise: "#afeeee",
-  palevioletred: "#d87093",
-  papayawhip: "#ffefd5",
-  peachpuff: "#ffdab9",
-  peru: "#cd853f",
-  pink: "#ffc0cb",
-  plum: "#dda0dd",
-  powderblue: "#b0e0e6",
-  purple: "#800080",
-  rebeccapurple: "#663399",
-  red: "#ff0000",
-  rosybrown: "#bc8f8f",
-  royalblue: "#4169e1",
-  saddlebrown: "#8b4513",
-  salmon: "#fa8072",
-  sandybrown: "#f4a460",
-  seagreen: "#2e8b57",
-  seashell: "#fff5ee",
-  sienna: "#a0522d",
-  silver: "#c0c0c0",
-  skyblue: "#87ceeb",
-  slateblue: "#6a5acd",
-  slategray: "#708090",
-  snow: "#fffafa",
-  springgreen: "#00ff7f",
-  steelblue: "#4682b4",
-  tan: "#d2b48c",
-  teal: "#008080",
-  thistle: "#d8bfd8",
-  tomato: "#ff6347",
-  turquoise: "#40e0d0",
-  violet: "#ee82ee",
-  wheat: "#f5deb3",
-  white: "#ffffff",
-  whitesmoke: "#f5f5f5",
-  yellow: "#ffff00",
-  yellowgreen: "#9acd32"
-};
-function rgbToHsl(r, g, b) {
-  r /= 255, g /= 255, b /= 255;
-  const max2 = Math.max(r, g, b), min2 = Math.min(r, g, b);
-  let h = (max2 + min2) / 2;
-  let s = (max2 + min2) / 2;
-  const l = (max2 + min2) / 2;
-  if (max2 == min2) {
-    h = s = 0;
-  } else {
-    const d = max2 - min2;
-    s = l > 0.5 ? d / (2 - max2 - min2) : d / (max2 + min2);
-    switch (max2) {
-      case r:
-        h = (g - b) / d + (g < b ? 6 : 0);
-        break;
-      case g:
-        h = (b - r) / d + 2;
-        break;
-      case b:
-        h = (r - g) / d + 4;
-        break;
+                    "td",
+                    {
+                      style: {
+                        fontSize: "8px",
+                        textAlign: "left",
+                        whiteSpace: "nowrap",
+                        overflow: "hidden",
+                        textOverflow: "ellipsis",
+                        width: "100%",
+                        margin: 0
+                      },
+                      colSpan: report.columns.length,
+                      children: [
+                        "Page ",
+                        pageNumber,
+                        " of ",
+                        numberOfPages
+                      ]
+                    }
+                  ) })
+                ] })
+              ]
+            }
+          )
+        }
+      ) })
     }
-    h /= 6;
-  }
-  return [h, s, l];
+  );
 }
-function HSLtoRGB(h, s, l) {
-  let r, g, b;
-  if (s == 0) {
-    r = g = b = l;
-  } else {
-    const hue2rgb = (p2, q2, t) => {
-      if (t < 0) t += 1;
-      if (t > 1) t -= 1;
-      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
-      if (t < 1 / 2) return q2;
-      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
-      return p2;
-    };
-    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-    const p = 2 * l - q;
-    r = hue2rgb(p, q, h + 1 / 3);
-    g = hue2rgb(p, q, h);
-    b = hue2rgb(p, q, h - 1 / 3);
+
+// src/Chart.tsx
+import { differenceInHours } from "date-fns";
+
+// src/components/Chart/BarList.tsx
+init_valueFormatter();
+init_chart();
+import React2 from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var getWidthsFromValues = (dataValues) => {
+  let maxValue = -Infinity;
+  dataValues.forEach((value) => {
+    maxValue = Math.max(maxValue, value);
+  });
+  return dataValues.map((value) => {
+    if (value === 0) return 0;
+    return Math.max(value / maxValue * 100, 1);
+  });
+};
+function getColors(colorMap, xAxisField, colors) {
+  if (colorMap && colorMap[xAxisField] && colorMap[xAxisField]["primary"]) {
+    return colorMap[xAxisField]["primary"];
+  } else if (colors) {
+    return hexToRgbaWith10PercentAlpha(colors[0]);
   }
-  return [r * 255, g * 255, b * 255];
+  return hexToRgbaWith10PercentAlpha(void 0);
 }
+var BarList = React2.forwardRef((props, ref) => {
+  const {
+    data = [],
+    yAxisFields,
+    xAxisField,
+    xAxisFormat,
+    colors,
+    colorMap = {},
+    // valueFormatter = (value: any) => value,valueFormatter
+    showAnimation = true,
+    className,
+    containerStyle,
+    theme,
+    onClickChartElement,
+    scrollable,
+    ...other
+  } = props;
+  const widths = getWidthsFromValues(
+    data.map((item) => {
+      if (yAxisFields && yAxisFields[0] && yAxisFields[0].field) {
+        return item[yAxisFields[0].field];
+      }
+      return 0;
+    })
+  );
+  const NUM_TO_SHOW = scrollable ? 500 : 5;
+  if (!data || data.length === 0) {
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flex: "1 0 auto",
+          // height: '100%',
+          margin: "auto",
+          justifyContent: "center",
+          alignItems: "center",
+          fontSize: 13,
+          fontFamily: theme?.fontFamily,
+          color: theme.secondaryTextColor,
+          ...containerStyle
+        },
+        className,
+        children: "No results"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref,
+      className,
+      style: {
+        // width: '100%',
+        boxSizing: "content-box",
+        height: "100%",
+        // marginLeft: 25,
+        // background: 'red',
+        // paddingRight: 25,
+        // paddingRight: 25,
+        ...containerStyle
+      },
+      ...other,
+      children: /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          style: {
+            display: "flex",
+            justifyContent: "space-between",
+            boxSizing: "content-box",
+            overflow: scrollable ? "scroll" : "hidden",
+            width: "100%",
+            height: "100%"
+          },
+          children: [
+            /* @__PURE__ */ jsxs2(
+              "div",
+              {
+                style: {
+                  width: "100%",
+                  boxSizing: "content-box",
+                  height: "100%",
+                  position: "relative",
+                  paddingRight: 25
+                },
+                children: [
+                  data.slice(0, NUM_TO_SHOW).map((item, idx) => {
+                    return /* @__PURE__ */ jsx3(
+                      "div",
+                      {
+                        style: {
+                          width: `${widths[idx]}%`,
+                          transition: showAnimation ? "all 2s" : "",
+                          boxSizing: "content-box",
+                          backgroundColor: getColors(colorMap, xAxisField, colors),
+                          display: "flex",
+                          alignItems: "center",
+                          height: "36px",
+                          marginBottom: "8px",
+                          borderRadius: "4px"
+                        },
+                        onClick: () => onClickChartElement?.(item),
+                        children: /* @__PURE__ */ jsx3(
+                          "div",
+                          {
+                            style: {
+                              boxSizing: "content-box",
+                              position: "absolute",
+                              maxWidth: "100%",
+                              display: "flex",
+                              marginLeft: "8px"
+                            },
+                            children: /* @__PURE__ */ jsx3(
+                              "p",
+                              {
+                                style: {
+                                  color: theme?.chartLabelColor,
+                                  boxSizing: "content-box",
+                                  whiteSpace: "nowrap",
+                                  overflow: "hidden",
+                                  textOverflow: "ellipsis",
+                                  fontFamily: theme?.chartLabelFontFamily || theme?.fontFamily,
+                                  fontSize: theme?.fontSizeSmall || "14px"
+                                },
+                                children: valueFormatter({
+                                  value: item[xAxisField] ?? item[`comparison_${xAxisField}`],
+                                  field: xAxisField,
+                                  // @ts-ignore
+                                  fields: [{ field: xAxisField, format: xAxisFormat }]
+                                })
+                              }
+                            )
+                          }
+                        )
+                      },
+                      item[xAxisField] + "label" + idx
+                    );
+                  }),
+                  data.length > NUM_TO_SHOW && /* @__PURE__ */ jsxs2(
+                    "div",
+                    {
+                      style: {
+                        color: theme?.chartLabelColor,
+                        boxSizing: "content-box",
+                        fontFamily: theme?.chartLabelFontFamily || theme?.fontFamily,
+                        fontSize: theme?.fontSizeSmall || "14px"
+                      },
+                      children: [
+                        "...",
+                        data.length - NUM_TO_SHOW,
+                        " more"
+                      ]
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx3(
+              "div",
+              {
+                style: {
+                  boxSizing: "content-box",
+                  textAlign: "right",
+                  minWidth: "min-content",
+                  paddingLeft: 10
+                },
+                children: data.slice(0, NUM_TO_SHOW).map((item, idx) => /* @__PURE__ */ jsx3(
+                  "div",
+                  {
+                    style: {
+                      boxSizing: "content-box",
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "flex-end",
+                      marginBottom: idx === data.length - 1 ? 0 : "8px",
+                      height: "36px"
+                    },
+                    children: /* @__PURE__ */ jsx3(
+                      "p",
+                      {
+                        style: {
+                          color: theme?.chartLabelColor,
+                          boxSizing: "content-box",
+                          fontFamily: theme?.chartLabelFontFamily || theme?.fontFamily,
+                          whiteSpace: "nowrap",
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          fontSize: theme?.fontSizeSmall || "14px"
+                        },
+                        children: valueFormatter({
+                          value: yAxisFields && yAxisFields[0] && item[yAxisFields[0].field] ? item[yAxisFields[0].field] : 0,
+                          field: yAxisFields && yAxisFields[0] && yAxisFields[0].field,
+                          fields: yAxisFields
+                        })
+                      }
+                    )
+                  },
+                  item[xAxisField] + "value" + idx
+                ))
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+});
+var BarList_default = BarList;
 
 // src/components/Chart/PieChart.tsx
+import React4, { useMemo as useMemo4 } from "react";
+import { Legend, Pie, PieChart, ResponsiveContainer, Tooltip } from "recharts";
 init_util();
 init_valueFormatter();
 
@@ -35167,16 +35868,9 @@ function BarChart({
     }
     return colorMap?.[field]?.[key];
   };
-  const sortYAxisFields = (fields) => {
-    if (data?.length > 0) {
-      fields = fields.sort(
-        (a, b) => Object.keys(data[0]).indexOf(a.field) - Object.keys(data[0]).indexOf(b.field)
-      ).filter(
-        (field) => comparison || !field.field.startsWith("comparison_")
-      );
-    }
-    return fields;
-  };
+  const getVisibleYAxisFields = (fields) => fields.filter(
+    ({ field }) => comparison || !field.startsWith("comparison_")
+  );
   const valueDomain = useMemo9(
     () => stackedMode ? getStackedDomain(data, yAxisFields, comparison) : getDomain(data, yAxisFields, referenceLines),
     [stackedMode, data, yAxisFields, referenceLines, comparison]
@@ -35202,13 +35896,13 @@ function BarChart({
   const customBarShape = useMemo9(() => {
     if (!theme?.barChartCornerRadius && !theme?.barChartCornerRadiusRatio)
       return void 0;
-    return createCustomBar(sortYAxisFields([...yAxisFields]), theme, layout);
+    return createCustomBar(getVisibleYAxisFields(yAxisFields), theme, layout);
   }, [isStacked, yAxisFields, theme, layout]);
   const customActiveBarShape = useMemo9(() => {
     if (!theme?.barChartCornerRadius && !theme?.barChartCornerRadiusRatio)
       return void 0;
     return createCustomBar(
-      sortYAxisFields([...yAxisFields]),
+      getVisibleYAxisFields(yAxisFields),
       theme,
       layout,
       true
@@ -35382,9 +36076,9 @@ function BarChart({
                       }
                       const row = payload[0]?.payload ?? {};
                       const activeLabel = label ?? row[xAxisField] ?? "";
-                      const payloadItems = sortYAxisFields([
-                        ...yAxisFields
-                      ]).map((field) => {
+                      const payloadItems = getVisibleYAxisFields(
+                        yAxisFields
+                      ).map((field) => {
                         const rawName = field.label;
                         const name2 = rawName ? humanizeChartSeriesTooltipLabel(rawName) : "";
                         return {
@@ -35437,7 +36131,7 @@ function BarChart({
                     position: isHorizontalBars ? void 0 : { y: 0 }
                   }
                 ),
-                sortYAxisFields([...yAxisFields]).map((elem) => {
+                getVisibleYAxisFields(yAxisFields).map((elem, index) => {
                   return /* @__PURE__ */ jsx38(
                     Bar,
                     {
@@ -35454,9 +36148,9 @@ function BarChart({
                       style: {
                         cursor: onClickChartElement ? "pointer" : void 0
                       },
-                      onClick: (bar, index, event) => {
+                      onClick: (bar, index2, event) => {
                         event?.stopPropagation();
-                        const payload = bar.payload ?? data[index] ?? {};
+                        const payload = bar.payload ?? data[index2] ?? {};
                         onClickChartElement?.({
                           ...payload,
                           interactionType: "bar",
@@ -35477,11 +36171,11 @@ function BarChart({
                           series: elem.field,
                           value: payload[elem.field] ?? bar.value,
                           row: payload,
-                          index
+                          index: index2
                         });
                       }
                     },
-                    elem.field
+                    `${index}:${elem.field}`
                   );
                 }),
                 referenceLines && referenceLines.map(({ label, query }) => /* @__PURE__ */ jsx38(
@@ -38601,13 +39295,23 @@ var ChartDataLoader = ({
     reportFilters,
     dashboardFilters
   ]);
-  const fetchReportHelper = async (useReportTask = true) => {
+  const fetchReportHelper = async (useReportTask = true, reason = "unknown") => {
     if (!client || !filters) {
       if (!fetchReportAbortController.current) setLoading(false);
       return;
     }
     const fetchRowsRequestId = rowsRequestId.current + 1;
     rowsRequestId.current = fetchRowsRequestId;
+    const startedAt = performance.now();
+    profileDashboard("chart-data-loader-fetch-start", {
+      reportId: item.id,
+      requestId: fetchRowsRequestId,
+      reason,
+      useReportTask,
+      triggerReload: (dashboardName ? dashboard : reports)[item.id]?.triggerReload,
+      abortsPrevious: !!fetchReportAbortController.current,
+      pivot: !!item.pivot
+    });
     previousUserFilters.current = userFilters;
     previousDateBucket.current = dateBucket;
     setLoading(true);
@@ -38740,6 +39444,14 @@ var ChartDataLoader = ({
       });
       setError(e.message ?? "Error fetching report");
     } finally {
+      profileDashboard("chart-data-loader-fetch-finish", {
+        reportId: item.id,
+        requestId: fetchRowsRequestId,
+        reason,
+        elapsedMs: Math.round(performance.now() - startedAt),
+        isLatestRequest: fetchRowsRequestId === rowsRequestId.current,
+        startsBackgroundFetch: !!backgroundFetch
+      });
       if (fetchRowsRequestId === rowsRequestId.current) {
         fetchReportAbortController.current = null;
         setLoading(false);
@@ -38774,7 +39486,7 @@ var ChartDataLoader = ({
     previousTenants.current = tenants;
     previousFilters.current = filters;
     previousCustomFields.current = schemaData.customFields;
-    fetchReportHelper();
+    fetchReportHelper(true, "inputs-effect");
   }, [
     filters,
     userFilters,
@@ -38786,8 +39498,13 @@ var ChartDataLoader = ({
   ]);
   useEffect12(() => {
     const tempReport = (dashboardName ? dashboard : reports)[item.id];
+    profileDashboard("chart-data-loader-trigger-effect", {
+      reportId: item.id,
+      triggerReload: tempReport?.triggerReload ?? null,
+      hasError: !!tempReport?.error
+    });
     if (tempReport && tempReport.triggerReload) {
-      fetchReportHelper();
+      fetchReportHelper(true, "trigger-reload-effect");
     } else if (tempReport?.error) {
       setError(tempReport.error);
     }
@@ -40426,7 +41143,6 @@ function QuillTableDashboardComponent({
 // src/Chart.tsx
 init_valueFormatter();
 import { Fragment as Fragment6, jsx as jsx50, jsxs as jsxs38 } from "react/jsx-runtime";
-var MAX_ROWS_FOR_GENERIC_TABLE = 500;
 function Chart({
   colors,
   reportId,
@@ -40708,6 +41424,14 @@ function Chart({
     }
   };
   useEffect16(() => {
+    profileDashboard("chart-fetch-decision", {
+      reportId,
+      clientLoading,
+      isDashboardsLoading,
+      hasDashboardReport: !!dashboardReport,
+      hasReport: !!reports[reportId],
+      dashboardFiltersReady: dashboardFilters !== null
+    });
     if (reportId === void 0 || reportId === "" || clientLoading || isDashboardsLoading) {
       return;
     }
@@ -40729,6 +41453,7 @@ function Chart({
       });
       setLoading(false);
     } else if (!reports[reportId]) {
+      profileDashboard("chart-fetch-individual", { reportId });
       fetchReportHelper();
       return;
     }
@@ -40949,8 +41674,9 @@ var ChartDisplay = ({
     return void 0;
   }, [config, specificReportFilters, specificDashboardFilters]);
   const resolvedShowLegend = showLegend !== void 0 ? showLegend : config?.showLegend ?? false;
+  const resolvedColorMap = resolveReportColorMap(config, chartColors, colorMap);
   const [page, setPage] = useState20(0);
-  const rowCountForLimit = config?.pivot ? config.pivotRowCount ?? config.pivotRows?.length ?? config.rows?.length : config?.rowCount ?? config?.rows?.length;
+  const chartRenderLimitError = getChartRenderLimitError(config);
   const tableDisplay = useMemo17(() => {
     if (!config || config.chartType?.toLowerCase() !== "table") {
       return void 0;
@@ -40983,15 +41709,8 @@ var ChartDisplay = ({
   }, [config]);
   if (loading) {
     return /* @__PURE__ */ jsx50("div", { className, style: containerStyle, children: /* @__PURE__ */ jsx50(LoadingComponent, {}) });
-  } else if (config && !["metric", "table", "gauge", "US map", "World map"].includes(
-    config.chartType
-  ) && rowCountForLimit !== void 0 && rowCountForLimit > MAX_ROWS_FOR_GENERIC_TABLE) {
-    return /* @__PURE__ */ jsx50("div", { style: containerStyle, className, children: /* @__PURE__ */ jsx50(
-      ErrorComponent,
-      {
-        errorMessage: `Charts can only display ${MAX_ROWS_FOR_GENERIC_TABLE} rows. Please modify the query.`
-      }
-    ) });
+  } else if (chartRenderLimitError) {
+    return /* @__PURE__ */ jsx50("div", { style: containerStyle, className, children: /* @__PURE__ */ jsx50(ErrorComponent, { errorMessage: chartRenderLimitError }) });
   }
   if (config?.chartType?.toLowerCase() === "pie") {
     return /* @__PURE__ */ jsx50(
@@ -41057,7 +41776,7 @@ var ChartDisplay = ({
         xAxisFormat: config?.xAxisFormat ?? "string",
         containerStyle,
         className,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement,
         scrollable,
         showAnimation: isAnimationActive
@@ -41083,7 +41802,7 @@ var ChartDisplay = ({
         hideXAxis,
         hideYAxis,
         hideCartesianGrid,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement,
         onClickLegendElement,
         dateFilter: !hideDateRangeFilter ? dateFilter : void 0,
@@ -41111,7 +41830,7 @@ var ChartDisplay = ({
         hideXAxis,
         hideYAxis,
         hideCartesianGrid,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement,
         onClickLegendElement,
         dateFilter: !hideDateRangeFilter ? dateFilter : void 0,
@@ -41233,7 +41952,7 @@ var ChartDisplay = ({
         xAxisFormat: config?.xAxisFormat ?? "string",
         containerStyle,
         className,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement
       }
     );
@@ -41250,7 +41969,7 @@ var ChartDisplay = ({
         xAxisFormat: config?.xAxisFormat ?? "string",
         containerStyle,
         className,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement
       }
     );
@@ -41260,7 +41979,7 @@ var ChartDisplay = ({
       RadarChart,
       {
         colors: chartColors,
-        colorMap,
+        colorMap: resolvedColorMap,
         yAxisFields: config?.yAxisFields.sort(sortComparisonFirst) ?? [],
         data: config?.rows ?? [],
         xAxisField: config?.xAxisField ?? "",
@@ -41281,7 +42000,7 @@ var ChartDisplay = ({
     LineChart,
     {
       colors: chartColors,
-      colorMap,
+      colorMap: resolvedColorMap,
       yAxisFields: config?.yAxisFields.sort(sortComparisonFirst) || [],
       data: config?.rows || [],
       xAxisField: config?.xAxisField || "",
@@ -44415,7 +45134,7 @@ import { useContext as useContext22, useMemo as useMemo22 } from "react";
 init_Filter();
 
 // src/StaticChart.tsx
-import { useMemo as useMemo21 } from "react";
+import { useEffect as useEffect20, useMemo as useMemo21 } from "react";
 import { jsx as jsx60 } from "react/jsx-runtime";
 var CHART_TYPE_STYLES = {
   metric: { height: "100px", width: "200px" },
@@ -44444,6 +45163,22 @@ function StaticChart(props) {
     prevPage,
     sortRows: sortRows3
   } = useDashboardReportInternal(reportId);
+  useEffect20(() => {
+    profileDashboard("static-chart-state", {
+      reportId,
+      loading,
+      hasReport: !!report,
+      error: error ?? null,
+      rowCount: report?.rows?.length ?? 0,
+      pivotRowCount: report?.pivotRows?.length ?? 0
+    });
+  }, [reportId, loading, report, error]);
+  useEffect20(() => {
+    profileDashboard("static-chart-mounted", { reportId });
+    return () => {
+      profileDashboard("static-chart-unmounted", { reportId });
+    };
+  }, [reportId]);
   const baseStyle = report?.chartType && CHART_TYPE_STYLES[report.chartType] ? CHART_TYPE_STYLES[report.chartType] : DEFAULT_STYLE;
   const mergedStyle = className ? { ...containerStyle ?? {} } : { ...baseStyle, ...containerStyle ?? {} };
   const safeContainerStyle = {
@@ -44468,13 +45203,12 @@ function StaticChart(props) {
     });
   };
   const useLocalPivotTablePagination = isDashboardPivotTable(report);
-  const config = useMemo21(() => {
-    return report ? {
-      ...report,
-      ...useLocalPivotTablePagination ? { pagination: void 0 } : {},
-      ...report.pivot ? formattedPivotRowsAndColumns(report, [], { formatRows: false }) : {}
-    } : void 0;
-  }, [report, useLocalPivotTablePagination]);
+  const config = useMemo21(
+    () => report ? prepareStaticChartReport(report, {
+      removePagination: useLocalPivotTablePagination
+    }) : void 0,
+    [report, useLocalPivotTablePagination]
+  );
   if (error) {
     return /* @__PURE__ */ jsx60(ChartError, { errorMessage: error, containerStyle: safeContainerStyle });
   }
@@ -45258,7 +45992,7 @@ var QuillProvider_default = QuillProvider;
 // src/Table.tsx
 import {
   useContext as useContext23,
-  useEffect as useEffect20,
+  useEffect as useEffect21,
   useMemo as useMemo23,
   useState as useState27
 } from "react";
@@ -45331,7 +46065,7 @@ var Table = ({
       setLoading(false);
     }
   };
-  useEffect20(() => {
+  useEffect21(() => {
     if (props.reportId === void 0 || props.reportId === "" || clientLoading) {
       return;
     }
@@ -45443,7 +46177,7 @@ var Table_default = Table;
 import {
   useState as useState33,
   useContext as useContext30,
-  useEffect as useEffect25,
+  useEffect as useEffect26,
   useRef as useRef20,
   useMemo as useMemo28,
   useCallback as useCallback4
@@ -45452,7 +46186,7 @@ import MonacoEditor from "@monaco-editor/react";
 
 // src/ChartBuilder.tsx
 import {
-  useEffect as useEffect23,
+  useEffect as useEffect24,
   useRef as useRef19,
   useState as useState31,
   useContext as useContext28,
@@ -45482,7 +46216,7 @@ import {
   useContext as useContext25,
   useMemo as useMemo24,
   useState as useState28,
-  useEffect as useEffect21,
+  useEffect as useEffect22,
   useRef as useRef16
 } from "react";
 
@@ -46110,7 +46844,7 @@ var PivotModal = ({
       setDateRanges(dateRangeByColumn || {});
     }
   };
-  useEffect21(() => {
+  useEffect22(() => {
     const calculatePivotCardSize = () => {
       if (rowFieldRef.current && colFieldRef.current) {
         const rowFieldSize = rowFieldRef.current?.getBoundingClientRect();
@@ -46131,7 +46865,7 @@ var PivotModal = ({
       }, 500);
     }
   }, [showUpdatePivot, isOpen]);
-  useEffect21(() => {
+  useEffect22(() => {
     const fetchPivotData = async () => {
       if (pivotRowField && data && columns && pivotAggregations2?.every((p) => p?.valueField && p?.aggregationType)) {
         const pivot = buildCurrentPivot();
@@ -46243,7 +46977,7 @@ var PivotModal = ({
     };
     fetchPivotData();
   }, [initialSelectedPivotTable]);
-  useEffect21(() => {
+  useEffect22(() => {
     if (pivotRowField && data && columns) {
       getDistinctValues();
       getAllDateRangesByColumn();
@@ -46251,7 +46985,7 @@ var PivotModal = ({
       getDistinctValues();
     }
   }, [initialSelectedPivotTable, columns, data, pivotRowField]);
-  useEffect21(() => {
+  useEffect22(() => {
     setAllowedFields(initialUniqueValues || {});
     setUniqueValues(initialUniqueValues);
   }, [initialUniqueValues, columns]);
@@ -46263,7 +46997,7 @@ var PivotModal = ({
     return possibleColumns;
   };
   const [selectedPivotTable, setSelectedPivotTable] = useState28(null);
-  useEffect21(() => {
+  useEffect22(() => {
     const fetchPivotTables = async () => {
       if (selectedPivotIndex === -1) {
         return null;
@@ -46317,7 +47051,7 @@ var PivotModal = ({
     fetchPivotTables();
   }, [selectedPivotIndex, data, dateRange, createdPivots]);
   const previousUniqueValuesRef = useRef16();
-  useEffect21(() => {
+  useEffect22(() => {
     if (!uniqueValuesIsLoading && !equal5(uniqueValues, previousUniqueValuesRef.current)) {
       previousUniqueValuesRef.current = uniqueValues;
       setRecommendedPivotTables([]);
@@ -46805,7 +47539,7 @@ var PivotModal = ({
     []
   );
   const [createdPivotTables, setCreatedPivotTables] = useState28([]);
-  useEffect21(() => {
+  useEffect22(() => {
     const fetchPivotTables = async () => {
       const pts = await Promise.all(
         createdPivots.map(async (p) => {
@@ -46879,7 +47613,7 @@ var PivotModal = ({
       setPopoverPosition("bottom");
     }
   };
-  useEffect21(() => {
+  useEffect22(() => {
     handleResize();
     window.addEventListener("resize", handleResize);
     const parentElement = parentRef?.current;
@@ -47725,7 +48459,7 @@ var validateReport = (formData, dashboardData, defaultDateFilter, allTables) =>
 // src/components/Chart/InternalChart.tsx
 import {
   useState as useState29,
-  useEffect as useEffect22,
+  useEffect as useEffect23,
   useContext as useContext26,
   useMemo as useMemo25,
   useRef as useRef17,
@@ -47884,7 +48618,7 @@ function InternalChart({
   const [lockedFilters, setLockedFilters] = useState29(
     {}
   );
-  useEffect22(() => {
+  useEffect23(() => {
     return () => {
       Object.values(multiselectDebounceRef.current).forEach((timer) => {
         if (timer) {
@@ -47893,7 +48627,7 @@ function InternalChart({
       });
     };
   }, []);
-  useEffect22(() => {
+  useEffect23(() => {
     if (reportDateFilter) {
       const customDateFilter = filters?.find(
         (f) => f.filterType === "date" /* Date */
@@ -49139,7 +49873,7 @@ function ChartBuilderWithModal(props) {
   const [filtersEnabledState, setFiltersEnabledState] = useState31(
     !!props.reportId
   );
-  useEffect23(() => {
+  useEffect24(() => {
     function handleResize() {
       const screenSize = window.innerWidth;
       if (screenSize >= 1200) {
@@ -49378,7 +50112,7 @@ function ChartBuilder({
       setFilterIssues([]);
     }
   };
-  useEffect23(() => {
+  useEffect24(() => {
     const handleResize = () => {
       setWindowWidth(window.innerWidth);
       if (inputRef.current && selectRef.current) {
@@ -49414,7 +50148,7 @@ function ChartBuilder({
   const hasExistingData = useMemo27(() => {
     return report?.rows && report.rows.length > 0 || report?.pivotRows && report.pivotRows.length > 0;
   }, [report?.rows, report?.pivotRows]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (!reportFilters[report?.id ?? TEMP_REPORT_ID]) {
       loadFiltersForReport(
         report?.id ?? TEMP_REPORT_ID,
@@ -49873,12 +50607,12 @@ function ChartBuilder({
     customFieldsInTabularColumns,
     chartBuilderFormDataContainsCustomFields
   ]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (!loadingFormData && triggeredEditChart) {
       editChart();
     }
   }, [loadingFormData]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (initializedRef.current) {
       return;
     }
@@ -50006,13 +50740,13 @@ function ChartBuilder({
     }
     getFormData();
   }, []);
-  useEffect23(() => {
+  useEffect24(() => {
     if (report?.triggerReload === false && report?.rows) {
       setRows(report.rows);
       setIsLoading(false);
     }
   }, [report?.triggerReload, report?.rows]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (!report?.rows || report.rows.length === 0) return;
     setRows((prev) => {
       if (prev.length > 0) return prev;
@@ -50020,7 +50754,7 @@ function ChartBuilder({
       return report.rows;
     });
   }, [report?.rows]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (report?.triggerReload === false && report?.columns && report.columns.length > 0 && formData.columns.length === 0) {
       const mappedColumns = report.columns.map((col) => ({
         ...col,
@@ -50033,7 +50767,7 @@ function ChartBuilder({
     }
   }, [report?.triggerReload, report?.columns, formData.columns.length]);
   const ranMountQuery = useRef19(false);
-  useEffect23(() => {
+  useEffect24(() => {
     if (runQueryOnMount && reportFiltersLoaded && filtersEnabled && !ranMountQuery.current) {
       ranMountQuery.current = true;
       handleRunQuery(baseProcessing, currentDashboardFilters);
@@ -50270,7 +51004,7 @@ function ChartBuilder({
     });
   };
   const filtersEnabledRef = useRef19(filtersEnabled);
-  useEffect23(() => {
+  useEffect24(() => {
     if (filtersEnabledRef.current !== filtersEnabled) {
       filtersEnabledRef.current = filtersEnabled;
       setCurrentPage(0);
@@ -53085,7 +53819,7 @@ function reconcileReportWithColumns(report, columns, previousReport) {
 }
 
 // src/hooks/useLongLoading.tsx
-import { useContext as useContext29, useEffect as useEffect24, useState as useState32 } from "react";
+import { useContext as useContext29, useEffect as useEffect25, useState as useState32 } from "react";
 function useLongLoading(isLoading, meta) {
   const {
     origin,
@@ -53096,7 +53830,7 @@ function useLongLoading(isLoading, meta) {
   const [isLongLoading, setIsLongLoading] = useState32(false);
   const [isAbnormalLoading, setIsAbnormalLoading] = useState32(false);
   const { eventTracking } = useContext29(EventTrackingContext);
-  useEffect24(() => {
+  useEffect25(() => {
     let longTimer = null;
     let abnormalTimer = null;
     if (isLoading) {
@@ -53354,17 +54088,17 @@ function SQLEditor({
     schemaData.schemaWithCustomFields,
     destinationDashboardConfig?.tenantKeys
   ]);
-  useEffect25(() => {
+  useEffect26(() => {
     if (tableRef.current) {
       setCachedHeight(tableRef.current.clientHeight);
     }
   }, [tableRef.current?.clientHeight]);
-  useEffect25(() => {
+  useEffect26(() => {
     if (!data && !dashboardIsLoading) {
       reload();
     }
   }, [data, dashboardIsLoading]);
-  useEffect25(() => {
+  useEffect26(() => {
     const loadReport = async () => {
       let reportToLoad;
       if (!client) {
@@ -53439,14 +54173,14 @@ function SQLEditor({
       );
     }) ?? [];
   }, [tableSearchQuery, schemaData.schemaWithCustomFields]);
-  useEffect25(() => {
+  useEffect26(() => {
     if (client) {
       setRows([]);
       setColumns([]);
       setDisplayTable(false);
     }
   }, [client?.id]);
-  useEffect25(() => {
+  useEffect26(() => {
     if (isChartBuilderOpen === false) {
       onCloseChartBuilder && onCloseChartBuilder();
     }
@@ -53713,7 +54447,7 @@ function SQLEditor({
     }
     return getTablesHelper(getSelectFromAST(resp.ast), dbTables, skipStar);
   };
-  useEffect25(() => {
+  useEffect26(() => {
     if (onChangeQuery) {
       onChangeQuery(query || "");
     }
@@ -54342,7 +55076,7 @@ var SQLEditorComponent = ({
   const [editorKey, setEditorKey] = useState33(0);
   const { eventTracking } = useContext30(EventTrackingContext);
   const currentProvider = useRef20(null);
-  useEffect25(() => {
+  useEffect26(() => {
     if (currentProvider.current) {
       currentProvider.current.dispose();
       if (schema && schema.length !== 0) {
@@ -54812,14 +55546,14 @@ function SchemaItem({
 // src/ReportBuilder.tsx
 import {
   useContext as useContext34,
-  useEffect as useEffect29,
+  useEffect as useEffect30,
   useRef as useRef22,
   useState as useState39
 } from "react";
 init_constants();
 
 // src/hooks/useReportBuilder.tsx
-import { useContext as useContext31, useEffect as useEffect26, useMemo as useMemo29, useState as useState34 } from "react";
+import { useContext as useContext31, useEffect as useEffect27, useMemo as useMemo29, useState as useState34 } from "react";
 init_tableProcessing();
 init_ReportBuilder();
 init_constants();
@@ -56047,7 +56781,7 @@ var useReportBuilderInternal = ({
       flags: tempReport?.flags
     });
   };
-  useEffect26(() => {
+  useEffect27(() => {
     if (!client) {
       return;
     }
@@ -56081,7 +56815,7 @@ var useReportBuilderInternal = ({
     }
     return state;
   };
-  useEffect26(() => {
+  useEffect27(() => {
     const loadChart = async () => {
       if (!client || !reportId) return;
       const report = allReportsById[reportId];
@@ -56119,7 +56853,7 @@ var useReportBuilderInternal = ({
       loadChart();
     }
   }, [allReportsById[reportId || ""], client]);
-  useEffect26(() => {
+  useEffect27(() => {
     if (initialTableName) {
       const tableColumns = filteredSchema.find((table) => {
         return table.name === initialTableName;
@@ -56139,7 +56873,7 @@ var useReportBuilderInternal = ({
       }
     }
   }, [filteredSchema, initialTableName]);
-  useEffect26(() => {
+  useEffect27(() => {
     if (!data && !dashboardIsLoading) {
       reload();
     }
@@ -56349,7 +57083,7 @@ var useReportBuilder = ({
 init_ReportBuilder();
 
 // src/components/ReportBuilder/AddColumnModal.tsx
-import { useState as useState35, useRef as useRef21, useMemo as useMemo30, useEffect as useEffect27, useContext as useContext32 } from "react";
+import { useState as useState35, useRef as useRef21, useMemo as useMemo30, useEffect as useEffect28, useContext as useContext32 } from "react";
 import {
   DndContext as DndContext2,
   closestCenter as closestCenter2,
@@ -56425,13 +57159,13 @@ function AddColumnModal({
       return columnOptions.includes(column) && (search.length === 0 || column.toLowerCase().includes(search.toLowerCase()) || snakeAndCamelCaseToTitleCase(column).toLowerCase().includes(search.toLowerCase()));
     });
   }, [search, columnOptions, orderedColumnNames]);
-  useEffect27(() => {
+  useEffect28(() => {
     const remainingColumns = columnOptions.filter(
       (col) => !modalSelectedColumns.includes(col)
     );
     setOrderedColumnNames([...modalSelectedColumns, ...remainingColumns]);
   }, [columnOptions]);
-  useEffect27(() => {
+  useEffect28(() => {
     if (!schemaLoading && initialLoad) {
       setTimeout(() => setInitialLoad(false), 200);
     }
@@ -57314,7 +58048,7 @@ var AddFilters = ({
 };
 
 // src/internals/ReportBuilder/PivotForm.tsx
-import { useContext as useContext33, useEffect as useEffect28, useState as useState36 } from "react";
+import { useContext as useContext33, useEffect as useEffect29, useState as useState36 } from "react";
 init_textProcessing();
 init_pivotProcessing();
 import { jsx as jsx77, jsxs as jsxs56 } from "react/jsx-runtime";
@@ -57358,7 +58092,7 @@ function PivotForm({
   );
   const [showLimitInput, setShowLimitInput] = useState36(!!pivotLimit);
   const [showSortInput, setShowSortInput] = useState36(!!pivotSort);
-  useEffect28(() => {
+  useEffect29(() => {
     if (uniqueValues) {
       const possibleColumns = getPossiblePivotFieldOptions(
         columns,
@@ -57369,12 +58103,12 @@ function PivotForm({
       setAllowedValueFields(possibleColumns.valueFields);
     }
   }, [columns, uniqueValues]);
-  useEffect28(() => {
+  useEffect29(() => {
     setSortFieldInput(pivotSort?.sortField ?? "");
     setSortDirectionInput(pivotSort?.sortDirection ?? "");
     setShowSortInput(!!pivotSort);
   }, [pivotSort]);
-  useEffect28(() => {
+  useEffect29(() => {
     setLimitInput(pivotLimit?.toString() ?? "");
     setShowLimitInput(!!pivotLimit);
   }, [pivotLimit]);
@@ -58916,7 +59650,7 @@ function ReportBuilder({
       setTimeout(() => setIsCopying(false), 800);
     }
   };
-  useEffect29(() => {
+  useEffect30(() => {
     if (isChartBuilderOpen === false) {
       onCloseChartBuilder && onCloseChartBuilder();
     }
@@ -59350,7 +60084,7 @@ function ReportBuilder({
 // src/ChartEditor.tsx
 import {
   useContext as useContext35,
-  useEffect as useEffect30,
+  useEffect as useEffect31,
   useMemo as useMemo32,
   useRef as useRef23,
   useState as useState40
@@ -59434,7 +60168,7 @@ function ChartEditor({
   const dateRange = useMemo32(() => {
     return dateFilter?.startDate ? { start: dateFilter.startDate, end: dateFilter.endDate } : void 0;
   }, [dateFilter]);
-  useEffect30(() => {
+  useEffect31(() => {
     function handleResize() {
       const screenSize = window.innerWidth;
       if (screenSize >= 1200) {
@@ -59482,7 +60216,7 @@ function ChartEditor({
     }
     addReport(report2);
   };
-  useEffect30(() => {
+  useEffect31(() => {
     if (!isOpen || !reportId) {
       return;
     }
@@ -59579,7 +60313,7 @@ function ChartEditor({
 }
 
 // src/Chat.tsx
-import { useContext as useContext37, useEffect as useEffect33, useRef as useRef25, useState as useState43 } from "react";
+import { useContext as useContext37, useEffect as useEffect33, useRef as useRef25, useState as useState42 } from "react";
 
 // src/ChatChartCard.tsx
 import { useMemo as useMemo34 } from "react";
@@ -59595,7 +60329,7 @@ import {
   useMemo as useMemo33,
   useReducer as useReducer2,
   useRef as useRef24,
-  useState as useState42
+  useState as useState41
 } from "react";
 import {
   keepPreviousData,
@@ -60786,20 +61520,6 @@ function useFormReducer(state, action) {
   }
 }
 
-// src/hooks/useForm.refreshDebounce.ts
-import { useEffect as useEffect31, useState as useState41 } from "react";
-var REPORT_REFRESH_DEBOUNCE_MS = 200;
-function useDebouncedRefreshInput(value, delayMs = REPORT_REFRESH_DEBOUNCE_MS) {
-  const [debouncedValue, setDebouncedValue] = useState41(value);
-  useEffect31(() => {
-    const timeout = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delayMs);
-    return () => clearTimeout(timeout);
-  }, [delayMs, value]);
-  return debouncedValue;
-}
-
 // src/utils/pivotDateBuckets.ts
 import {
   eachDayOfInterval as eachDayOfInterval3,
@@ -61933,22 +62653,6 @@ var buildQueryBuilderFieldConfigByName = (schemaTables) => {
 function getReportBuilderTableNames(report) {
   return (report?.reportBuilderState?.tables ?? []).map((table) => String(table.name ?? "").trim()).filter(Boolean);
 }
-function getPivotAggregations(report) {
-  const pivot = report.pivot;
-  if (!pivot) return [];
-  if ("aggregations" in pivot && Array.isArray(pivot.aggregations)) {
-    return pivot.aggregations;
-  }
-  if ("aggregationType" in pivot && pivot.aggregationType) {
-    return [
-      {
-        aggregationType: pivot.aggregationType,
-        valueField: pivot.valueField
-      }
-    ];
-  }
-  return [];
-}
 function trimAggregationSuffix(value, aggregationType) {
   if (!aggregationType) return value;
   const suffixes = [`_${aggregationType}`, `:${aggregationType}`];
@@ -61956,16 +62660,6 @@ function trimAggregationSuffix(value, aggregationType) {
   if (!matchedSuffix) return value;
   return value.slice(0, -matchedSuffix.length);
 }
-function getAggregationFieldKey(aggregation, hasMultipleAggregations) {
-  if (!aggregation.aggregationType) return null;
-  if (!aggregation.valueField && aggregation.aggregationType === "percentage") {
-    return "percentage";
-  }
-  if (aggregation.valueField) {
-    return hasMultipleAggregations ? `${aggregation.valueField}_${aggregation.aggregationType}` : aggregation.valueField;
-  }
-  return hasMultipleAggregations ? `${aggregation.aggregationType}_${aggregation.aggregationType}` : String(aggregation.aggregationType);
-}
 function buildSyntheticAggregationOnlyDisplayRows(chart) {
   const pivot = chart.pivot;
   if (!pivot) return null;
@@ -62005,69 +62699,6 @@ function buildSyntheticAggregationOnlyDisplayRows(chart) {
   }
   return null;
 }
-function trailingPivotMeasureSegmentBeforeAggType(normalizedField, normalizedAggregationType) {
-  const suf = `_${normalizedAggregationType}`;
-  if (!normalizedField.endsWith(suf)) return null;
-  const base = normalizedField.slice(0, -suf.length);
-  const lastUnderscore = base.lastIndexOf("_");
-  if (lastUnderscore < 0) return null;
-  const candidate = base.slice(lastUnderscore + 1).trim();
-  return candidate || null;
-}
-var PIVOT_FIELD_AGG_MATCH_TIER = {
-  looseAggSuffix: 1,
-  rawValueField: 2,
-  pivotWideValueAndAggSuffix: 3,
-  canonicalValueAggOrCount: 4
-};
-function matchPivotFieldToAggregationTier(normalizedField, aggregation) {
-  const aggregationType = String(aggregation.aggregationType ?? "").trim();
-  if (!aggregationType) return null;
-  const t = aggregationType.toLowerCase();
-  const vf = String(aggregation.valueField ?? "").trim().toLowerCase();
-  if (!vf && normalizedField === t) {
-    return PIVOT_FIELD_AGG_MATCH_TIER.canonicalValueAggOrCount;
-  }
-  if (vf && normalizedField === vf) {
-    return PIVOT_FIELD_AGG_MATCH_TIER.rawValueField;
-  }
-  if (vf && normalizedField === `${vf}_${t}`) {
-    return PIVOT_FIELD_AGG_MATCH_TIER.canonicalValueAggOrCount;
-  }
-  if (vf && normalizedField.endsWith(`_${vf}_${t}`)) {
-    return PIVOT_FIELD_AGG_MATCH_TIER.pivotWideValueAndAggSuffix;
-  }
-  if (normalizedField.endsWith(`_${t}`) || normalizedField.endsWith(`:${t}`)) {
-    const embeddedMeasure = trailingPivotMeasureSegmentBeforeAggType(
-      normalizedField,
-      t
-    );
-    if (embeddedMeasure && vf && embeddedMeasure !== vf) {
-      return null;
-    }
-    return PIVOT_FIELD_AGG_MATCH_TIER.looseAggSuffix;
-  }
-  return null;
-}
-function findAggregationForFieldStrict(field, aggregations) {
-  const normalizedField = String(field ?? "").trim().toLowerCase();
-  let best = null;
-  for (let index = 0; index < aggregations.length; index++) {
-    const aggregation = aggregations[index];
-    const tier = matchPivotFieldToAggregationTier(normalizedField, aggregation);
-    if (tier == null) continue;
-    if (!best || tier > best.tier || tier === best.tier && index < best.index) {
-      best = { aggregation, tier, index };
-    }
-  }
-  return best?.aggregation;
-}
-function getAggregationIdentityKey(aggregation) {
-  if (!aggregation) return "";
-  const aggregationType = String(aggregation.aggregationType ?? "").trim().toLowerCase();
-  const valueField = String(aggregation.valueField ?? "").trim().toLowerCase();
-  return `${aggregationType}::${valueField}`;
-}
 function buildAggregationLabel(aggregation, report) {
   const aggregationType = aggregation.aggregationType ?? "value";
   const reportBuilderTableNames = report?.reportBuilderState?.tables?.map((table) => table.name).filter(Boolean) ?? [];
@@ -64617,10 +65248,10 @@ function generateDraftSessionId() {
 }
 function useReport(reportIdArg, options = {}) {
   const propReportId = String(reportIdArg ?? "").trim();
-  const [createdReportBootstrap, setCreatedReportBootstrap] = useState42(null);
+  const [createdReportBootstrap, setCreatedReportBootstrap] = useState41(null);
   const effectiveReportId = propReportId || createdReportBootstrap?.reportId || "";
   const { eventTracking } = useContext36(EventTrackingContext);
-  const [draftSessionId, setDraftSessionId] = useState42(generateDraftSessionId);
+  const [draftSessionId, setDraftSessionId] = useState41(generateDraftSessionId);
   const useInMemoryEngines = options.useInMemoryEngines ?? false;
   const dateBucketMode = options.dateBucketMode ?? "dynamic";
   const restrictFieldOptionsToSelectedDatasources = options.restrictFieldOptionsToSelectedDatasources ?? true;
@@ -64634,7 +65265,7 @@ function useReport(reportIdArg, options = {}) {
     ...getDefaultPaginationState(),
     ...options.initialState?.pagination ?? {}
   });
-  const [internalPagination, setInternalPagination] = useState42(
+  const [internalPagination, setInternalPagination] = useState41(
     initialPaginationRef.current
   );
   const pagination = controlledPagination ?? internalPagination;
@@ -64727,13 +65358,13 @@ function useReport(reportIdArg, options = {}) {
     dateBucketSetViaSetReportRef.current = false;
     aggregationStateSetViaSetReportRef.current = false;
   }
-  const [chartPivotHydrationEpoch, setChartPivotHydrationEpoch] = useState42(0);
+  const [chartPivotHydrationEpoch, setChartPivotHydrationEpoch] = useState41(0);
   const [
     expandReportBuilderColumnsForFlatTable,
     setExpandReportBuilderColumnsForFlatTable
-  ] = useState42(false);
+  ] = useState41(false);
   const prevPivotStateForColumnExpansionRef = useRef24(null);
-  const [sourceReport, setSourceReport] = useState42(
+  const [sourceReport, setSourceReport] = useState41(
     null
   );
   const prevSourceReportIdForPivotHydrationRef = useRef24(null);
@@ -64748,14 +65379,15 @@ function useReport(reportIdArg, options = {}) {
       lastPivotHydrateCompletedSourceIdRef.current = null;
     }
   }
-  const [preserveSchemaWideOptions, setPreserveSchemaWideOptions] = useState42(false);
-  const [initialSchemaScopedTableNames, setInitialSchemaScopedTableNames] = useState42(null);
-  const [tableColumnsEditedSignature, setTableColumnsEditedSignature] = useState42(null);
+  const [preserveSchemaWideOptions, setPreserveSchemaWideOptions] = useState41(false);
+  const [initialSchemaScopedTableNames, setInitialSchemaScopedTableNames] = useState41(null);
+  const [tableColumnsEditedSignature, setTableColumnsEditedSignature] = useState41(null);
   useEffect32(() => {
     setTableColumnsEditedSignature(null);
   }, [effectiveReportId]);
-  const [chartAxisEdits, setChartAxisEdits] = useState42({});
-  const [chartVisibilityOverrides, setChartVisibilityOverrides] = useState42({});
+  const [chartAxisEdits, setChartAxisEdits] = useState41({});
+  const [chartVisibilityOverrides, setChartVisibilityOverrides] = useState41({});
+  const [chartSortOverride, setChartSortOverride] = useState41(void 0);
   const [client] = useContext36(ClientContext);
   const { loadDashboard } = useContext36(DashboardConfigContext);
   const queryClient = useQueryClient2();
@@ -64887,6 +65519,7 @@ function useReport(reportIdArg, options = {}) {
   useEffect32(() => {
     setChartAxisEdits({});
     setChartVisibilityOverrides({});
+    setChartSortOverride(void 0);
   }, [effectiveReportId]);
   const bootstrapReportTaskUsedForReportIdRef = useRef24(null);
   const sharedInitialRequestUsedForReportIdRef = useRef24(null);
@@ -66789,7 +67422,7 @@ function useReport(reportIdArg, options = {}) {
     filterStack
   ]);
   const shouldForceTableRefreshFromFilters = !useInMemoryEngines && !pivotState;
-  const immediateTableRefreshInput = useMemo33(
+  const tableRefreshInput = useMemo33(
     () => ({
       version: tableRefreshVersion,
       reportBuilderStateHash: effectiveReportBuilderStateHash,
@@ -66805,18 +67438,12 @@ function useReport(reportIdArg, options = {}) {
       tableRefreshVersion
     ]
   );
-  const debouncedTableRefreshInput = useDebouncedRefreshInput(
-    immediateTableRefreshInput
-  );
-  const disableTableRefreshDebounceForDiagnostics = process.env.NODE_ENV === "test" && process.env.QUILL_DISABLE_REPORT_REFRESH_DEBOUNCE === "true";
-  const tableRefreshInput = disableTableRefreshDebounceForDiagnostics ? immediateTableRefreshInput : debouncedTableRefreshInput;
-  const tableRefreshInputIsCurrent = tableRefreshInput.version === tableRefreshVersion && tableRefreshInput.reportBuilderStateHash === effectiveReportBuilderStateHash;
   const completedTableRefreshRef = useRef24(null);
   if (completedTableRefreshRef.current?.reportId !== effectiveReportId) {
     completedTableRefreshRef.current = null;
   }
-  const tableRefreshInputAlreadyCompleted = !disableTableRefreshDebounceForDiagnostics && completedTableRefreshRef.current?.reportId === effectiveReportId && completedTableRefreshRef.current.version >= tableRefreshInput.version;
-  const tableRefreshQueryEnabled = !reportOverride && tableRefreshInputIsCurrent && !tableRefreshInputAlreadyCompleted && tableRefreshInput.version > 0 && Boolean(sourceReport) && Boolean(client) && Boolean(tableRefreshInput.reportBuilderState) && !pendingPivotRefresh && sourceReportMatchesEffectiveReportId && tableRefreshInput.shouldRefresh;
+  const tableRefreshInputAlreadyCompleted = completedTableRefreshRef.current?.reportId === effectiveReportId && completedTableRefreshRef.current.version >= tableRefreshInput.version;
+  const tableRefreshQueryEnabled = !reportOverride && !tableRefreshInputAlreadyCompleted && tableRefreshInput.version > 0 && Boolean(sourceReport) && Boolean(client) && Boolean(tableRefreshInput.reportBuilderState) && !pendingPivotRefresh && sourceReportMatchesEffectiveReportId && tableRefreshInput.shouldRefresh;
   const tableRefreshQuery = useQuery({
     queryKey: createUseFormTableRefreshQueryKey({
       reportId: effectiveReportId,
@@ -67310,9 +67937,9 @@ function useReport(reportIdArg, options = {}) {
       (option) => ["ASC", "DESC"].map((direction) => {
         const field = String(option.value ?? "").trim();
         const labelField = String(option.label ?? field).trim();
-        const directionLabel = toFlatSortDirectionLabel(direction);
+        const directionLabel2 = toFlatSortDirectionLabel(direction);
         return {
-          label: `${toTitleCaseLabel(labelField)} ${directionLabel}`,
+          label: `${toTitleCaseLabel(labelField)} ${directionLabel2}`,
           value: toFlatSortValue(field, direction)
         };
       })
@@ -68000,9 +68627,7 @@ function useReport(reportIdArg, options = {}) {
       chartAxesBaseChart,
       resolvedXAxisField
     );
-    if (bucketFormat && (defaultFormat === "string" || chartAxesBaseChart.pivot?.dateBucket === "week")) {
-      defaultFormat = bucketFormat;
-    }
+    if (bucketFormat) return bucketFormat;
     if (isPivotTableDateBucketRowAxis(chartAxesBaseChart, resolvedXAxisField) && chartAxisEdits.xAxisFormat === void 0) {
       defaultFormat = "string";
     }
@@ -68267,6 +68892,16 @@ function useReport(reportIdArg, options = {}) {
       }
     };
   }, [chart, filterOptions, filtersForQueryBuilder]);
+  const resolvedChartSort = chartSortOverride === void 0 ? sourceReport?.chartSort : chartSortOverride ?? void 0;
+  const chartSort = formatChartSortValue(resolvedChartSort);
+  const chartSortOptions = useMemo33(
+    () => getChartSortOptions(chartForUi),
+    [chartForUi]
+  );
+  const chartWithSort = useMemo33(
+    () => chartForUi ? applyChartSort(chartForUi, resolvedChartSort) : chartForUi,
+    [chartForUi, resolvedChartSort]
+  );
   const isPivotTableChart = String(chartType ?? "").toLowerCase() === "table" && Boolean(pivotState);
   const pivotTableColumnControls = useMemo33(
     () => isPivotTableChart ? buildPivotColumnPivotTableFormattingColumns(pivotState, chart) : null,
@@ -69061,6 +69696,11 @@ function useReport(reportIdArg, options = {}) {
         showLegend: Boolean(effectiveNextState.showLegend)
       }));
     }
+    if (effectiveNextState.chartSort !== void 0) {
+      setChartSortOverride(
+        parseChartSortValue(effectiveNextState.chartSort) ?? null
+      );
+    }
     if (effectiveNextState.xAxis !== void 0 || effectiveNextState.yAxis !== void 0 || effectiveNextState.chartAxes !== void 0) {
       const cx = {
         ...effectiveNextState.chartAxes,
@@ -69633,57 +70273,7 @@ function useReport(reportIdArg, options = {}) {
           })
         });
       }
-    } catch (error) {
-      const requestedFieldNames = (resolved?.rules ?? []).map((rule) => String(rule?.field ?? "").trim()).filter(Boolean);
-      const relevantFieldConfigs = Object.fromEntries(
-        Object.entries(queryBuilderFieldConfigByName ?? {}).filter(
-          ([key, config]) => {
-            const configuredField = String(config?.field ?? "").trim();
-            return requestedFieldNames.some((requestedField) => {
-              const bareRequestedField = requestedField.split(".").pop() ?? "";
-              return key === requestedField || configuredField === requestedField || configuredField === bareRequestedField;
-            });
-          }
-        )
-      );
-      console.error("[useForm] setFilters swallowed error", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        reportId: effectiveReportId,
-        requestedRules: (resolved?.rules ?? []).map((rule) => ({
-          table: rule?.table,
-          field: rule?.field,
-          operator: rule?.operator,
-          value: rule?.value
-        })),
-        normalizedRules: (nextFiltersNormalizedForConfig?.rules ?? []).map((rule) => ({
-          table: rule?.table,
-          field: rule?.field,
-          operator: rule?.operator,
-          value: rule?.value
-        })),
-        relevantFieldConfigs,
-        pivot: nextPivot,
-        reportBuilderTables: effectiveReportBuilderState?.tables,
-        reportBuilderColumns: effectiveReportBuilderColumns.filter(
-          (column) => requestedFieldNames.some((requestedField) => {
-            const bareRequestedField = requestedField.split(".").pop() ?? "";
-            return String(column.field ?? "").trim() === bareRequestedField;
-          })
-        ).map((column) => ({
-          table: column.table,
-          field: column.field,
-          alias: column.alias
-        })),
-        schemaTablesWithRequestedFields: schemaForReportBuilderState.filter(
-          (table2) => table2.columns?.some(
-            (column) => requestedFieldNames.some(
-              (requestedField) => String(column.field ?? "").trim() === (requestedField.split(".").pop() ?? "")
-            )
-          )
-        ).map((table2) => table2.name),
-        fieldConfigKeys: Object.keys(queryBuilderFieldConfigByName ?? {})
-      });
+    } catch {
     }
   };
   const saveChanges = useCallback5(async () => {
@@ -69722,7 +70312,8 @@ function useReport(reportIdArg, options = {}) {
         xAxisFormat: resolvedXAxisFormat,
         xAxisLabel: resolvedXAxisLabel,
         yAxisFields: resolvedYAxisFields,
-        showLegend: chartVisibility.showLegend
+        showLegend: chartVisibility.showLegend,
+        chartSort: resolvedChartSort ?? null
       },
       dashboardItemId: effectiveReportId || void 0,
       client,
@@ -69759,6 +70350,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedXAxisFormat,
     resolvedXAxisLabel,
     resolvedChartType,
+    resolvedChartSort,
     resolvedYAxisFields,
     sourceReport,
     setDraftSessionId,
@@ -69767,7 +70359,7 @@ function useReport(reportIdArg, options = {}) {
   ]);
   return {
     /* ── Chart & table (exceptions: not value/options pairs) ── */
-    chart: chartForUi,
+    chart: chartWithSort,
     chartLoading,
     table,
     tableLoading,
@@ -69795,6 +70387,9 @@ function useReport(reportIdArg, options = {}) {
     aggregationDescriptionOptions: cleanedAggregations,
     sort: cleanedSort,
     sortOptions,
+    /** Display-only chart ordering; update with a value from `chartSortOptions`. */
+    chartSort,
+    chartSortOptions,
     chartType: resolvedChartType,
     chartTypeOptions: chartTypes,
     /** Selected tabular columns in display order. */
@@ -70138,7 +70733,7 @@ function ToolCallBlock({ toolCall }) {
   );
 }
 function ToolCallResult({ content }) {
-  const [expanded, setExpanded] = useState43(false);
+  const [expanded, setExpanded] = useState42(false);
   if (!content) return null;
   const isLong = content.length > 300;
   const displayed = isLong && !expanded ? content.slice(0, 300) + "..." : content;
@@ -70193,11 +70788,11 @@ function Chat({
   const [client] = useContext37(ClientContext);
   const { getToken } = useContext37(FetchContext);
   const { tenants } = useContext37(TenantContext);
-  const [messages, setMessages] = useState43([]);
-  const [input, setInput] = useState43("");
-  const [inputError, setInputError] = useState43("");
-  const [isLoading, setIsLoading] = useState43(false);
-  const [model, setModel] = useState43("gemini-3-flash-preview");
+  const [messages, setMessages] = useState42([]);
+  const [input, setInput] = useState42("");
+  const [inputError, setInputError] = useState42("");
+  const [isLoading, setIsLoading] = useState42(false);
+  const [model, setModel] = useState42("gemini-3-flash-preview");
   const containerRef = useRef25(null);
   const textareaRef = useRef25(null);
   const abortControllerRef = useRef25(null);
@@ -70635,7 +71230,7 @@ function Chat({
 }
 
 // src/hooks/useReportFilterDraft.ts
-import { useCallback as useCallback6, useEffect as useEffect34, useMemo as useMemo35, useRef as useRef26, useState as useState44 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect34, useMemo as useMemo35, useRef as useRef26, useState as useState43 } from "react";
 var normalizeOperatorKey = (operator) => String(operator ?? "").trim().toLowerCase().replace(/[_\s]+/g, "");
 var defaultFilterRuleValueForOperator = (operator) => {
   const key = normalizeOperatorKey(operator);
@@ -70697,9 +71292,9 @@ function useReportFilterDraft(args) {
     () => fieldCatalogSignature(effectiveFields),
     [effectiveFields]
   );
-  const [resetEpoch, setResetEpoch] = useState44(0);
-  const [draftQuery, setDraftQuery] = useState44(committed);
-  const [hasUnappliedFilterChanges, setHasUnappliedFilterChanges] = useState44(false);
+  const [resetEpoch, setResetEpoch] = useState43(0);
+  const [draftQuery, setDraftQuery] = useState43(committed);
+  const [hasUnappliedFilterChanges, setHasUnappliedFilterChanges] = useState43(false);
   const draftResetKey = `${reportId}|${committedSignature}|${resetEpoch}`;
   useEffect34(() => {
     setDraftQuery(committedRef.current);
@@ -70793,7 +71388,7 @@ import {
   useContext as useContext38,
   useLayoutEffect as useLayoutEffect5,
   useRef as useRef27,
-  useState as useState45
+  useState as useState44
 } from "react";
 import { jsx as jsx89, jsxs as jsxs66 } from "react/jsx-runtime";
 var CHART_MIN_PX = 220;
@@ -70895,7 +71490,7 @@ function ReportDetail({
   const useDetailTableFromUseForm = isTableChart && !isPivotTableChartConfig(chart);
   const showBottomRawTable = !isTableChart;
   const chartSlotRef = useRef27(null);
-  const [chartHeightPx, setChartHeightPx] = useState45(360);
+  const [chartHeightPx, setChartHeightPx] = useState44(360);
   useLayoutEffect5(() => {
     const el = chartSlotRef.current;
     if (!el) {
@@ -71059,7 +71654,7 @@ var useTenants = (dashboardName) => {
 };
 
 // src/hooks/useQuill.ts
-import { useContext as useContext40, useEffect as useEffect36, useMemo as useMemo36, useState as useState46 } from "react";
+import { useContext as useContext40, useEffect as useEffect36, useMemo as useMemo36, useState as useState45 } from "react";
 init_paginationProcessing();
 init_tableProcessing();
 init_dataProcessing();
@@ -71082,9 +71677,9 @@ var useQuill = (reportId, pagination) => {
   const [client, isClientLoading] = useContext40(ClientContext);
   const { tenants } = useContext40(TenantContext);
   const { eventTracking } = useContext40(EventTrackingContext);
-  const [loading, setLoading] = useState46(true);
-  const [error, setError] = useState46(void 0);
-  const [previousPage, setPreviousPage] = useState46(0);
+  const [loading, setLoading] = useState45(true);
+  const [error, setError] = useState45(void 0);
+  const [previousPage, setPreviousPage] = useState45(0);
   const processedReport = useMemo36(() => {
     return reportId && allReportsById[reportId] ? convertInternalReportToReport(
       mergeComparisonRange(allReportsById[reportId]),
@@ -71093,7 +71688,7 @@ var useQuill = (reportId, pagination) => {
       "useQuill"
     ) : void 0;
   }, [reportId, reportId && allReportsById[reportId], specificReportFilters]);
-  const [additionalProcessing, setAdditionProcessing] = useState46(
+  const [additionalProcessing, setAdditionProcessing] = useState45(
     pagination ? {
       page: pagination
     } : void 0
@@ -71309,7 +71904,7 @@ var useMemoizedRows = (reportId) => {
 };
 
 // src/hooks/useAskQuill.tsx
-import { useContext as useContext41, useEffect as useEffect37, useState as useState47 } from "react";
+import { useContext as useContext41, useEffect as useEffect37, useState as useState46 } from "react";
 init_astProcessing();
 init_astFilterProcessing();
 init_pivotProcessing();
@@ -71342,8 +71937,8 @@ var useAskQuill = (dashboardName) => {
   const { tenants } = useContext41(TenantContext);
   const { getToken } = useContext41(FetchContext);
   const { eventTracking } = useContext41(EventTrackingContext);
-  const [astInfo, setAstInfo] = useState47(void 0);
-  const [data, setData] = useState47({
+  const [astInfo, setAstInfo] = useState46(void 0);
+  const [data, setData] = useState46({
     rows: [],
     columns: [],
     pivot: null,
@@ -71353,9 +71948,9 @@ var useAskQuill = (dashboardName) => {
     pivotColumnFields: [],
     pivotValueFields: []
   });
-  const [loading, setLoading] = useState47(false);
-  const [error, setError] = useState47(void 0);
-  const [ask, setAsk] = useState47(
+  const [loading, setLoading] = useState46(false);
+  const [error, setError] = useState46(void 0);
+  const [ask, setAsk] = useState46(
     async () => void 0
   );
   const askHelper = async (query) => {
@@ -71569,13 +72164,13 @@ var useAskQuill = (dashboardName) => {
 };
 
 // src/hooks/useVirtualTables.tsx
-import { useContext as useContext42, useState as useState48 } from "react";
+import { useContext as useContext42, useState as useState47 } from "react";
 var useVirtualTables = () => {
   const [schemaData, setSchemaData] = useContext42(SchemaDataContext);
   const { tenants } = useContext42(TenantContext);
   const { getToken, quillFetchWithToken } = useContext42(FetchContext);
   const { eventTracking } = useContext42(EventTrackingContext);
-  const [loadingTables, setLoadingTables] = useState48({});
+  const [loadingTables, setLoadingTables] = useState47({});
   const handleReload = async (client, caller) => {
     setSchemaData({ ...schemaData, isSchemaLoading: true });
     setLoadingTables(