@quillsql/react 2.16.79 → 2.16.80

package/dist/index.cjs

@@ -15028,46 +15028,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";
@@ -15156,7 +15122,7 @@ function getExclusiveDateBucketRange(startInput, bucket) {
     endExclusive: endExclusive.toISOString()
   };
 }
-var import_date_fns5;
+var import_date_fns5, DATE_BUCKET_AXIS_FORMATS;
 var init_dates = __esm({
   "src/utils/dates.ts"() {
     "use strict";
@@ -15164,6 +15130,12 @@ var init_dates = __esm({
     init_dateRangePickerUtils();
     init_inMemoryPivotEngine();
     init_valueFormatter();
+    DATE_BUCKET_AXIS_FORMATS = {
+      day: "MMM_dd_yyyy",
+      week: "MMM_dd-MMM_dd",
+      month: "MMM_yyyy",
+      year: "yyyy"
+    };
   }
 });
 
@@ -21357,6 +21329,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: "",
@@ -21442,6 +21430,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(
@@ -21549,6 +21546,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,
@@ -21749,6 +21747,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";
@@ -22351,6 +22375,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();
@@ -22364,90 +22758,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,
@@ -22460,8 +23278,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)) {
@@ -22504,6 +23330,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,
@@ -22519,6 +23355,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;
@@ -22571,6 +23414,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(
@@ -22817,6 +23669,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) {
@@ -22840,7 +23737,7 @@ function convertInternalReportToReport(report, dashboardFilters, eventTracking,
         ...pivotFormatted
       };
       pivotReport.formattedBaseRows = formattedBaseRows;
-      return pivotReport;
+      return applyChartSort(pivotReport);
     }
     let rows = report.rows;
     if (report.chartType === "metric") {
@@ -22852,11 +23749,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",
@@ -25829,8 +26726,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;
   }
@@ -25846,6 +26749,11 @@ var ReportsContext = (0, import_react.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];
@@ -26121,7 +27029,14 @@ var ContextProvider = ({
   const mappedTenantsRequests = (0, import_react.useRef)(/* @__PURE__ */ new Set());
   const loadDashboardProcessId = (0, import_react.useRef)({});
   (0, import_react.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]);
@@ -27700,6 +28615,7 @@ init_dataFetcher();
 init_tableProcessing();
 init_paginationProcessing();
 init_inMemoryPivotEngine();
+init_pivotConstructor();
 
 // src/utils/dashboardPagination.ts
 function isDashboardPivotTable(report) {
@@ -28414,6 +29330,7 @@ var useDashboard = (dashboardName, config) => {
   const { getCacheCab } = (0, import_react2.useContext)(CacheCabContext);
   const reportRequestIds = (0, import_react2.useRef)({});
   const reportFetchAbortController = (0, import_react2.useRef)(null);
+  const dashboardFetchGeneration = (0, import_react2.useRef)(0);
   const lastDashboardName = (0, import_react2.useRef)(null);
   const pendingNameChangeReload = (0, import_react2.useRef)(false);
   const [loadedDashes, setLoadedDashes] = (0, import_react2.useState)([]);
@@ -28423,12 +29340,6 @@ var useDashboard = (dashboardName, config) => {
     () => getCacheCab(config?.cacheType),
     [getCacheCab, config?.cacheType]
   );
-  (0, import_react2.useEffect)(() => {
-    return () => {
-      reportFetchAbortController.current?.abort();
-      reportFetchAbortController.current = null;
-    };
-  }, [dashboardName]);
   (0, import_react2.useEffect)(() => {
     const nameChanged = dashboardName !== lastDashboardName.current;
     if (nameChanged) {
@@ -28491,15 +29402,42 @@ var useDashboard = (dashboardName, config) => {
     );
   }, [dashboardFilters]);
   (0, import_react2.useEffect)(() => {
+    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]);
   (0, import_react2.useEffect)(() => {
+    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) => {
@@ -28610,11 +29548,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];
@@ -28656,9 +29606,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;
@@ -28670,6 +29647,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,
@@ -28896,20 +29899,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,
@@ -28988,10 +30036,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]
@@ -29673,683 +30736,320 @@ function QuillCustomDocumentComponent({
                             whiteSpace: "nowrap",
                             overflow: "hidden",
                             textOverflow: "ellipsis",
-                            width: "100%",
-                            margin: 0
-                          },
-                          colSpan: report.columns.length,
-                          children: report.name
-                        }
-                      ) }),
-                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { colSpan: report.columns.length, children: "\xA0" }) }),
-                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                        "th",
-                        {
-                          style: { padding: "2px", paddingLeft: "3px", fontSize: 8 },
-                          children: col.label
-                        },
-                        "head" + colIndex
-                      )) })
-                    ]
-                  }
-                ),
-                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("tbody", { children: [
-                  report.rows.slice(rowStartIndex, rowEndIndex).map((row, rowIndex) => {
-                    return [
-                      // Title and header at the top of every page
-                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                        "td",
-                        {
-                          style: {
-                            padding: "2px",
-                            paddingLeft: "3px",
-                            fontSize: 8,
-                            whiteSpace: "nowrap",
-                            overflow: "hidden",
-                            textOverflow: "ellipsis",
-                            width: "100%"
-                          },
-                          children: quillFormat({
-                            value: row[col.field],
-                            format: col.format
-                          })
-                        },
-                        "cell" + col.field + colIndex + rowIndex
-                      )) }, "row" + rowIndex)
-                    ];
-                  }),
-                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { colSpan: report.columns.length, children: "\xA0" }) }),
-                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: /* @__PURE__ */ (0, import_jsx_runtime2.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
-var import_date_fns14 = require("date-fns");
-
-// src/components/Chart/BarList.tsx
-var import_react4 = __toESM(require("react"), 1);
-init_valueFormatter();
-init_chart();
-var import_jsx_runtime3 = require("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 = import_react4.default.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__ */ (0, import_jsx_runtime3.jsx)(
-      "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__ */ (0, import_jsx_runtime3.jsx)(
-    "div",
-    {
-      ref,
-      className,
-      style: {
-        // width: '100%',
-        boxSizing: "content-box",
-        height: "100%",
-        // marginLeft: 25,
-        // background: 'red',
-        // paddingRight: 25,
-        // paddingRight: 25,
-        ...containerStyle
-      },
-      ...other,
-      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
-        "div",
-        {
-          style: {
-            display: "flex",
-            justifyContent: "space-between",
-            boxSizing: "content-box",
-            overflow: scrollable ? "scroll" : "hidden",
-            width: "100%",
-            height: "100%"
-          },
-          children: [
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
-              "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__ */ (0, import_jsx_runtime3.jsx)(
-                      "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__ */ (0, import_jsx_runtime3.jsx)(
-                          "div",
-                          {
-                            style: {
-                              boxSizing: "content-box",
-                              position: "absolute",
-                              maxWidth: "100%",
-                              display: "flex",
-                              marginLeft: "8px"
-                            },
-                            children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-                              "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__ */ (0, import_jsx_runtime3.jsxs)(
-                    "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__ */ (0, import_jsx_runtime3.jsx)(
-              "div",
-              {
-                style: {
-                  boxSizing: "content-box",
-                  textAlign: "right",
-                  minWidth: "min-content",
-                  paddingLeft: 10
-                },
-                children: data.slice(0, NUM_TO_SHOW).map((item, idx) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-                  "div",
-                  {
-                    style: {
-                      boxSizing: "content-box",
-                      display: "flex",
-                      alignItems: "center",
-                      justifyContent: "flex-end",
-                      marginBottom: idx === data.length - 1 ? 0 : "8px",
-                      height: "36px"
-                    },
-                    children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-                      "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
-var import_react13 = __toESM(require("react"), 1);
-var import_recharts = require("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;
+                            width: "100%",
+                            margin: 0
+                          },
+                          colSpan: report.columns.length,
+                          children: report.name
+                        }
+                      ) }),
+                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { colSpan: report.columns.length, children: "\xA0" }) }),
+                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                        "th",
+                        {
+                          style: { padding: "2px", paddingLeft: "3px", fontSize: 8 },
+                          children: col.label
+                        },
+                        "head" + colIndex
+                      )) })
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("tbody", { children: [
+                  report.rows.slice(rowStartIndex, rowEndIndex).map((row, rowIndex) => {
+                    return [
+                      // Title and header at the top of every page
+                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: report.columns.map((col, colIndex) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                        "td",
+                        {
+                          style: {
+                            padding: "2px",
+                            paddingLeft: "3px",
+                            fontSize: 8,
+                            whiteSpace: "nowrap",
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            width: "100%"
+                          },
+                          children: quillFormat({
+                            value: row[col.field],
+                            format: col.format
+                          })
+                        },
+                        "cell" + col.field + colIndex + rowIndex
+                      )) }, "row" + rowIndex)
+                    ];
+                  }),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { colSpan: report.columns.length, children: "\xA0" }) }),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: /* @__PURE__ */ (0, import_jsx_runtime2.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
+                      ]
+                    }
+                  ) })
+                ] })
+              ]
+            }
+          )
+        }
+      ) })
     }
-    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
+var import_date_fns14 = require("date-fns");
+
+// src/components/Chart/BarList.tsx
+var import_react4 = __toESM(require("react"), 1);
+init_valueFormatter();
+init_chart();
+var import_jsx_runtime3 = require("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 = import_react4.default.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__ */ (0, import_jsx_runtime3.jsx)(
+      "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__ */ (0, import_jsx_runtime3.jsx)(
+    "div",
+    {
+      ref,
+      className,
+      style: {
+        // width: '100%',
+        boxSizing: "content-box",
+        height: "100%",
+        // marginLeft: 25,
+        // background: 'red',
+        // paddingRight: 25,
+        // paddingRight: 25,
+        ...containerStyle
+      },
+      ...other,
+      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+        "div",
+        {
+          style: {
+            display: "flex",
+            justifyContent: "space-between",
+            boxSizing: "content-box",
+            overflow: scrollable ? "scroll" : "hidden",
+            width: "100%",
+            height: "100%"
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+              "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__ */ (0, import_jsx_runtime3.jsx)(
+                      "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__ */ (0, import_jsx_runtime3.jsx)(
+                          "div",
+                          {
+                            style: {
+                              boxSizing: "content-box",
+                              position: "absolute",
+                              maxWidth: "100%",
+                              display: "flex",
+                              marginLeft: "8px"
+                            },
+                            children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+                              "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__ */ (0, import_jsx_runtime3.jsxs)(
+                    "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__ */ (0, import_jsx_runtime3.jsx)(
+              "div",
+              {
+                style: {
+                  boxSizing: "content-box",
+                  textAlign: "right",
+                  minWidth: "min-content",
+                  paddingLeft: 10
+                },
+                children: data.slice(0, NUM_TO_SHOW).map((item, idx) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+                  "div",
+                  {
+                    style: {
+                      boxSizing: "content-box",
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "flex-end",
+                      marginBottom: idx === data.length - 1 ? 0 : "8px",
+                      height: "36px"
+                    },
+                    children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+                      "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
+var import_react13 = __toESM(require("react"), 1);
+var import_recharts = require("recharts");
 init_util();
 init_valueFormatter();
 
@@ -35101,16 +35801,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 = (0, import_react18.useMemo)(
     () => stackedMode ? getStackedDomain(data, yAxisFields, comparison) : getDomain(data, yAxisFields, referenceLines),
     [stackedMode, data, yAxisFields, referenceLines, comparison]
@@ -35136,13 +35829,13 @@ function BarChart({
   const customBarShape = (0, import_react18.useMemo)(() => {
     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 = (0, import_react18.useMemo)(() => {
     if (!theme?.barChartCornerRadius && !theme?.barChartCornerRadiusRatio)
       return void 0;
     return createCustomBar(
-      sortYAxisFields([...yAxisFields]),
+      getVisibleYAxisFields(yAxisFields),
       theme,
       layout,
       true
@@ -35316,9 +36009,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 {
@@ -35371,7 +36064,7 @@ function BarChart({
                     position: isHorizontalBars ? void 0 : { y: 0 }
                   }
                 ),
-                sortYAxisFields([...yAxisFields]).map((elem) => {
+                getVisibleYAxisFields(yAxisFields).map((elem, index) => {
                   return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
                     import_recharts4.Bar,
                     {
@@ -35388,9 +36081,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",
@@ -35411,11 +36104,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__ */ (0, import_jsx_runtime38.jsx)(
@@ -38499,13 +39192,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);
@@ -38638,6 +39341,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);
@@ -38672,7 +39383,7 @@ var ChartDataLoader = ({
     previousTenants.current = tenants;
     previousFilters.current = filters;
     previousCustomFields.current = schemaData.customFields;
-    fetchReportHelper();
+    fetchReportHelper(true, "inputs-effect");
   }, [
     filters,
     userFilters,
@@ -38684,8 +39395,13 @@ var ChartDataLoader = ({
   ]);
   (0, import_react26.useEffect)(() => {
     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);
     }
@@ -40324,7 +41040,6 @@ function QuillTableDashboardComponent({
 // src/Chart.tsx
 init_valueFormatter();
 var import_jsx_runtime50 = require("react/jsx-runtime");
-var MAX_ROWS_FOR_GENERIC_TABLE = 500;
 function Chart({
   colors,
   reportId,
@@ -40606,6 +41321,14 @@ function Chart({
     }
   };
   (0, import_react32.useEffect)(() => {
+    profileDashboard("chart-fetch-decision", {
+      reportId,
+      clientLoading,
+      isDashboardsLoading,
+      hasDashboardReport: !!dashboardReport,
+      hasReport: !!reports[reportId],
+      dashboardFiltersReady: dashboardFilters !== null
+    });
     if (reportId === void 0 || reportId === "" || clientLoading || isDashboardsLoading) {
       return;
     }
@@ -40627,6 +41350,7 @@ function Chart({
       });
       setLoading(false);
     } else if (!reports[reportId]) {
+      profileDashboard("chart-fetch-individual", { reportId });
       fetchReportHelper();
       return;
     }
@@ -40847,8 +41571,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] = (0, import_react32.useState)(0);
-  const rowCountForLimit = config?.pivot ? config.pivotRowCount ?? config.pivotRows?.length ?? config.rows?.length : config?.rowCount ?? config?.rows?.length;
+  const chartRenderLimitError = getChartRenderLimitError(config);
   const tableDisplay = (0, import_react32.useMemo)(() => {
     if (!config || config.chartType?.toLowerCase() !== "table") {
       return void 0;
@@ -40881,15 +41606,8 @@ var ChartDisplay = ({
   }, [config]);
   if (loading) {
     return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("div", { className, style: containerStyle, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(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__ */ (0, import_jsx_runtime50.jsx)("div", { style: containerStyle, className, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
-      ErrorComponent,
-      {
-        errorMessage: `Charts can only display ${MAX_ROWS_FOR_GENERIC_TABLE} rows. Please modify the query.`
-      }
-    ) });
+  } else if (chartRenderLimitError) {
+    return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("div", { style: containerStyle, className, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(ErrorComponent, { errorMessage: chartRenderLimitError }) });
   }
   if (config?.chartType?.toLowerCase() === "pie") {
     return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
@@ -40955,7 +41673,7 @@ var ChartDisplay = ({
         xAxisFormat: config?.xAxisFormat ?? "string",
         containerStyle,
         className,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement,
         scrollable,
         showAnimation: isAnimationActive
@@ -40981,7 +41699,7 @@ var ChartDisplay = ({
         hideXAxis,
         hideYAxis,
         hideCartesianGrid,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement,
         onClickLegendElement,
         dateFilter: !hideDateRangeFilter ? dateFilter : void 0,
@@ -41009,7 +41727,7 @@ var ChartDisplay = ({
         hideXAxis,
         hideYAxis,
         hideCartesianGrid,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement,
         onClickLegendElement,
         dateFilter: !hideDateRangeFilter ? dateFilter : void 0,
@@ -41131,7 +41849,7 @@ var ChartDisplay = ({
         xAxisFormat: config?.xAxisFormat ?? "string",
         containerStyle,
         className,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement
       }
     );
@@ -41148,7 +41866,7 @@ var ChartDisplay = ({
         xAxisFormat: config?.xAxisFormat ?? "string",
         containerStyle,
         className,
-        colorMap,
+        colorMap: resolvedColorMap,
         onClickChartElement
       }
     );
@@ -41158,7 +41876,7 @@ var ChartDisplay = ({
       RadarChart,
       {
         colors: chartColors,
-        colorMap,
+        colorMap: resolvedColorMap,
         yAxisFields: config?.yAxisFields.sort(sortComparisonFirst) ?? [],
         data: config?.rows ?? [],
         xAxisField: config?.xAxisField ?? "",
@@ -41179,7 +41897,7 @@ var ChartDisplay = ({
     LineChart,
     {
       colors: chartColors,
-      colorMap,
+      colorMap: resolvedColorMap,
       yAxisFields: config?.yAxisFields.sort(sortComparisonFirst) || [],
       data: config?.rows || [],
       xAxisField: config?.xAxisField || "",
@@ -44335,6 +45053,22 @@ function StaticChart(props) {
     prevPage,
     sortRows: sortRows3
   } = useDashboardReportInternal(reportId);
+  (0, import_react41.useEffect)(() => {
+    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]);
+  (0, import_react41.useEffect)(() => {
+    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 = {
@@ -44359,13 +45093,12 @@ function StaticChart(props) {
     });
   };
   const useLocalPivotTablePagination = isDashboardPivotTable(report);
-  const config = (0, import_react41.useMemo)(() => {
-    return report ? {
-      ...report,
-      ...useLocalPivotTablePagination ? { pagination: void 0 } : {},
-      ...report.pivot ? formattedPivotRowsAndColumns(report, [], { formatRows: false }) : {}
-    } : void 0;
-  }, [report, useLocalPivotTablePagination]);
+  const config = (0, import_react41.useMemo)(
+    () => report ? prepareStaticChartReport(report, {
+      removePagination: useLocalPivotTablePagination
+    }) : void 0,
+    [report, useLocalPivotTablePagination]
+  );
   if (error) {
     return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(ChartError, { errorMessage: error, containerStyle: safeContainerStyle });
   }
@@ -59375,13 +60108,13 @@ function ChartEditor({
 }
 
 // src/Chat.tsx
-var import_react64 = require("react");
+var import_react63 = require("react");
 
 // src/ChatChartCard.tsx
-var import_react63 = require("react");
+var import_react62 = require("react");
 
 // src/hooks/useForm.tsx
-var import_react62 = require("react");
+var import_react61 = require("react");
 var import_react_query3 = require("@tanstack/react-query");
 init_Filter();
 init_ReportBuilder();
@@ -60568,20 +61301,6 @@ function useFormReducer(state, action) {
   }
 }
 
-// src/hooks/useForm.refreshDebounce.ts
-var import_react61 = require("react");
-var REPORT_REFRESH_DEBOUNCE_MS = 200;
-function useDebouncedRefreshInput(value, delayMs = REPORT_REFRESH_DEBOUNCE_MS) {
-  const [debouncedValue, setDebouncedValue] = (0, import_react61.useState)(value);
-  (0, import_react61.useEffect)(() => {
-    const timeout = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delayMs);
-    return () => clearTimeout(timeout);
-  }, [delayMs, value]);
-  return debouncedValue;
-}
-
 // src/utils/pivotDateBuckets.ts
 var import_date_fns18 = require("date-fns");
 function buildPivotDateBucketStarts(range, bucket) {
@@ -61710,22 +62429,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}`];
@@ -61733,16 +62436,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;
@@ -61782,69 +62475,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) ?? [];
@@ -64394,10 +65024,10 @@ function generateDraftSessionId() {
 }
 function useReport(reportIdArg, options = {}) {
   const propReportId = String(reportIdArg ?? "").trim();
-  const [createdReportBootstrap, setCreatedReportBootstrap] = (0, import_react62.useState)(null);
+  const [createdReportBootstrap, setCreatedReportBootstrap] = (0, import_react61.useState)(null);
   const effectiveReportId = propReportId || createdReportBootstrap?.reportId || "";
-  const { eventTracking } = (0, import_react62.useContext)(EventTrackingContext);
-  const [draftSessionId, setDraftSessionId] = (0, import_react62.useState)(generateDraftSessionId);
+  const { eventTracking } = (0, import_react61.useContext)(EventTrackingContext);
+  const [draftSessionId, setDraftSessionId] = (0, import_react61.useState)(generateDraftSessionId);
   const useInMemoryEngines = options.useInMemoryEngines ?? false;
   const dateBucketMode = options.dateBucketMode ?? "dynamic";
   const restrictFieldOptionsToSelectedDatasources = options.restrictFieldOptionsToSelectedDatasources ?? true;
@@ -64407,24 +65037,24 @@ function useReport(reportIdArg, options = {}) {
     options.destinationDashboardName ?? ""
   ).trim();
   const controlledPagination = options.state?.pagination;
-  const initialPaginationRef = (0, import_react62.useRef)({
+  const initialPaginationRef = (0, import_react61.useRef)({
     ...getDefaultPaginationState(),
     ...options.initialState?.pagination ?? {}
   });
-  const [internalPagination, setInternalPagination] = (0, import_react62.useState)(
+  const [internalPagination, setInternalPagination] = (0, import_react61.useState)(
     initialPaginationRef.current
   );
   const pagination = controlledPagination ?? internalPagination;
-  const paginationRef = (0, import_react62.useRef)(pagination);
+  const paginationRef = (0, import_react61.useRef)(pagination);
   paginationRef.current = pagination;
-  const onPaginationChangeRef = (0, import_react62.useRef)(options.onPaginationChange);
+  const onPaginationChangeRef = (0, import_react61.useRef)(options.onPaginationChange);
   onPaginationChangeRef.current = options.onPaginationChange;
-  const controlledPaginationRef = (0, import_react62.useRef)(Boolean(controlledPagination));
+  const controlledPaginationRef = (0, import_react61.useRef)(Boolean(controlledPagination));
   controlledPaginationRef.current = Boolean(controlledPagination);
-  const autoResetPageIndexRef = (0, import_react62.useRef)(true);
+  const autoResetPageIndexRef = (0, import_react61.useRef)(true);
   autoResetPageIndexRef.current = options.autoResetPageIndex ?? true;
-  const paginationPageCountRef = (0, import_react62.useRef)(-1);
-  const applyPaginationUpdate = (0, import_react62.useCallback)(
+  const paginationPageCountRef = (0, import_react61.useRef)(-1);
+  const applyPaginationUpdate = (0, import_react61.useCallback)(
     (updater) => {
       onPaginationChangeRef.current?.(updater);
       if (!controlledPaginationRef.current) {
@@ -64433,11 +65063,11 @@ function useReport(reportIdArg, options = {}) {
     },
     []
   );
-  const setPagination = (0, import_react62.useCallback)(
+  const setPagination = (0, import_react61.useCallback)(
     (updater) => applyPaginationUpdate(updater),
     [applyPaginationUpdate]
   );
-  const setPageIndex = (0, import_react62.useCallback)(
+  const setPageIndex = (0, import_react61.useCallback)(
     (updater) => applyPaginationUpdate((old) => ({
       ...old,
       pageIndex: clampPageIndex(
@@ -64447,7 +65077,7 @@ function useReport(reportIdArg, options = {}) {
     })),
     [applyPaginationUpdate]
   );
-  const setPageSize = (0, import_react62.useCallback)(
+  const setPageSize = (0, import_react61.useCallback)(
     (updater) => applyPaginationUpdate(
       (old) => paginationStateAfterPageSizeChange(
         old,
@@ -64456,46 +65086,46 @@ function useReport(reportIdArg, options = {}) {
     ),
     [applyPaginationUpdate]
   );
-  const resetPagination = (0, import_react62.useCallback)(
+  const resetPagination = (0, import_react61.useCallback)(
     (defaultState) => applyPaginationUpdate(
       defaultState ? getDefaultPaginationState() : initialPaginationRef.current
     ),
     [applyPaginationUpdate]
   );
-  const resetPageIndex = (0, import_react62.useCallback)(
+  const resetPageIndex = (0, import_react61.useCallback)(
     (defaultState) => {
       const target = defaultState ? 0 : initialPaginationRef.current.pageIndex;
       setPageIndex(target);
     },
     [setPageIndex]
   );
-  const resetPageSize = (0, import_react62.useCallback)(
+  const resetPageSize = (0, import_react61.useCallback)(
     (defaultState) => {
       const target = defaultState ? getDefaultPaginationState().pageSize : initialPaginationRef.current.pageSize;
       setPageSize(target);
     },
     [setPageSize]
   );
-  const nextPage = (0, import_react62.useCallback)(
+  const nextPage = (0, import_react61.useCallback)(
     () => setPageIndex((old) => old + 1),
     [setPageIndex]
   );
-  const previousPage = (0, import_react62.useCallback)(
+  const previousPage = (0, import_react61.useCallback)(
     () => setPageIndex((old) => old - 1),
     [setPageIndex]
   );
-  const firstPage = (0, import_react62.useCallback)(() => setPageIndex(0), [setPageIndex]);
-  const lastPage = (0, import_react62.useCallback)(
+  const firstPage = (0, import_react61.useCallback)(() => setPageIndex(0), [setPageIndex]);
+  const lastPage = (0, import_react61.useCallback)(
     () => setPageIndex(paginationPageCountRef.current - 1),
     [setPageIndex]
   );
-  const chartPivotHydratedFromSourceRef = (0, import_react62.useRef)(false);
-  const lastPivotHydrateCompletedSourceIdRef = (0, import_react62.useRef)(null);
-  const groupRowsBySetViaSetReportRef = (0, import_react62.useRef)(false);
-  const groupColumnsBySetViaSetReportRef = (0, import_react62.useRef)(false);
-  const dateBucketSetViaSetReportRef = (0, import_react62.useRef)(false);
-  const aggregationStateSetViaSetReportRef = (0, import_react62.useRef)(false);
-  const prevReportIdForChartPivotHydrationRef = (0, import_react62.useRef)(effectiveReportId);
+  const chartPivotHydratedFromSourceRef = (0, import_react61.useRef)(false);
+  const lastPivotHydrateCompletedSourceIdRef = (0, import_react61.useRef)(null);
+  const groupRowsBySetViaSetReportRef = (0, import_react61.useRef)(false);
+  const groupColumnsBySetViaSetReportRef = (0, import_react61.useRef)(false);
+  const dateBucketSetViaSetReportRef = (0, import_react61.useRef)(false);
+  const aggregationStateSetViaSetReportRef = (0, import_react61.useRef)(false);
+  const prevReportIdForChartPivotHydrationRef = (0, import_react61.useRef)(effectiveReportId);
   if (prevReportIdForChartPivotHydrationRef.current !== effectiveReportId) {
     prevReportIdForChartPivotHydrationRef.current = effectiveReportId;
     chartPivotHydratedFromSourceRef.current = false;
@@ -64504,16 +65134,16 @@ function useReport(reportIdArg, options = {}) {
     dateBucketSetViaSetReportRef.current = false;
     aggregationStateSetViaSetReportRef.current = false;
   }
-  const [chartPivotHydrationEpoch, setChartPivotHydrationEpoch] = (0, import_react62.useState)(0);
+  const [chartPivotHydrationEpoch, setChartPivotHydrationEpoch] = (0, import_react61.useState)(0);
   const [
     expandReportBuilderColumnsForFlatTable,
     setExpandReportBuilderColumnsForFlatTable
-  ] = (0, import_react62.useState)(false);
-  const prevPivotStateForColumnExpansionRef = (0, import_react62.useRef)(null);
-  const [sourceReport, setSourceReport] = (0, import_react62.useState)(
+  ] = (0, import_react61.useState)(false);
+  const prevPivotStateForColumnExpansionRef = (0, import_react61.useRef)(null);
+  const [sourceReport, setSourceReport] = (0, import_react61.useState)(
     null
   );
-  const prevSourceReportIdForPivotHydrationRef = (0, import_react62.useRef)(null);
+  const prevSourceReportIdForPivotHydrationRef = (0, import_react61.useRef)(null);
   {
     const currentSourceId = sourceReport ? String(
       sourceReport.id ?? sourceReport._id ?? ""
@@ -64525,22 +65155,23 @@ function useReport(reportIdArg, options = {}) {
       lastPivotHydrateCompletedSourceIdRef.current = null;
     }
   }
-  const [preserveSchemaWideOptions, setPreserveSchemaWideOptions] = (0, import_react62.useState)(false);
-  const [initialSchemaScopedTableNames, setInitialSchemaScopedTableNames] = (0, import_react62.useState)(null);
-  const [tableColumnsEditedSignature, setTableColumnsEditedSignature] = (0, import_react62.useState)(null);
-  (0, import_react62.useEffect)(() => {
+  const [preserveSchemaWideOptions, setPreserveSchemaWideOptions] = (0, import_react61.useState)(false);
+  const [initialSchemaScopedTableNames, setInitialSchemaScopedTableNames] = (0, import_react61.useState)(null);
+  const [tableColumnsEditedSignature, setTableColumnsEditedSignature] = (0, import_react61.useState)(null);
+  (0, import_react61.useEffect)(() => {
     setTableColumnsEditedSignature(null);
   }, [effectiveReportId]);
-  const [chartAxisEdits, setChartAxisEdits] = (0, import_react62.useState)({});
-  const [chartVisibilityOverrides, setChartVisibilityOverrides] = (0, import_react62.useState)({});
-  const [client] = (0, import_react62.useContext)(ClientContext);
-  const { loadDashboard } = (0, import_react62.useContext)(DashboardConfigContext);
+  const [chartAxisEdits, setChartAxisEdits] = (0, import_react61.useState)({});
+  const [chartVisibilityOverrides, setChartVisibilityOverrides] = (0, import_react61.useState)({});
+  const [chartSortOverride, setChartSortOverride] = (0, import_react61.useState)(void 0);
+  const [client] = (0, import_react61.useContext)(ClientContext);
+  const { loadDashboard } = (0, import_react61.useContext)(DashboardConfigContext);
   const queryClient = (0, import_react_query3.useQueryClient)();
-  const [schemaData] = (0, import_react62.useContext)(SchemaDataContext);
-  const { tenants, flags } = (0, import_react62.useContext)(TenantContext);
-  const { getToken } = (0, import_react62.useContext)(FetchContext);
-  const { getCacheCab } = (0, import_react62.useContext)(CacheCabContext);
-  const cacheCab = (0, import_react62.useMemo)(() => getCacheCab(), [getCacheCab]);
+  const [schemaData] = (0, import_react61.useContext)(SchemaDataContext);
+  const { tenants, flags } = (0, import_react61.useContext)(TenantContext);
+  const { getToken } = (0, import_react61.useContext)(FetchContext);
+  const { getCacheCab } = (0, import_react61.useContext)(CacheCabContext);
+  const cacheCab = (0, import_react61.useMemo)(() => getCacheCab(), [getCacheCab]);
   const clientDefaultDashboardName = String(
     client?.defaultDashboard?.name ?? ""
   ).trim();
@@ -64549,7 +65180,7 @@ function useReport(reportIdArg, options = {}) {
     clientDefaultDashboardName,
     destinationDashboardName
   ].map((entry) => String(entry ?? "").trim()).find((entry) => entry.length > 0) ?? "";
-  const initialFormState = (0, import_react62.useMemo)(
+  const initialFormState = (0, import_react61.useMemo)(
     () => ({
       reportName: void 0,
       columns: [],
@@ -64569,7 +65200,7 @@ function useReport(reportIdArg, options = {}) {
     }),
     []
   );
-  const [formRuntimeState, dispatchFormRuntime] = (0, import_react62.useReducer)(
+  const [formRuntimeState, dispatchFormRuntime] = (0, import_react61.useReducer)(
     useFormReducer,
     initialFormState,
     createInitialUseFormReducerState
@@ -64599,13 +65230,13 @@ function useReport(reportIdArg, options = {}) {
     schemaDatasourceIds
   } = formState;
   const schemaDatasourceIdsKey = schemaDatasourceIds?.map((id) => String(id ?? "").trim()).join("\0") ?? "";
-  const queryColumnsBootstrapKey = (0, import_react62.useMemo)(
+  const queryColumnsBootstrapKey = (0, import_react61.useMemo)(
     () => queryColumns.map(
       (c) => `${String(c.table ?? "").trim()}\0${String(c.field ?? "").trim()}`
     ).join("\n"),
     [queryColumns]
   );
-  const dashboardNameForNewReport = (0, import_react62.useMemo)(() => {
+  const dashboardNameForNewReport = (0, import_react61.useMemo)(() => {
     return [clientDefaultDashboardName, destinationDashboardName].map((entry) => String(entry ?? "").trim()).find((entry) => entry.length > 0) ?? "";
   }, [clientDefaultDashboardName, destinationDashboardName]);
   const { mutate: createReport } = (0, import_react_query3.useMutation)({
@@ -64652,22 +65283,23 @@ function useReport(reportIdArg, options = {}) {
       };
     }
   });
-  const filterStackRef = (0, import_react62.useRef)(filterStack);
+  const filterStackRef = (0, import_react61.useRef)(filterStack);
   filterStackRef.current = filterStack;
   const resolvedGroupRowsBy = decodePivotGroupOptionValue(groupRowsBy);
   const resolvedGroupColumnsBy = decodePivotGroupOptionValue(groupColumnsBy);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (propReportId) {
       setCreatedReportBootstrap(null);
     }
   }, [propReportId]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     setChartAxisEdits({});
     setChartVisibilityOverrides({});
+    setChartSortOverride(void 0);
   }, [effectiveReportId]);
-  const bootstrapReportTaskUsedForReportIdRef = (0, import_react62.useRef)(null);
-  const sharedInitialRequestUsedForReportIdRef = (0, import_react62.useRef)(null);
-  const schemaScopeInitializedForReportIdRef = (0, import_react62.useRef)(null);
+  const bootstrapReportTaskUsedForReportIdRef = (0, import_react61.useRef)(null);
+  const sharedInitialRequestUsedForReportIdRef = (0, import_react61.useRef)(null);
+  const schemaScopeInitializedForReportIdRef = (0, import_react61.useRef)(null);
   const initializeSchemaScopeForReport = (report) => {
     if (!report) return;
     if (schemaScopeInitializedForReportIdRef.current === effectiveReportId)
@@ -64680,16 +65312,16 @@ function useReport(reportIdArg, options = {}) {
     );
     schemaScopeInitializedForReportIdRef.current = effectiveReportId;
   };
-  const internalFilters = (0, import_react62.useMemo)(
+  const internalFilters = (0, import_react61.useMemo)(
     () => internalFiltersFromFilterStack(filterStack),
     [filterStack]
   );
-  const customFilters = (0, import_react62.useMemo)(
+  const customFilters = (0, import_react61.useMemo)(
     () => customFiltersFromFilterStack(filterStack),
     [filterStack]
   );
   const forceIncompleteCacheCabForParity = process.env.NODE_ENV === "test" && process.env.QUILL_FORCE_INCOMPLETE_CACHECAB_FOR_PARITY === "true";
-  const resolveCachedReport = (0, import_react62.useCallback)(
+  const resolveCachedReport = (0, import_react61.useCallback)(
     async ({
       reportBuilderState,
       filters,
@@ -64737,18 +65369,18 @@ function useReport(reportIdArg, options = {}) {
       tenants
     ]
   );
-  const reloadKey = (0, import_react62.useMemo)(() => 0, []);
-  const schemaForReportBuilderState = (0, import_react62.useMemo)(() => {
+  const reloadKey = (0, import_react61.useMemo)(() => 0, []);
+  const schemaForReportBuilderState = (0, import_react61.useMemo)(() => {
     if (schemaData.schemaWithCustomFields?.length) {
       return schemaData.schemaWithCustomFields;
     }
     return schemaData.schema ?? [];
   }, [schemaData.schema, schemaData.schemaWithCustomFields]);
-  const schemaForReportBuilderStateRef = (0, import_react62.useRef)(schemaForReportBuilderState);
-  const customFieldsRef = (0, import_react62.useRef)(schemaData.customFields);
+  const schemaForReportBuilderStateRef = (0, import_react61.useRef)(schemaForReportBuilderState);
+  const customFieldsRef = (0, import_react61.useRef)(schemaData.customFields);
   schemaForReportBuilderStateRef.current = schemaForReportBuilderState;
   customFieldsRef.current = schemaData.customFields;
-  const isBoolAggregationField = (0, import_react62.useCallback)(
+  const isBoolAggregationField = (0, import_react61.useCallback)(
     (field, table2) => {
       const fieldType = resolveFieldType({
         field,
@@ -64761,11 +65393,11 @@ function useReport(reportIdArg, options = {}) {
     },
     []
   );
-  const schemaForeignKeyMap = (0, import_react62.useMemo)(
+  const schemaForeignKeyMap = (0, import_react61.useMemo)(
     () => getSchemaForeignKeyMapping(schemaForReportBuilderState),
     [schemaForReportBuilderState]
   );
-  const datasourceJoinOptionsByTable = (0, import_react62.useMemo)(() => {
+  const datasourceJoinOptionsByTable = (0, import_react61.useMemo)(() => {
     const tableNames = new Set(
       schemaForReportBuilderState.map((table2) => String(table2.name ?? "").trim()).filter(Boolean)
     );
@@ -64791,14 +65423,14 @@ function useReport(reportIdArg, options = {}) {
     );
   }, [schemaForReportBuilderState, schemaForeignKeyMap]);
   const reportBuilderBaseTableNamesKey = (sourceReport?.reportBuilderState?.tables ?? []).map((t) => String(t?.name ?? "").trim()).filter(Boolean).join("\0") ?? "";
-  const selectedBaseTableNamesForFieldOptions = (0, import_react62.useMemo)(() => {
+  const selectedBaseTableNamesForFieldOptions = (0, import_react61.useMemo)(() => {
     const fromPicker = schemaDatasourceIds?.map((id) => String(id ?? "").trim()).filter(Boolean) ?? [];
     if (fromPicker.length > 0) {
       return fromPicker;
     }
     return (sourceReport?.reportBuilderState?.tables ?? []).map((t) => String(t?.name ?? "").trim()).filter(Boolean);
   }, [schemaDatasourceIdsKey, reportBuilderBaseTableNamesKey]);
-  const fieldOptionsAllowedTableNames = (0, import_react62.useMemo)(() => {
+  const fieldOptionsAllowedTableNames = (0, import_react61.useMemo)(() => {
     if (!restrictFieldOptionsToSelectedDatasources) {
       return null;
     }
@@ -64810,7 +65442,7 @@ function useReport(reportIdArg, options = {}) {
     restrictFieldOptionsToSelectedDatasources,
     selectedBaseTableNamesForFieldOptions
   ]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (reportOverride) return;
     if (propReportId) return;
     if (createdReportBootstrap) return;
@@ -64875,7 +65507,7 @@ function useReport(reportIdArg, options = {}) {
     schemaForReportBuilderState,
     queryColumnsBootstrapKey
   ]);
-  const datasourceOptions = (0, import_react62.useMemo)(() => {
+  const datasourceOptions = (0, import_react61.useMemo)(() => {
     const seen = /* @__PURE__ */ new Set();
     const result = [];
     for (const table2 of schemaForReportBuilderState) {
@@ -64890,7 +65522,7 @@ function useReport(reportIdArg, options = {}) {
     }
     return result;
   }, [schemaForReportBuilderState, datasourceJoinOptionsByTable]);
-  const queryBuilderFieldConfigByName = (0, import_react62.useMemo)(() => {
+  const queryBuilderFieldConfigByName = (0, import_react61.useMemo)(() => {
     const configByName = buildQueryBuilderFieldConfigByName(
       schemaForReportBuilderState
     );
@@ -65024,7 +65656,7 @@ function useReport(reportIdArg, options = {}) {
     sourceReport?.columns,
     sourceReport?.reportBuilderState?.columns
   ]);
-  const filterUniqueValuesRequest = (0, import_react62.useMemo)(() => {
+  const filterUniqueValuesRequest = (0, import_react61.useMemo)(() => {
     const dashboardName = resolvedSourceDashboardName;
     const reportBuilderStateFromSource = sourceReport?.reportBuilderState;
     const isStringReportBuilderColumn = (column) => {
@@ -65241,13 +65873,13 @@ function useReport(reportIdArg, options = {}) {
     sourceReport?.reportBuilderState,
     resolvedSourceDashboardName
   ]);
-  const filterUniqueValuesRequestHash = (0, import_react62.useMemo)(
+  const filterUniqueValuesRequestHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(
       filterUniqueValuesRequestForQueryKey(filterUniqueValuesRequest)
     ),
     [filterUniqueValuesRequest]
   );
-  const customFiltersHashForUniqueValues = (0, import_react62.useMemo)(
+  const customFiltersHashForUniqueValues = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(customFilters),
     [customFilters]
   );
@@ -65356,7 +65988,7 @@ function useReport(reportIdArg, options = {}) {
     gcTime: 15 * 6e4,
     placeholderData: import_react_query3.keepPreviousData
   });
-  const backendUniqueValuesByFieldName = (0, import_react62.useMemo)(() => {
+  const backendUniqueValuesByFieldName = (0, import_react61.useMemo)(() => {
     const valuesByField = /* @__PURE__ */ new Map();
     const uniqueValuesByColumn = filterUniqueValuesQuery.data?.uniqueValuesByColumn;
     if (!uniqueValuesByColumn || typeof uniqueValuesByColumn !== "object") {
@@ -65389,7 +66021,7 @@ function useReport(reportIdArg, options = {}) {
     filterUniqueValuesQuery.data?.uniqueValuesByColumn,
     filterUniqueValuesRequest?.stringColumnsByTable
   ]);
-  const filterValueOptionsByFieldName = (0, import_react62.useMemo)(() => {
+  const filterValueOptionsByFieldName = (0, import_react61.useMemo)(() => {
     const optionsByField = /* @__PURE__ */ new Map();
     const selectedMultiselectByField = collectSelectedStringMultiselectValuesByField(queryFilters);
     const collectValuesForField = (fieldName) => {
@@ -65455,7 +66087,7 @@ function useReport(reportIdArg, options = {}) {
     queryBuilderFieldConfigByName,
     queryFilters
   ]);
-  const filterFieldsComputed = (0, import_react62.useMemo)(() => {
+  const filterFieldsComputed = (0, import_react61.useMemo)(() => {
     const fields = [];
     const seen = /* @__PURE__ */ new Set();
     const addField = (fieldName, fieldType, tableName, rawFieldName) => {
@@ -65556,9 +66188,9 @@ function useReport(reportIdArg, options = {}) {
     queryBuilderFieldConfigByName,
     queryFilters
   ]);
-  const filterFieldsStableReportIdRef = (0, import_react62.useRef)("");
-  const filterFieldsStableCacheRef = (0, import_react62.useRef)([]);
-  const filterFields = (0, import_react62.useMemo)(() => {
+  const filterFieldsStableReportIdRef = (0, import_react61.useRef)("");
+  const filterFieldsStableCacheRef = (0, import_react61.useRef)([]);
+  const filterFields = (0, import_react61.useMemo)(() => {
     const rid = String(effectiveReportId ?? "");
     if (filterFieldsStableReportIdRef.current !== rid) {
       filterFieldsStableReportIdRef.current = rid;
@@ -65573,14 +66205,14 @@ function useReport(reportIdArg, options = {}) {
     }
     return filterFieldsComputed;
   }, [effectiveReportId, filterFieldsComputed]);
-  const getFilterOperators = (0, import_react62.useMemo)(
+  const getFilterOperators = (0, import_react61.useMemo)(
     () => (_field, misc) => {
       const fieldType = misc?.fieldData?.quillFieldType ?? queryBuilderFieldConfigByName[String(_field ?? "").trim()]?.fieldType ?? "string";
       return QUERY_BUILDER_OPERATORS_BY_FIELD_TYPE[fieldType] ?? QUERY_BUILDER_OPERATORS_BY_FIELD_TYPE.string;
     },
     [queryBuilderFieldConfigByName]
   );
-  const getFilterInputType = (0, import_react62.useMemo)(
+  const getFilterInputType = (0, import_react61.useMemo)(
     () => (_field, operator, misc) => {
       const fieldType = misc?.fieldData?.quillFieldType ?? queryBuilderFieldConfigByName[String(_field ?? "").trim()]?.fieldType ?? "string";
       if (fieldType === "date" && isRelativeDateQueryBuilderOperator(operator)) {
@@ -65590,7 +66222,7 @@ function useReport(reportIdArg, options = {}) {
     },
     [queryBuilderFieldConfigByName]
   );
-  const getFilterValueEditorType = (0, import_react62.useMemo)(
+  const getFilterValueEditorType = (0, import_react61.useMemo)(
     () => (_field, operator, misc) => {
       const fieldType = misc?.fieldData?.quillFieldType ?? queryBuilderFieldConfigByName[String(_field ?? "").trim()]?.fieldType;
       if (fieldType === "string" && isMultiValueOperator(operator)) {
@@ -65603,7 +66235,7 @@ function useReport(reportIdArg, options = {}) {
     },
     [queryBuilderFieldConfigByName]
   );
-  const getFilterValues = (0, import_react62.useMemo)(
+  const getFilterValues = (0, import_react61.useMemo)(
     () => (_field, operator, misc) => {
       const fieldName = String(_field ?? "").trim();
       if (!fieldName) {
@@ -65633,7 +66265,7 @@ function useReport(reportIdArg, options = {}) {
     },
     [filterValueOptionsByFieldName, queryBuilderFieldConfigByName]
   );
-  const filterQueryBuilderProps = (0, import_react62.useMemo)(
+  const filterQueryBuilderProps = (0, import_react61.useMemo)(
     () => ({
       fields: filterFields,
       listsAsArrays: true,
@@ -65650,7 +66282,7 @@ function useReport(reportIdArg, options = {}) {
       getFilterValues
     ]
   );
-  const filtersForQueryBuilder = (0, import_react62.useMemo)(
+  const filtersForQueryBuilder = (0, import_react61.useMemo)(
     () => canonicalizeMultiselectStringRulesToOptionValues(
       queryFilters,
       filterValueOptionsByFieldName,
@@ -65717,12 +66349,12 @@ function useReport(reportIdArg, options = {}) {
       ...table2 ? { table: table2 } : {}
     };
   };
-  const tenantHash = (0, import_react62.useMemo)(
+  const tenantHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(tenants),
     [tenants]
   );
-  const flagHash = (0, import_react62.useMemo)(() => stableSerializeForQueryKey(flags), [flags]);
-  const clientHash = (0, import_react62.useMemo)(
+  const flagHash = (0, import_react61.useMemo)(() => stableSerializeForQueryKey(flags), [flags]);
+  const clientHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey({
       publicKey: client?.publicKey,
       clientId: client?.clientId,
@@ -65730,16 +66362,16 @@ function useReport(reportIdArg, options = {}) {
     }),
     [client]
   );
-  const reloadKeyHash = (0, import_react62.useMemo)(
+  const reloadKeyHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(reloadKey),
     [reloadKey]
   );
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!reportOverride) return;
     initializeSchemaScopeForReport(reportOverride);
     setSourceReport(reportOverride);
   }, [reportOverride, propReportId]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     schemaScopeInitializedForReportIdRef.current = null;
     bootstrapReportTaskUsedForReportIdRef.current = null;
     sharedInitialRequestUsedForReportIdRef.current = null;
@@ -65891,13 +66523,13 @@ function useReport(reportIdArg, options = {}) {
   const reportTitleFromTask = String(reportNameQuery.data?.name ?? "").trim();
   const resolvedReportName = reportNameQueryReportId && sourceReportIdForTitle === reportNameQueryReportId && sourceReportNameForTitle ? sourceReportNameForTitle : reportTitleFromTask || sourceReportNameForTitle || "";
   const displayReportName = formReportName !== void 0 ? formReportName : resolvedReportName;
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (reportOverride) return;
     const report = initialLoadQuery.data?.report ?? null;
     initializeSchemaScopeForReport(report);
     setSourceReport(report);
   }, [initialLoadQuery.data, reportOverride, effectiveReportId]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!sourceReport) {
       return;
     }
@@ -66042,11 +66674,11 @@ function useReport(reportIdArg, options = {}) {
     schemaForReportBuilderState,
     sourceReport
   ]);
-  const appliedAggregationState = (0, import_react62.useMemo)(
+  const appliedAggregationState = (0, import_react61.useMemo)(
     () => aggregationState.filter(isAppliedAggregation),
     [aggregationState]
   );
-  const pivotState = (0, import_react62.useMemo)(() => {
+  const pivotState = (0, import_react61.useMemo)(() => {
     if (!resolvedGroupRowsBy && !resolvedGroupColumnsBy && appliedAggregationState.length === 0) {
       return null;
     }
@@ -66123,7 +66755,7 @@ function useReport(reportIdArg, options = {}) {
     chartPivotHydrationEpoch
   ]);
   const hasDatePivotRow = Boolean(String(pivotState?.rowField ?? "").trim()) && isDateType(String(pivotState?.rowFieldType ?? ""));
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     const previous = prevPivotStateForColumnExpansionRef.current;
     if (previous && !pivotState) {
       setExpandReportBuilderColumnsForFlatTable(true);
@@ -66133,7 +66765,7 @@ function useReport(reportIdArg, options = {}) {
     }
     prevPivotStateForColumnExpansionRef.current = pivotState;
   }, [pivotState]);
-  const effectiveReportBuilderTables = (0, import_react62.useMemo)(() => {
+  const effectiveReportBuilderTables = (0, import_react61.useMemo)(() => {
     const explicitBaseFromSchemaPicker = Array.isArray(schemaDatasourceIds) && schemaDatasourceIds.length > 0 ? schemaDatasourceIds.map((tableName) => String(tableName ?? "").trim()).filter(Boolean).map((name2) => ({ name: name2 })) : null;
     const baseTablesForMerge = explicitBaseFromSchemaPicker ?? baseReportBuilderTables;
     return mergeReportBuilderTables(
@@ -66157,18 +66789,18 @@ function useReport(reportIdArg, options = {}) {
     queryColumns,
     schemaDatasourceIds
   ]);
-  const datasources = (0, import_react62.useMemo)(() => {
+  const datasources = (0, import_react61.useMemo)(() => {
     return effectiveReportBuilderTables.map((table2) => String(table2.name ?? "").trim()).filter((name2) => Boolean(name2));
   }, [effectiveReportBuilderTables]);
-  const effectiveReportBuilderTableNames = (0, import_react62.useMemo)(
+  const effectiveReportBuilderTableNames = (0, import_react61.useMemo)(
     () => effectiveReportBuilderTables.map((table2) => String(table2.name ?? "").trim()).filter((name2) => Boolean(name2)),
     [effectiveReportBuilderTables]
   );
-  const baseReportBuilderTableNames = (0, import_react62.useMemo)(
+  const baseReportBuilderTableNames = (0, import_react61.useMemo)(
     () => baseReportBuilderTables.map((table2) => String(table2.name ?? "").trim()).filter((name2) => Boolean(name2)),
     [baseReportBuilderTables]
   );
-  const normalizeQueryBuilderFieldNameForConfig = (0, import_react62.useMemo)(() => {
+  const normalizeQueryBuilderFieldNameForConfig = (0, import_react61.useMemo)(() => {
     const configEntries = Object.entries(queryBuilderFieldConfigByName);
     const preferredTableNames = /* @__PURE__ */ new Set([
       ...effectiveReportBuilderTableNames,
@@ -66217,7 +66849,7 @@ function useReport(reportIdArg, options = {}) {
     effectiveReportBuilderTableNames,
     queryBuilderFieldConfigByName
   ]);
-  const normalizeQueryBuilderFiltersForConfig = (0, import_react62.useMemo)(() => {
+  const normalizeQueryBuilderFiltersForConfig = (0, import_react61.useMemo)(() => {
     const normalizeGroup = (group) => {
       const groupRules = Array.isArray(group.rules) ? group.rules : [];
       const nextRules = groupRules.map((entry) => {
@@ -66254,14 +66886,14 @@ function useReport(reportIdArg, options = {}) {
       return normalizeGroup(group);
     };
   }, [normalizeQueryBuilderFieldNameForConfig, queryBuilderFieldConfigByName]);
-  const refreshSelectionTables = (0, import_react62.useMemo)(() => {
+  const refreshSelectionTables = (0, import_react61.useMemo)(() => {
     return [
       getPivotGroupOptionTable(groupRowsBy),
       getPivotGroupOptionTable(groupColumnsBy),
       ...aggregationTablesByIndex
     ].map((tableName) => String(tableName ?? "").trim()).filter((tableName) => Boolean(tableName));
   }, [aggregationTablesByIndex, groupColumnsBy, groupRowsBy]);
-  const refreshSelectionFields = (0, import_react62.useMemo)(() => {
+  const refreshSelectionFields = (0, import_react61.useMemo)(() => {
     const resolveFieldTableForSelection = (field, tableHint) => {
       const fieldName = String(field ?? "").trim();
       if (!fieldName) return "";
@@ -66311,7 +66943,7 @@ function useReport(reportIdArg, options = {}) {
     schemaForReportBuilderState,
     sourceReport
   ]);
-  const refreshDecision = (0, import_react62.useMemo)(
+  const refreshDecision = (0, import_react61.useMemo)(
     () => decideReportBuilderRefresh({
       baseTables: baseReportBuilderTables,
       baseColumns: baseReportBuilderColumns,
@@ -66325,7 +66957,7 @@ function useReport(reportIdArg, options = {}) {
       refreshSelectionTables
     ]
   );
-  const effectiveReportBuilderColumns = (0, import_react62.useMemo)(() => {
+  const effectiveReportBuilderColumns = (0, import_react61.useMemo)(() => {
     const columnsFromPivot = [];
     const appendPivotColumn = (field, tableHint) => {
       const normalizedField = String(field ?? "").trim();
@@ -66388,7 +67020,7 @@ function useReport(reportIdArg, options = {}) {
     queryColumns,
     sourceReport
   ]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!Array.isArray(filterStack) || filterStack.length === 0) {
       return;
     }
@@ -66423,7 +67055,7 @@ function useReport(reportIdArg, options = {}) {
     queryBuilderFieldConfigByName,
     queryFilters
   ]);
-  const resolvedSortFieldType = (0, import_react62.useMemo)(() => {
+  const resolvedSortFieldType = (0, import_react61.useMemo)(() => {
     const sortField = pivotSort?.sortField;
     if (!sortField || !pivotState) return void 0;
     if (sortField === resolvedGroupRowsBy) {
@@ -66444,7 +67076,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedGroupColumnsBy,
     resolvedGroupRowsBy
   ]);
-  const effectiveReportBuilderState = (0, import_react62.useMemo)(() => {
+  const effectiveReportBuilderState = (0, import_react61.useMemo)(() => {
     if (!sourceReport && effectiveReportBuilderTables.length === 0) {
       return void 0;
     }
@@ -66487,12 +67119,12 @@ function useReport(reportIdArg, options = {}) {
     resolvedSortFieldType,
     sourceReport
   ]);
-  const effectiveReportBuilderStateHash = (0, import_react62.useMemo)(
+  const effectiveReportBuilderStateHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(effectiveReportBuilderState),
     [effectiveReportBuilderState]
   );
-  const prevPaginationResetStateHashRef = (0, import_react62.useRef)(null);
-  (0, import_react62.useEffect)(() => {
+  const prevPaginationResetStateHashRef = (0, import_react61.useRef)(null);
+  (0, import_react61.useEffect)(() => {
     const prevHash = prevPaginationResetStateHashRef.current;
     prevPaginationResetStateHashRef.current = effectiveReportBuilderStateHash;
     if (prevHash === null || prevHash === effectiveReportBuilderStateHash) {
@@ -66506,7 +67138,7 @@ function useReport(reportIdArg, options = {}) {
     }
     applyPaginationUpdate((old) => ({ ...old, pageIndex: 0 }));
   }, [applyPaginationUpdate, effectiveReportBuilderStateHash]);
-  const pivotTableDataReportBuilderState = (0, import_react62.useMemo)(() => {
+  const pivotTableDataReportBuilderState = (0, import_react61.useMemo)(() => {
     if (!effectiveReportBuilderState?.pivot) {
       return void 0;
     }
@@ -66526,11 +67158,11 @@ function useReport(reportIdArg, options = {}) {
       limit: null
     };
   }, [effectiveReportBuilderState, schemaForReportBuilderState]);
-  const pivotTableDataReportBuilderStateHash = (0, import_react62.useMemo)(
+  const pivotTableDataReportBuilderStateHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(pivotTableDataReportBuilderState),
     [pivotTableDataReportBuilderState]
   );
-  const sourceReportMatchesEffectiveReportId = (0, import_react62.useMemo)(() => {
+  const sourceReportMatchesEffectiveReportId = (0, import_react61.useMemo)(() => {
     const loadTarget = String(effectiveReportId ?? "").trim();
     if (!loadTarget || !sourceReport) {
       return true;
@@ -66540,7 +67172,7 @@ function useReport(reportIdArg, options = {}) {
     ).trim();
     return sid === loadTarget;
   }, [effectiveReportId, sourceReport]);
-  const shouldSkipRedundantFlatTableReportBuilderQuery = (0, import_react62.useMemo)(() => {
+  const shouldSkipRedundantFlatTableReportBuilderQuery = (0, import_react61.useMemo)(() => {
     if (!sourceReport || pivotState) {
       return false;
     }
@@ -66566,7 +67198,7 @@ function useReport(reportIdArg, options = {}) {
     filterStack
   ]);
   const shouldForceTableRefreshFromFilters = !useInMemoryEngines && !pivotState;
-  const immediateTableRefreshInput = (0, import_react62.useMemo)(
+  const tableRefreshInput = (0, import_react61.useMemo)(
     () => ({
       version: tableRefreshVersion,
       reportBuilderStateHash: effectiveReportBuilderStateHash,
@@ -66582,18 +67214,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 = (0, import_react62.useRef)(null);
+  const completedTableRefreshRef = (0, import_react61.useRef)(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 = (0, import_react_query3.useQuery)({
     queryKey: createUseFormTableRefreshQueryKey({
       reportId: effectiveReportId,
@@ -66665,7 +67291,7 @@ function useReport(reportIdArg, options = {}) {
     enabled: isCreatedReportBootstrapLoad && Boolean(client) && !reportOverride,
     retry: false
   });
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!tableRefreshQueryEnabled) return;
     const report = tableRefreshQuery.data?.report;
     if (tableRefreshQuery.data?.error || !report) return;
@@ -66680,7 +67306,7 @@ function useReport(reportIdArg, options = {}) {
     tableRefreshQuery.data,
     tableRefreshQueryEnabled
   ]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     const countReport = createdBootstrapRowCountQuery.data?.report;
     if (createdBootstrapRowCountQuery.data?.error || !countReport) return;
     setSourceReport((currentReport) => {
@@ -66696,11 +67322,11 @@ function useReport(reportIdArg, options = {}) {
       return { ...currentReport, rowCount: countReport.rowCount };
     });
   }, [createdBootstrapRowCountQuery.data, effectiveReportId, sourceReport?.id]);
-  const chartTypes = (0, import_react62.useMemo)(() => {
+  const chartTypes = (0, import_react61.useMemo)(() => {
     return getChartTypeOptions2({ pivot: pivotState });
   }, [pivotState]);
   const resolvedChartType = chartTypes.find((option) => option.value === chartType)?.value ?? chartTypes.find((option) => option.value === sourceReport?.chartType)?.value ?? chartTypes.find((option) => option.value === DEFAULT_CHART_TYPE)?.value ?? chartTypes[0]?.value ?? DEFAULT_CHART_TYPE;
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!sourceReport) {
       return;
     }
@@ -66735,7 +67361,7 @@ function useReport(reportIdArg, options = {}) {
       });
     }
   }, [chartType, chartTypes, sourceReport]);
-  const schemaScopedTableNames = (0, import_react62.useMemo)(() => {
+  const schemaScopedTableNames = (0, import_react61.useMemo)(() => {
     if (preserveSchemaWideOptions) {
       return [];
     }
@@ -66750,7 +67376,7 @@ function useReport(reportIdArg, options = {}) {
     preserveSchemaWideOptions,
     sourceReport?.reportBuilderState?.tables
   ]);
-  const joinCompatibleSchemaTableNames = (0, import_react62.useMemo)(() => {
+  const joinCompatibleSchemaTableNames = (0, import_react61.useMemo)(() => {
     if (schemaScopedTableNames.length === 0) {
       return [];
     }
@@ -66759,7 +67385,7 @@ function useReport(reportIdArg, options = {}) {
       schemaForeignKeyMap
     );
   }, [schemaForeignKeyMap, schemaScopedTableNames]);
-  const aggregationFallbackTarget = (0, import_react62.useMemo)(() => {
+  const aggregationFallbackTarget = (0, import_react61.useMemo)(() => {
     const tableNames = effectiveReportBuilderTables.map((table2) => table2.name).filter((name2) => Boolean(name2));
     const referencedTableNames = (sourceReport?.referencedTables ?? []).filter(
       (name2) => typeof name2 === "string" && name2.length > 0
@@ -66767,7 +67393,7 @@ function useReport(reportIdArg, options = {}) {
     const tableNamesToUse = tableNames.length ? tableNames : referencedTableNames;
     return tableNamesToUse.length > 0 ? tableNamesToUse.join(", ") : "table";
   }, [effectiveReportBuilderTables, sourceReport?.referencedTables]);
-  const aggregationFallbackTableName = (0, import_react62.useMemo)(() => {
+  const aggregationFallbackTableName = (0, import_react61.useMemo)(() => {
     const tableNames = effectiveReportBuilderTables.map((table2) => table2.name).filter((name2) => Boolean(name2));
     const referencedTableNames = (sourceReport?.referencedTables ?? []).filter(
       (name2) => typeof name2 === "string" && name2.length > 0
@@ -66775,7 +67401,7 @@ function useReport(reportIdArg, options = {}) {
     const tableNamesToUse = tableNames.length ? tableNames : referencedTableNames;
     return tableNamesToUse[0] ?? "table";
   }, [effectiveReportBuilderTables, sourceReport?.referencedTables]);
-  const cleanedAggregations = (0, import_react62.useMemo)(() => {
+  const cleanedAggregations = (0, import_react61.useMemo)(() => {
     return aggregationState.filter((aggregation) => Boolean(aggregation?.aggregationType)).map((aggregation, index) => {
       const aggregationType = String(aggregation.aggregationType);
       const normalizedAggregationType = aggregationType.toLowerCase();
@@ -66797,7 +67423,7 @@ function useReport(reportIdArg, options = {}) {
     aggregationTablesByIndex,
     isBoolAggregationField
   ]);
-  const { aggregationBaseOptions, aggregationOptionTableLookup } = (0, import_react62.useMemo)(() => {
+  const { aggregationBaseOptions, aggregationOptionTableLookup } = (0, import_react61.useMemo)(() => {
     const joinScoped = fieldOptionsAllowedTableNames ? joinCompatibleSchemaTableNames.filter(
       (name2) => fieldOptionsAllowedTableNames.has(name2)
     ) : joinCompatibleSchemaTableNames;
@@ -66880,7 +67506,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedGroupRowsBy,
     schemaForReportBuilderState
   ]);
-  const { schemaColumnOptions, columnIdentifierLookup } = (0, import_react62.useMemo)(() => {
+  const { schemaColumnOptions, columnIdentifierLookup } = (0, import_react61.useMemo)(() => {
     const lookup = /* @__PURE__ */ new Map();
     const options2 = [];
     for (const table2 of schemaData.schemaWithCustomFields) {
@@ -66907,7 +67533,7 @@ function useReport(reportIdArg, options = {}) {
       columnIdentifierLookup: lookup
     };
   }, [schemaData.schemaWithCustomFields]);
-  const tableColumnPickerPoolOptions = (0, import_react62.useMemo)(() => {
+  const tableColumnPickerPoolOptions = (0, import_react61.useMemo)(() => {
     const allowed = new Set(
       effectiveReportBuilderTableNames.map((name2) => String(name2 ?? "").trim()).filter(Boolean)
     );
@@ -66918,16 +67544,16 @@ function useReport(reportIdArg, options = {}) {
       (option) => allowed.has(String(option.tableName ?? "").trim())
     );
   }, [effectiveReportBuilderTableNames, schemaColumnOptions]);
-  const columns = (0, import_react62.useMemo)(() => {
+  const columns = (0, import_react61.useMemo)(() => {
     return displayColumns.filter((column) => Boolean(column.field)).map((column) => encodeColumnOptionValue(column.table, column.field));
   }, [displayColumns]);
-  const selectedColumnOptions = (0, import_react62.useMemo)(() => {
+  const selectedColumnOptions = (0, import_react61.useMemo)(() => {
     return displayColumns.map((column) => {
       const value = column.alias || column.field;
       return value ? { label: value, value } : null;
     }).filter((option) => option !== null);
   }, [displayColumns]);
-  const scopedSchemaColumns = (0, import_react62.useMemo)(() => {
+  const scopedSchemaColumns = (0, import_react61.useMemo)(() => {
     const tableNames = fieldOptionsAllowedTableNames ? Array.from(fieldOptionsAllowedTableNames) : joinCompatibleSchemaTableNames;
     const schemaTables = schemaForReportBuilderState;
     const tablesToUse = tableNames.length ? schemaTables.filter((table2) => tableNames.includes(table2.name ?? "")) : schemaTables;
@@ -66948,7 +67574,7 @@ function useReport(reportIdArg, options = {}) {
     joinCompatibleSchemaTableNames,
     schemaForReportBuilderState
   ]);
-  const pivotUniqueValuesByColumn = (0, import_react62.useMemo)(() => {
+  const pivotUniqueValuesByColumn = (0, import_react61.useMemo)(() => {
     const explicitUniqueValues = sourceReport?.uniqueStringsByColumn ?? sourceReport?.columnUniqueValues ?? sourceReport?.uniqueValues;
     if (explicitUniqueValues && typeof explicitUniqueValues === "object" && !Array.isArray(explicitUniqueValues)) {
       return explicitUniqueValues;
@@ -66974,7 +67600,7 @@ function useReport(reportIdArg, options = {}) {
     }
     return result;
   }, [sourceReport]);
-  const possiblePivotFields = (0, import_react62.useMemo)(() => {
+  const possiblePivotFields = (0, import_react61.useMemo)(() => {
     const options2 = getPossiblePivotFieldOptions(
       scopedSchemaColumns,
       pivotUniqueValuesByColumn
@@ -66985,7 +67611,7 @@ function useReport(reportIdArg, options = {}) {
       columnFields: options2.columnFields.filter((field) => !isIdColumn(field))
     };
   }, [scopedSchemaColumns, pivotUniqueValuesByColumn]);
-  const groupRowsByOptions = (0, import_react62.useMemo)(() => {
+  const groupRowsByOptions = (0, import_react61.useMemo)(() => {
     const allowedFields = new Set(possiblePivotFields.rowFields);
     const seenValues = /* @__PURE__ */ new Set();
     const options2 = [];
@@ -67012,7 +67638,7 @@ function useReport(reportIdArg, options = {}) {
     }
     return options2;
   }, [groupRowsBy, possiblePivotFields.rowFields, scopedSchemaColumns]);
-  const groupColumnsByOptions = (0, import_react62.useMemo)(() => {
+  const groupColumnsByOptions = (0, import_react61.useMemo)(() => {
     const allowedFields = new Set(possiblePivotFields.columnFields);
     const seenValues = /* @__PURE__ */ new Set();
     const options2 = [];
@@ -67039,19 +67665,19 @@ function useReport(reportIdArg, options = {}) {
     }
     return options2;
   }, [groupColumnsBy, possiblePivotFields.columnFields, scopedSchemaColumns]);
-  const cleanedSort = (0, import_react62.useMemo)(() => {
+  const cleanedSort = (0, import_react61.useMemo)(() => {
     const activeSort = resolvedGroupRowsBy ? pivotSort : regularSort;
     if (!activeSort?.sortField || !activeSort?.sortDirection) {
       return "";
     }
     return toFlatSortValue(activeSort.sortField, activeSort.sortDirection);
   }, [pivotSort, regularSort, resolvedGroupRowsBy]);
-  const aggregationSortLabelFallbackTable = (0, import_react62.useMemo)(() => {
+  const aggregationSortLabelFallbackTable = (0, import_react61.useMemo)(() => {
     const reportBuilderTableName = effectiveReportBuilderTables.map((table2) => String(table2.name ?? "").trim()).find((tableName) => Boolean(tableName));
     if (reportBuilderTableName) return reportBuilderTableName;
     return (sourceReport?.referencedTables ?? []).map((tableName) => String(tableName ?? "").trim()).find((tableName) => Boolean(tableName));
   }, [effectiveReportBuilderTables, sourceReport?.referencedTables]);
-  const sortOptions = (0, import_react62.useMemo)(() => {
+  const sortOptions = (0, import_react61.useMemo)(() => {
     if (resolvedGroupRowsBy) {
       const aggregationSortFields = getPivotAggregationSortFields(
         aggregationState,
@@ -67087,9 +67713,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)
         };
       })
@@ -67110,7 +67736,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedGroupRowsBy,
     selectedColumnOptions
   ]);
-  const { aggregationValues, aggregationOptions } = (0, import_react62.useMemo)(() => {
+  const { aggregationValues, aggregationOptions } = (0, import_react61.useMemo)(() => {
     const baseOptions = aggregationBaseOptions.map((option) => ({
       value: option.value,
       label: option.label
@@ -67154,7 +67780,7 @@ function useReport(reportIdArg, options = {}) {
     aggregationTablesByIndex,
     isBoolAggregationField
   ]);
-  const nextPivot = (0, import_react62.useMemo)(() => {
+  const nextPivot = (0, import_react61.useMemo)(() => {
     if (!sourceReport) return null;
     return pivotState ? {
       ...pivotState,
@@ -67169,15 +67795,15 @@ function useReport(reportIdArg, options = {}) {
       rowLimit: limit?.value
     } : null;
   }, [sourceReport, pivotState, pivotSort, limit, resolvedSortFieldType]);
-  const nextPivotHash = (0, import_react62.useMemo)(
+  const nextPivotHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(nextPivot),
     [nextPivot]
   );
-  const filterStackHash = (0, import_react62.useMemo)(
+  const filterStackHash = (0, import_react61.useMemo)(
     () => stableSerializeForQueryKey(filterStack),
     [filterStack]
   );
-  const shouldSkipPivotRefreshForUnchangedPivot = (0, import_react62.useMemo)(() => {
+  const shouldSkipPivotRefreshForUnchangedPivot = (0, import_react61.useMemo)(() => {
     if (!sourceReport || !nextPivot) return false;
     if (!Array.isArray(sourceReport.rows) || sourceReport.rows.length === 0) {
       return false;
@@ -67195,7 +67821,7 @@ function useReport(reportIdArg, options = {}) {
     );
     return hasSamePivot && sourceFilterStackHash === filterStackHash;
   }, [filterStackHash, nextPivot, sourceReport]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!pendingPivotRefresh) return;
     if (!nextPivot) {
       if (!sourceReport) {
@@ -67215,7 +67841,7 @@ function useReport(reportIdArg, options = {}) {
     shouldSkipPivotRefreshForUnchangedPivot,
     sourceReport
   ]);
-  const shouldSkipRedundantPivotTableDataReportBuilderQuery = (0, import_react62.useMemo)(() => {
+  const shouldSkipRedundantPivotTableDataReportBuilderQuery = (0, import_react61.useMemo)(() => {
     if (!sourceReport || !nextPivot) {
       return false;
     }
@@ -67344,7 +67970,7 @@ function useReport(reportIdArg, options = {}) {
   });
   const tablePageReportBuilderState = pivotTableDataReportBuilderState ?? effectiveReportBuilderState;
   const tablePageReportBuilderStateHash = pivotTableDataReportBuilderState ? pivotTableDataReportBuilderStateHash : effectiveReportBuilderStateHash;
-  const tablePaginationSort = (0, import_react62.useMemo)(
+  const tablePaginationSort = (0, import_react61.useMemo)(
     () => getStablePaginationSort({
       columns: tablePageReportBuilderState?.columns,
       sort: tablePageReportBuilderState?.sort
@@ -67400,7 +68026,7 @@ function useReport(reportIdArg, options = {}) {
   const tablePageRows = tablePageQueryEnabled && !tablePageQuery.data?.error && Array.isArray(tablePageQuery.data?.report?.rows) ? tablePageQuery.data.report.rows : void 0;
   const tablePageRowCount = tablePageQueryEnabled && typeof tablePageQuery.data?.report?.rowCount === "number" && tablePageQuery.data.report.rowCount > 0 ? tablePageQuery.data.report.rowCount : void 0;
   const tablePageFetching = tablePageQueryEnabled && tablePageQuery.isFetching;
-  const paginationTotalRowCount = (0, import_react62.useMemo)(() => {
+  const paginationTotalRowCount = (0, import_react61.useMemo)(() => {
     if (tablePageRowCount !== void 0) {
       return Math.max(tablePageRowCount, baseWindowRowsLength);
     }
@@ -67423,7 +68049,7 @@ function useReport(reportIdArg, options = {}) {
     pagination.pageSize
   );
   paginationPageCountRef.current = paginationPageCount;
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!pivotTableDataRefreshQueryEnabled) return;
     if (pivotTableDataRefreshQuery.status !== "success" && pivotTableDataRefreshQuery.status !== "error") {
       return;
@@ -67464,7 +68090,7 @@ function useReport(reportIdArg, options = {}) {
     pivotTableDataRefreshQueryEnabled,
     effectiveReportId
   ]);
-  (0, import_react62.useEffect)(() => {
+  (0, import_react61.useEffect)(() => {
     if (!pivotRefreshQueryEnabled) return;
     if (pivotRefreshQuery.status !== "success" && pivotRefreshQuery.status !== "error") {
       return;
@@ -67525,7 +68151,7 @@ function useReport(reportIdArg, options = {}) {
   const pendingPivotChangesDimensions = Boolean(
     sourceReport && pendingPivotRefresh && nextPivot && (settledSourceRowFieldForChart !== String(nextPivot.rowField ?? "").trim() || String(settledPivotForChart?.rowFieldTable ?? "").trim() !== String(nextPivot.rowFieldTable ?? "").trim() || String(settledPivotForChart?.columnField ?? "").trim() !== String(nextPivot.columnField ?? "").trim() || String(settledPivotForChart?.columnFieldTable ?? "").trim() !== String(nextPivot.columnFieldTable ?? "").trim())
   );
-  const chartData = (0, import_react62.useMemo)(() => {
+  const chartData = (0, import_react61.useMemo)(() => {
     if (!sourceReport) return void 0;
     const rowsForChart = Array.isArray(sourceReport.rows) ? sourceReport.rows : [];
     const chartPivot = pendingPivotChangesDimensions ? sourceReport.pivot ?? null : nextPivot ?? (!chartPivotHydratedFromSourceRef.current ? sourceReport.pivot ?? null : null);
@@ -67559,18 +68185,18 @@ function useReport(reportIdArg, options = {}) {
     useInMemoryEngines,
     chartPivotHydrationEpoch
   ]);
-  const baseChart = (0, import_react62.useMemo)(
+  const baseChart = (0, import_react61.useMemo)(
     () => normalizePivotChartForDisplay(chartData),
     [chartData]
   );
-  const chartAxesBaseChart = (0, import_react62.useMemo)(() => {
+  const chartAxesBaseChart = (0, import_react61.useMemo)(() => {
     if (!chartData) return void 0;
     if (chartData.pivot?.columnField) {
       return normalizePivotChartForAxisControls(chartData, effectiveReportId);
     }
     return baseChart;
   }, [baseChart, chartData, effectiveReportId]);
-  const chartAxisOptions = (0, import_react62.useMemo)(() => {
+  const chartAxisOptions = (0, import_react61.useMemo)(() => {
     if (!chartAxesBaseChart) return [];
     const optionsByField = /* @__PURE__ */ new Map();
     const registerOption = (fieldRaw, labelRaw, formatRaw) => {
@@ -67609,14 +68235,14 @@ function useReport(reportIdArg, options = {}) {
     );
     return Array.from(optionsByField.values());
   }, [chartAxesBaseChart]);
-  const chartAxisOptionByField = (0, import_react62.useMemo)(() => {
+  const chartAxisOptionByField = (0, import_react61.useMemo)(() => {
     const optionsByField = /* @__PURE__ */ new Map();
     for (const option of chartAxisOptions) {
       optionsByField.set(option.value, option);
     }
     return optionsByField;
   }, [chartAxisOptions]);
-  const xAxisOptions = (0, import_react62.useMemo)(() => {
+  const xAxisOptions = (0, import_react61.useMemo)(() => {
     if (!chartAxesBaseChart) return chartAxisOptions;
     const pivot = chartAxesBaseChart.pivot;
     const pivotRowField = String(pivot?.rowField ?? "").trim();
@@ -67639,7 +68265,7 @@ function useReport(reportIdArg, options = {}) {
     }
     return chartAxisOptions;
   }, [chartAxesBaseChart, chartAxisOptions, chartAxisOptionByField]);
-  const yAxisOptions = (0, import_react62.useMemo)(() => {
+  const yAxisOptions = (0, import_react61.useMemo)(() => {
     if (!chartAxesBaseChart) return [];
     const keepOption = (option) => {
       const col = findSchemaColumnForChartAxisField(
@@ -67675,21 +68301,21 @@ function useReport(reportIdArg, options = {}) {
     chartAxisOptions,
     schemaColumnOptions
   ]);
-  const normalizedChartXAxisOptions = (0, import_react62.useMemo)(() => {
+  const normalizedChartXAxisOptions = (0, import_react61.useMemo)(() => {
     return xAxisOptions.map((option) => ({
       value: String(option.value ?? "").trim(),
       label: String(option.label ?? option.value ?? "").trim(),
       format: String(option.format ?? "").trim()
     }));
   }, [xAxisOptions]);
-  const normalizedChartYAxisOptions = (0, import_react62.useMemo)(() => {
+  const normalizedChartYAxisOptions = (0, import_react61.useMemo)(() => {
     return yAxisOptions.map((option) => ({
       value: String(option.value ?? "").trim(),
       label: String(option.label ?? option.value ?? "").trim(),
       format: String(option.format ?? "").trim()
     }));
   }, [yAxisOptions]);
-  const resolvedYAxisFields = (0, import_react62.useMemo)(() => {
+  const resolvedYAxisFields = (0, import_react61.useMemo)(() => {
     if (!chartAxesBaseChart) return [];
     const normalizeYAxisField = (yAxisFieldRaw) => {
       const field = String(yAxisFieldRaw?.field ?? "").trim();
@@ -67733,7 +68359,7 @@ function useReport(reportIdArg, options = {}) {
     chartAxisOptionByField,
     chartAxisOptions
   ]);
-  const resolvedXAxisField = (0, import_react62.useMemo)(() => {
+  const resolvedXAxisField = (0, import_react61.useMemo)(() => {
     if (!chartAxesBaseChart) return "";
     const chartType2 = String(chartAxesBaseChart.chartType ?? "").toLowerCase();
     const pivotRowField = String(
@@ -67765,7 +68391,7 @@ function useReport(reportIdArg, options = {}) {
     chartAxisOptions,
     resolvedYAxisFields
   ]);
-  const resolvedXAxisFormat = (0, import_react62.useMemo)(() => {
+  const resolvedXAxisFormat = (0, import_react61.useMemo)(() => {
     if (!chartAxesBaseChart) {
       return "string";
     }
@@ -67777,9 +68403,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";
     }
@@ -67791,7 +68415,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedXAxisField,
     resolvedYAxisFields
   ]);
-  const resolvedXAxisLabel = (0, import_react62.useMemo)(() => {
+  const resolvedXAxisLabel = (0, import_react61.useMemo)(() => {
     const defaultXLabel = String(
       chartAxesBaseChart?.xAxisLabel ?? chartAxisOptionByField.get(resolvedXAxisField)?.label ?? ""
     ).trim();
@@ -67805,13 +68429,13 @@ function useReport(reportIdArg, options = {}) {
     chartAxisOptionByField,
     resolvedXAxisField
   ]);
-  const chartVisibility = (0, import_react62.useMemo)(
+  const chartVisibility = (0, import_react61.useMemo)(
     () => ({
       showLegend: chartVisibilityOverrides.showLegend ?? Boolean(baseChart?.showLegend ?? false)
     }),
     [baseChart?.showLegend, chartVisibilityOverrides]
   );
-  const xAxis = (0, import_react62.useMemo)(() => {
+  const xAxis = (0, import_react61.useMemo)(() => {
     const pivotBucketXAxis = isPivotTableDateBucketRowAxis(
       chartAxesBaseChart,
       resolvedXAxisField
@@ -67828,7 +68452,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedXAxisField,
     resolvedXAxisFormat
   ]);
-  const yAxis = (0, import_react62.useMemo)(
+  const yAxis = (0, import_react61.useMemo)(
     () => ({
       fields: resolvedYAxisFields.map((yAxisField) => ({
         field: yAxisField.field,
@@ -67840,14 +68464,14 @@ function useReport(reportIdArg, options = {}) {
     }),
     [resolvedYAxisFields]
   );
-  const resolvedYAxisFieldsForDisplay = (0, import_react62.useMemo)(() => {
+  const resolvedYAxisFieldsForDisplay = (0, import_react61.useMemo)(() => {
     if (!baseChart) return resolvedYAxisFields;
     return mapResolvedPivotYAxisFieldsForDisplay({
       chart: baseChart,
       resolvedYAxisFields
     });
   }, [baseChart, resolvedYAxisFields]);
-  const chart = (0, import_react62.useMemo)(() => {
+  const chart = (0, import_react61.useMemo)(() => {
     if (!baseChart) return void 0;
     let columns2 = mergeChartColumnFormatsFromYAxisFields(
       baseChart.columns,
@@ -67906,8 +68530,8 @@ function useReport(reportIdArg, options = {}) {
     resolvedYAxisFields,
     resolvedYAxisFieldsForDisplay
   ]);
-  const pivotDateFilterRangeCacheRef = (0, import_react62.useRef)({ key: "", min: null, max: null });
-  const filterOptions = (0, import_react62.useMemo)(() => {
+  const pivotDateFilterRangeCacheRef = (0, import_react61.useRef)({ key: "", min: null, max: null });
+  const filterOptions = (0, import_react61.useMemo)(() => {
     const out = [];
     for (const [field, values] of filterValueOptionsByFieldName) {
       out.push({
@@ -67969,7 +68593,7 @@ function useReport(reportIdArg, options = {}) {
     effectiveReportId,
     filterValueOptionsByFieldName
   ]);
-  const chartForUi = (0, import_react62.useMemo)(() => {
+  const chartForUi = (0, import_react61.useMemo)(() => {
     if (!chart?.pivot) return chart;
     const pivot = chart.pivot;
     const qualify = (field, table2) => table2 ? `${table2}.${field}` : field;
@@ -68044,12 +68668,22 @@ function useReport(reportIdArg, options = {}) {
       }
     };
   }, [chart, filterOptions, filtersForQueryBuilder]);
+  const resolvedChartSort = chartSortOverride === void 0 ? sourceReport?.chartSort : chartSortOverride ?? void 0;
+  const chartSort = formatChartSortValue(resolvedChartSort);
+  const chartSortOptions = (0, import_react61.useMemo)(
+    () => getChartSortOptions(chartForUi),
+    [chartForUi]
+  );
+  const chartWithSort = (0, import_react61.useMemo)(
+    () => chartForUi ? applyChartSort(chartForUi, resolvedChartSort) : chartForUi,
+    [chartForUi, resolvedChartSort]
+  );
   const isPivotTableChart = String(chartType ?? "").toLowerCase() === "table" && Boolean(pivotState);
-  const pivotTableColumnControls = (0, import_react62.useMemo)(
+  const pivotTableColumnControls = (0, import_react61.useMemo)(
     () => isPivotTableChart ? buildPivotColumnPivotTableFormattingColumns(pivotState, chart) : null,
     [chart, isPivotTableChart, pivotState]
   );
-  const chartAxes = (0, import_react62.useMemo)(() => {
+  const chartAxes = (0, import_react61.useMemo)(() => {
     const yAxisItems = resolvedYAxisFields.map(
       (yAxisField, index) => ({
         id: String(index),
@@ -68198,8 +68832,8 @@ function useReport(reportIdArg, options = {}) {
     xAxisOptions,
     yAxisOptions
   ]);
-  const tableFormatCacheRef = (0, import_react62.useRef)(/* @__PURE__ */ new Map());
-  const tableFormatMerge = (0, import_react62.useMemo)(
+  const tableFormatCacheRef = (0, import_react61.useRef)(/* @__PURE__ */ new Map());
+  const tableFormatMerge = (0, import_react61.useMemo)(
     () => mergeDisplayAndSourceForTableFormats({
       effectiveReportBuilderTableNames,
       scopedSchemaColumns,
@@ -68215,7 +68849,7 @@ function useReport(reportIdArg, options = {}) {
       tableColumnsEditedSignature
     ]
   );
-  const table = (0, import_react62.useMemo)(() => {
+  const table = (0, import_react61.useMemo)(() => {
     const baseWindowRows = Array.isArray(sourceReport?.rows) ? sourceReport.rows : [];
     const rawRows = tablePageRows ?? baseWindowRows.slice(paginationRangeStart, paginationRangeEnd);
     const { columns: mergedFromReport } = mergeDisplayAndSourceForTableFormats({
@@ -68345,7 +68979,7 @@ function useReport(reportIdArg, options = {}) {
   const {
     columnsOptions: tableFormattingColumnOptions,
     hasTableDrivenColumnOrder
-  } = (0, import_react62.useMemo)(() => {
+  } = (0, import_react61.useMemo)(() => {
     if (pivotTableColumnControls) {
       return getAllColumnOptions({
         schemaColumnOptions,
@@ -68375,24 +69009,24 @@ function useReport(reportIdArg, options = {}) {
     schemaColumnOptions,
     table.columns
   ]);
-  const axisSelectFormatLabels = (0, import_react62.useMemo)(
+  const axisSelectFormatLabels = (0, import_react61.useMemo)(
     () => AXIS_FORMAT_OPTIONS.map((option) => option.label),
     []
   );
-  const xAxisFormatOptionLabels = (0, import_react62.useMemo)(() => {
+  const xAxisFormatOptionLabels = (0, import_react61.useMemo)(() => {
     if (isPivotTableDateBucketRowAxis(chartAxesBaseChart, resolvedXAxisField)) {
       return ["date", ...axisSelectFormatLabels];
     }
     return axisSelectFormatLabels;
   }, [chartAxesBaseChart, resolvedXAxisField, axisSelectFormatLabels]);
-  const tableDerivedColumnOrder = (0, import_react62.useMemo)(() => {
+  const tableDerivedColumnOrder = (0, import_react61.useMemo)(() => {
     return tableFormattingColumnOptions.map((option) => option.value);
   }, [tableFormattingColumnOptions]);
-  const tableDerivedColumnOrderSignature = (0, import_react62.useMemo)(
+  const tableDerivedColumnOrderSignature = (0, import_react61.useMemo)(
     () => tableDerivedColumnOrder.join("|"),
     [tableDerivedColumnOrder]
   );
-  const activeTableColumnIds = (0, import_react62.useMemo)(() => {
+  const activeTableColumnIds = (0, import_react61.useMemo)(() => {
     if (pivotTableColumnControls) {
       return pivotTableColumnControls.selectedColumnIds;
     }
@@ -68426,7 +69060,7 @@ function useReport(reportIdArg, options = {}) {
     tableDerivedColumnOrder,
     tableFormattingColumnOptions
   ]);
-  const columnOptionById = (0, import_react62.useMemo)(() => {
+  const columnOptionById = (0, import_react61.useMemo)(() => {
     const map = /* @__PURE__ */ new Map();
     for (const option of tableColumnPickerPoolOptions) {
       map.set(option.value, option);
@@ -68438,7 +69072,7 @@ function useReport(reportIdArg, options = {}) {
     }
     return map;
   }, [tableColumnPickerPoolOptions, tableFormattingColumnOptions]);
-  const displayColumnById = (0, import_react62.useMemo)(() => {
+  const displayColumnById = (0, import_react61.useMemo)(() => {
     const map = /* @__PURE__ */ new Map();
     for (const column of displayColumns) {
       const field = String(column.field ?? "").trim();
@@ -68449,7 +69083,7 @@ function useReport(reportIdArg, options = {}) {
     }
     return map;
   }, [displayColumns]);
-  const tableColumnSettingsById = (0, import_react62.useMemo)(() => {
+  const tableColumnSettingsById = (0, import_react61.useMemo)(() => {
     const map = /* @__PURE__ */ new Map();
     const effectiveById = tableFormatMerge.formatByColumnOptionId;
     const mergedColumnByField = /* @__PURE__ */ new Map();
@@ -68579,13 +69213,13 @@ function useReport(reportIdArg, options = {}) {
     sourceReport?.columns,
     tableFormatMerge
   ]);
-  const tableColumnSettingsCoalesceRef = (0, import_react62.useRef)(
+  const tableColumnSettingsCoalesceRef = (0, import_react61.useRef)(
     /* @__PURE__ */ new Map()
   );
-  (0, import_react62.useLayoutEffect)(() => {
+  (0, import_react61.useLayoutEffect)(() => {
     tableColumnSettingsCoalesceRef.current = new Map(tableColumnSettingsById);
   }, [tableColumnSettingsById]);
-  const tableColumnItems = (0, import_react62.useMemo)(() => {
+  const tableColumnItems = (0, import_react61.useMemo)(() => {
     const pivotRowFieldForFormat = String(chart?.pivot?.rowField ?? "").trim();
     const pivotRowFieldType = String(chart?.pivot?.rowFieldType ?? "").trim();
     const items = activeTableColumnIds.map((columnId) => {
@@ -68621,10 +69255,10 @@ function useReport(reportIdArg, options = {}) {
     isPivotTableChart,
     tableColumnSettingsById
   ]);
-  const tableColumnById = (0, import_react62.useMemo)(() => {
+  const tableColumnById = (0, import_react61.useMemo)(() => {
     return new Map(tableColumnItems.map((item) => [item.id, item]));
   }, [tableColumnItems]);
-  const tableColumnValues = (0, import_react62.useMemo)(() => {
+  const tableColumnValues = (0, import_react61.useMemo)(() => {
     const pivotRowFieldForFormat = String(chart?.pivot?.rowField ?? "").trim();
     const pivotRowFieldType = String(chart?.pivot?.rowFieldType ?? "").trim();
     return tableColumnItems.map((item) => {
@@ -68838,6 +69472,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,
@@ -69410,60 +70049,10 @@ 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 = (0, import_react62.useCallback)(async () => {
+  const saveChanges = (0, import_react61.useCallback)(async () => {
     if (!client) return;
     if (!String(dashboardNameForNewReport ?? "").trim()) return;
     if (!sourceReport) return;
@@ -69499,7 +70088,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,
@@ -69536,6 +70126,7 @@ function useReport(reportIdArg, options = {}) {
     resolvedXAxisFormat,
     resolvedXAxisLabel,
     resolvedChartType,
+    resolvedChartSort,
     resolvedYAxisFields,
     sourceReport,
     setDraftSessionId,
@@ -69544,7 +70135,7 @@ function useReport(reportIdArg, options = {}) {
   ]);
   return {
     /* ── Chart & table (exceptions: not value/options pairs) ── */
-    chart: chartForUi,
+    chart: chartWithSort,
     chartLoading,
     table,
     tableLoading,
@@ -69572,6 +70163,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. */
@@ -69648,7 +70242,7 @@ function ChatChartCard({
     loading,
     setReport
   } = useReport(reportId);
-  const selectedColumnValues = (0, import_react63.useMemo)(
+  const selectedColumnValues = (0, import_react62.useMemo)(
     () => columns.map((column) => column.value),
     [columns]
   );
@@ -69915,7 +70509,7 @@ function ToolCallBlock({ toolCall }) {
   );
 }
 function ToolCallResult({ content }) {
-  const [expanded, setExpanded] = (0, import_react64.useState)(false);
+  const [expanded, setExpanded] = (0, import_react63.useState)(false);
   if (!content) return null;
   const isLong = content.length > 300;
   const displayed = isLong && !expanded ? content.slice(0, 300) + "..." : content;
@@ -69967,18 +70561,18 @@ function Chat({
   agentEndpoint,
   suggestions
 }) {
-  const [client] = (0, import_react64.useContext)(ClientContext);
-  const { getToken } = (0, import_react64.useContext)(FetchContext);
-  const { tenants } = (0, import_react64.useContext)(TenantContext);
-  const [messages, setMessages] = (0, import_react64.useState)([]);
-  const [input, setInput] = (0, import_react64.useState)("");
-  const [inputError, setInputError] = (0, import_react64.useState)("");
-  const [isLoading, setIsLoading] = (0, import_react64.useState)(false);
-  const [model, setModel] = (0, import_react64.useState)("gemini-3-flash-preview");
-  const containerRef = (0, import_react64.useRef)(null);
-  const textareaRef = (0, import_react64.useRef)(null);
-  const abortControllerRef = (0, import_react64.useRef)(null);
-  (0, import_react64.useEffect)(() => {
+  const [client] = (0, import_react63.useContext)(ClientContext);
+  const { getToken } = (0, import_react63.useContext)(FetchContext);
+  const { tenants } = (0, import_react63.useContext)(TenantContext);
+  const [messages, setMessages] = (0, import_react63.useState)([]);
+  const [input, setInput] = (0, import_react63.useState)("");
+  const [inputError, setInputError] = (0, import_react63.useState)("");
+  const [isLoading, setIsLoading] = (0, import_react63.useState)(false);
+  const [model, setModel] = (0, import_react63.useState)("gemini-3-flash-preview");
+  const containerRef = (0, import_react63.useRef)(null);
+  const textareaRef = (0, import_react63.useRef)(null);
+  const abortControllerRef = (0, import_react63.useRef)(null);
+  (0, import_react63.useEffect)(() => {
     if (!containerRef.current) {
       return;
     }
@@ -70412,7 +71006,7 @@ function Chat({
 }
 
 // src/hooks/useReportFilterDraft.ts
-var import_react65 = require("react");
+var import_react64 = require("react");
 var normalizeOperatorKey = (operator) => String(operator ?? "").trim().toLowerCase().replace(/[_\s]+/g, "");
 var defaultFilterRuleValueForOperator = (operator) => {
   const key = normalizeOperatorKey(operator);
@@ -70451,12 +71045,12 @@ function useReportFilterDraft(args) {
   const committed = queryBuilderFiltersForEditor(
     isQueryBuilderDisplayGroup(committedFilters) ? committedFilters : EMPTY_COMMITTED_FILTERS
   );
-  const committedRef = (0, import_react65.useRef)(committed);
+  const committedRef = (0, import_react64.useRef)(committed);
   committedRef.current = committed;
-  const setFiltersRef = (0, import_react65.useRef)(setFilters);
+  const setFiltersRef = (0, import_react64.useRef)(setFilters);
   setFiltersRef.current = setFilters;
-  const lastNonEmptyFieldsRef = (0, import_react65.useRef)([]);
-  const prevReportIdForFieldsRef = (0, import_react65.useRef)(reportId);
+  const lastNonEmptyFieldsRef = (0, import_react64.useRef)([]);
+  const prevReportIdForFieldsRef = (0, import_react64.useRef)(reportId);
   if (prevReportIdForFieldsRef.current !== reportId) {
     prevReportIdForFieldsRef.current = reportId;
     lastNonEmptyFieldsRef.current = [];
@@ -70465,25 +71059,25 @@ function useReportFilterDraft(args) {
     lastNonEmptyFieldsRef.current = queryBuilderProps.fields;
   }
   const effectiveFields = queryBuilderProps.fields.length > 0 ? queryBuilderProps.fields : lastNonEmptyFieldsRef.current;
-  const committedSignature = (0, import_react65.useMemo)(
+  const committedSignature = (0, import_react64.useMemo)(
     () => committedFiltersSignature(committed),
     // eslint-disable-next-line react-hooks/exhaustive-deps -- `committed` normalizes null to a stable constant
     [committedFilters]
   );
-  const fieldsSignature = (0, import_react65.useMemo)(
+  const fieldsSignature = (0, import_react64.useMemo)(
     () => fieldCatalogSignature(effectiveFields),
     [effectiveFields]
   );
-  const [resetEpoch, setResetEpoch] = (0, import_react65.useState)(0);
-  const [draftQuery, setDraftQuery] = (0, import_react65.useState)(committed);
-  const [hasUnappliedFilterChanges, setHasUnappliedFilterChanges] = (0, import_react65.useState)(false);
+  const [resetEpoch, setResetEpoch] = (0, import_react64.useState)(0);
+  const [draftQuery, setDraftQuery] = (0, import_react64.useState)(committed);
+  const [hasUnappliedFilterChanges, setHasUnappliedFilterChanges] = (0, import_react64.useState)(false);
   const draftResetKey = `${reportId}|${committedSignature}|${resetEpoch}`;
-  (0, import_react65.useEffect)(() => {
+  (0, import_react64.useEffect)(() => {
     setDraftQuery(committedRef.current);
     setHasUnappliedFilterChanges(false);
   }, [draftResetKey]);
   const filterDraftKey = `${draftResetKey}|${fieldsSignature}`;
-  const handleQueryChange = (0, import_react65.useCallback)((next) => {
+  const handleQueryChange = (0, import_react64.useCallback)((next) => {
     if (!isQueryBuilderDisplayGroup(next)) return;
     const nextGroup = next;
     setDraftQuery(nextGroup);
@@ -70495,25 +71089,25 @@ function useReportFilterDraft(args) {
       (prev) => prev === nextDirty ? prev : nextDirty
     );
   }, []);
-  const applyFilterDraft = (0, import_react65.useCallback)(() => {
+  const applyFilterDraft = (0, import_react64.useCallback)(() => {
     setFiltersRef.current(draftQuery);
   }, [draftQuery]);
-  const resetFilterDraft = (0, import_react65.useCallback)(() => {
+  const resetFilterDraft = (0, import_react64.useCallback)(() => {
     setDraftQuery(committedRef.current);
     setHasUnappliedFilterChanges(false);
     setResetEpoch((epoch) => epoch + 1);
   }, []);
-  const getDefaultField = (0, import_react65.useCallback)((fields) => {
+  const getDefaultField = (0, import_react64.useCallback)((fields) => {
     const stringField = fields.find(
       (field) => field.quillFieldType === "string" && String(field.name ?? "").trim()
     );
     return stringField?.name ?? fields[0]?.name ?? "";
   }, []);
-  const getDefaultValue = (0, import_react65.useCallback)(
+  const getDefaultValue = (0, import_react64.useCallback)(
     (rule) => defaultFilterRuleValueForOperator(rule?.operator),
     []
   );
-  const filterDraftQueryBuilderProps = (0, import_react65.useMemo)(
+  const filterDraftQueryBuilderProps = (0, import_react64.useMemo)(
     () => ({
       ...queryBuilderProps,
       fields: effectiveFields,
@@ -70566,7 +71160,7 @@ function useReportQueryBuilder(args) {
 }
 
 // src/ReportDetail.tsx
-var import_react66 = require("react");
+var import_react65 = require("react");
 var import_jsx_runtime89 = require("react/jsx-runtime");
 var CHART_MIN_PX = 220;
 var TABLE_SLOT_HEIGHT_PX = 360;
@@ -70657,7 +71251,7 @@ function ReportDetail({
   hideTableChartOuterBorder = false,
   onClickChartElement
 }) {
-  const [theme] = (0, import_react66.useContext)(ThemeContext);
+  const [theme] = (0, import_react65.useContext)(ThemeContext);
   const surfaceBackground = theme?.backgroundColor ?? "#fff";
   const titleColor = theme?.primaryTextColor ?? "var(--foreground, #0f172a)";
   const mutedTextColor = theme?.secondaryTextColor ?? "#64748B";
@@ -70666,9 +71260,9 @@ function ReportDetail({
   const isTableChart = type === "table";
   const useDetailTableFromUseForm = isTableChart && !isPivotTableChartConfig(chart);
   const showBottomRawTable = !isTableChart;
-  const chartSlotRef = (0, import_react66.useRef)(null);
-  const [chartHeightPx, setChartHeightPx] = (0, import_react66.useState)(360);
-  (0, import_react66.useLayoutEffect)(() => {
+  const chartSlotRef = (0, import_react65.useRef)(null);
+  const [chartHeightPx, setChartHeightPx] = (0, import_react65.useState)(360);
+  (0, import_react65.useLayoutEffect)(() => {
     const el = chartSlotRef.current;
     if (!el) {
       return;
@@ -70793,7 +71387,7 @@ function ReportDetail({
 init_valueFormatter();
 
 // src/hooks/useTenants.ts
-var import_react67 = require("react");
+var import_react66 = require("react");
 var useTenants = (dashboardName) => {
   const {
     tenants,
@@ -70806,13 +71400,13 @@ var useTenants = (dashboardName) => {
     fetchMappedTenantsForDashboard,
     getMappedTenantsForDashboard,
     getViewerTenantsByOwner
-  } = (0, import_react67.useContext)(TenantContext);
-  (0, import_react67.useEffect)(() => {
+  } = (0, import_react66.useContext)(TenantContext);
+  (0, import_react66.useEffect)(() => {
     if (dashboardName) {
       fetchViewerTenantsForDashboard(dashboardName);
     }
   }, [dashboardName, fetchViewerTenantsForDashboard]);
-  (0, import_react67.useEffect)(() => {
+  (0, import_react66.useEffect)(() => {
     if (dashboardName) {
       fetchMappedTenantsForDashboard(dashboardName);
     }
@@ -70831,33 +71425,33 @@ var useTenants = (dashboardName) => {
 };
 
 // src/hooks/useQuill.ts
-var import_react68 = require("react");
+var import_react67 = require("react");
 init_paginationProcessing();
 init_tableProcessing();
 init_dataProcessing();
 var useQuill = (reportId, pagination) => {
-  const { reports, reportsDispatch, fetchIndividualReport } = (0, import_react68.useContext)(ReportsContext);
+  const { reports, reportsDispatch, fetchIndividualReport } = (0, import_react67.useContext)(ReportsContext);
   const { allReportsById } = useAllReports();
-  const { getToken } = (0, import_react68.useContext)(FetchContext);
-  const dashboardReport = (0, import_react68.useMemo)(() => {
+  const { getToken } = (0, import_react67.useContext)(FetchContext);
+  const dashboardReport = (0, import_react67.useMemo)(() => {
     return allReportsById[reportId ?? ""];
   }, [allReportsById[reportId ?? ""]]);
-  const { dashboardFilters, dashboardCustomFilters } = (0, import_react68.useContext)(
+  const { dashboardFilters, dashboardCustomFilters } = (0, import_react67.useContext)(
     DashboardFiltersContext
   );
-  const { reportFilters, customReportFilters, reportFiltersDispatch } = (0, import_react68.useContext)(ReportFiltersContext);
-  const specificReportFilters = (0, import_react68.useMemo)(() => {
+  const { reportFilters, customReportFilters, reportFiltersDispatch } = (0, import_react67.useContext)(ReportFiltersContext);
+  const specificReportFilters = (0, import_react67.useMemo)(() => {
     if (!reportId) return null;
     return Object.values(reportFilters[reportId] ?? []).map((f) => f.filter);
   }, [reportFilters, reportId]);
-  const [schemaData] = (0, import_react68.useContext)(SchemaDataContext);
-  const [client, isClientLoading] = (0, import_react68.useContext)(ClientContext);
-  const { tenants } = (0, import_react68.useContext)(TenantContext);
-  const { eventTracking } = (0, import_react68.useContext)(EventTrackingContext);
-  const [loading, setLoading] = (0, import_react68.useState)(true);
-  const [error, setError] = (0, import_react68.useState)(void 0);
-  const [previousPage, setPreviousPage] = (0, import_react68.useState)(0);
-  const processedReport = (0, import_react68.useMemo)(() => {
+  const [schemaData] = (0, import_react67.useContext)(SchemaDataContext);
+  const [client, isClientLoading] = (0, import_react67.useContext)(ClientContext);
+  const { tenants } = (0, import_react67.useContext)(TenantContext);
+  const { eventTracking } = (0, import_react67.useContext)(EventTrackingContext);
+  const [loading, setLoading] = (0, import_react67.useState)(true);
+  const [error, setError] = (0, import_react67.useState)(void 0);
+  const [previousPage, setPreviousPage] = (0, import_react67.useState)(0);
+  const processedReport = (0, import_react67.useMemo)(() => {
     return reportId && allReportsById[reportId] ? convertInternalReportToReport(
       mergeComparisonRange(allReportsById[reportId]),
       specificReportFilters ?? [],
@@ -70865,7 +71459,7 @@ var useQuill = (reportId, pagination) => {
       "useQuill"
     ) : void 0;
   }, [reportId, reportId && allReportsById[reportId], specificReportFilters]);
-  const [additionalProcessing, setAdditionProcessing] = (0, import_react68.useState)(
+  const [additionalProcessing, setAdditionProcessing] = (0, import_react67.useState)(
     pagination ? {
       page: pagination
     } : void 0
@@ -71014,7 +71608,7 @@ var useQuill = (reportId, pagination) => {
       setLoading(false);
     }
   };
-  (0, import_react68.useEffect)(() => {
+  (0, import_react67.useEffect)(() => {
     if (isClientLoading) return;
     if (reportId && specificReportFilters) {
       fetchReportHelper(reportId, {
@@ -71054,10 +71648,10 @@ var useQuill = (reportId, pagination) => {
 
 // src/hooks/useFormat.ts
 init_valueFormatter();
-var import_react69 = require("react");
+var import_react68 = require("react");
 var useMemoizedRows = (reportId) => {
   const { data } = useQuill(reportId);
-  const formattedRows = (0, import_react69.useMemo)(() => {
+  const formattedRows = (0, import_react68.useMemo)(() => {
     if (!data || !data.rows || !data.columns)
       return { rows: [], loading: true };
     return {
@@ -71081,7 +71675,7 @@ var useMemoizedRows = (reportId) => {
 };
 
 // src/hooks/useAskQuill.tsx
-var import_react70 = require("react");
+var import_react69 = require("react");
 init_astProcessing();
 init_astFilterProcessing();
 init_pivotProcessing();
@@ -71109,13 +71703,13 @@ function convertColumnInternalToAskQuillColumn(columns) {
   });
 }
 var useAskQuill = (dashboardName) => {
-  const [client] = (0, import_react70.useContext)(ClientContext);
-  const [schemaData] = (0, import_react70.useContext)(SchemaDataContext);
-  const { tenants } = (0, import_react70.useContext)(TenantContext);
-  const { getToken } = (0, import_react70.useContext)(FetchContext);
-  const { eventTracking } = (0, import_react70.useContext)(EventTrackingContext);
-  const [astInfo, setAstInfo] = (0, import_react70.useState)(void 0);
-  const [data, setData] = (0, import_react70.useState)({
+  const [client] = (0, import_react69.useContext)(ClientContext);
+  const [schemaData] = (0, import_react69.useContext)(SchemaDataContext);
+  const { tenants } = (0, import_react69.useContext)(TenantContext);
+  const { getToken } = (0, import_react69.useContext)(FetchContext);
+  const { eventTracking } = (0, import_react69.useContext)(EventTrackingContext);
+  const [astInfo, setAstInfo] = (0, import_react69.useState)(void 0);
+  const [data, setData] = (0, import_react69.useState)({
     rows: [],
     columns: [],
     pivot: null,
@@ -71125,9 +71719,9 @@ var useAskQuill = (dashboardName) => {
     pivotColumnFields: [],
     pivotValueFields: []
   });
-  const [loading, setLoading] = (0, import_react70.useState)(false);
-  const [error, setError] = (0, import_react70.useState)(void 0);
-  const [ask, setAsk] = (0, import_react70.useState)(
+  const [loading, setLoading] = (0, import_react69.useState)(false);
+  const [error, setError] = (0, import_react69.useState)(void 0);
+  const [ask, setAsk] = (0, import_react69.useState)(
     async () => void 0
   );
   const askHelper = async (query) => {
@@ -71327,7 +71921,7 @@ var useAskQuill = (dashboardName) => {
     });
     setLoading(false);
   };
-  (0, import_react70.useEffect)(() => {
+  (0, import_react69.useEffect)(() => {
     setAsk(() => askHelper);
   }, [schemaData.schema]);
   return {
@@ -71341,13 +71935,13 @@ var useAskQuill = (dashboardName) => {
 };
 
 // src/hooks/useVirtualTables.tsx
-var import_react71 = require("react");
+var import_react70 = require("react");
 var useVirtualTables = () => {
-  const [schemaData, setSchemaData] = (0, import_react71.useContext)(SchemaDataContext);
-  const { tenants } = (0, import_react71.useContext)(TenantContext);
-  const { getToken, quillFetchWithToken } = (0, import_react71.useContext)(FetchContext);
-  const { eventTracking } = (0, import_react71.useContext)(EventTrackingContext);
-  const [loadingTables, setLoadingTables] = (0, import_react71.useState)({});
+  const [schemaData, setSchemaData] = (0, import_react70.useContext)(SchemaDataContext);
+  const { tenants } = (0, import_react70.useContext)(TenantContext);
+  const { getToken, quillFetchWithToken } = (0, import_react70.useContext)(FetchContext);
+  const { eventTracking } = (0, import_react70.useContext)(EventTrackingContext);
+  const [loadingTables, setLoadingTables] = (0, import_react70.useState)({});
   const handleReload = async (client, caller) => {
     setSchemaData({ ...schemaData, isSchemaLoading: true });
     setLoadingTables(
@@ -71485,7 +72079,7 @@ var useVirtualTables = () => {
 };
 
 // src/hooks/useChangelogRefresh.ts
-var import_react72 = require("react");
+var import_react71 = require("react");
 init_filterProcessing();
 var CALLER = "agent-changelog";
 var getChangeType = (entry) => {
@@ -71506,15 +72100,15 @@ var getChangeType = (entry) => {
   return typeof changeType === "string" ? changeType.toUpperCase() : "UNKNOWN";
 };
 var useChangelogRefresh = () => {
-  const { loadDashboard, dashboardConfig, dashboardConfigDispatch } = (0, import_react72.useContext)(DashboardConfigContext);
+  const { loadDashboard, dashboardConfig, dashboardConfigDispatch } = (0, import_react71.useContext)(DashboardConfigContext);
   const {
     loadFiltersForDashboard,
     dispatch: dashboardFiltersDispatch,
     customFilterDispatch
-  } = (0, import_react72.useContext)(DashboardFiltersContext);
-  const [, dashboardDispatch] = (0, import_react72.useContext)(DashboardContext);
-  const { reportsDispatch } = (0, import_react72.useContext)(ReportsContext);
-  const [, setSchemaData] = (0, import_react72.useContext)(SchemaDataContext);
+  } = (0, import_react71.useContext)(DashboardFiltersContext);
+  const [, dashboardDispatch] = (0, import_react71.useContext)(DashboardContext);
+  const { reportsDispatch } = (0, import_react71.useContext)(ReportsContext);
+  const [, setSchemaData] = (0, import_react71.useContext)(SchemaDataContext);
   const { allReportsById } = useAllReports();
   const { reloadSome } = useVirtualTables();
   const refreshChangelogEntries = async (entries2, client) => {