@quillsql/react 2.16.76 → 2.16.78

package/dist/index.js

@@ -17280,7 +17280,8 @@ async function generatePivotWithSQL({
   getToken,
   reportBuilderState,
   // Add reportBuilderState parameter
-  overwriteCache = false
+  overwriteCache = false,
+  abortSignal
 }) {
   const databaseType = client.databaseType || "postgresql";
   pivot = normalizeLegacyPivotSortField(pivot);
@@ -17344,7 +17345,8 @@ async function generatePivotWithSQL({
       overwriteCache,
       dateBucket: resolvedDateBucket
     },
-    getToken
+    getToken,
+    abortSignal
   });
   if (resp.data?.success === false) {
     throw resp.data.errorMessage;
@@ -17354,9 +17356,7 @@ async function generatePivotWithSQL({
   const rowCount = resp.queries?.queryResults?.[1]?.rows?.[0]?.row_count || 0;
   parseValueFromBigQueryDates(queryResponseRows, queryResponseFields);
   const resultRowField = processColumnName(
-    String(
-      resp.data?.config?.rowField ?? pivot.rowField ?? ""
-    )
+    String(resp.data?.config?.rowField ?? pivot.rowField ?? "")
   );
   const responseRows = queryResponseRows;
   const responseFields = queryResponseFields;
@@ -17522,7 +17522,8 @@ async function generatePivotTable({
   pivotQuery,
   reportBuilderState,
   // Add reportBuilderState parameter
-  overwriteCache
+  overwriteCache,
+  abortSignal
 }) {
   try {
     if (report && client) {
@@ -17541,11 +17542,15 @@ async function generatePivotTable({
         getToken,
         reportBuilderState,
         // Pass reportBuilderState
-        overwriteCache
+        overwriteCache,
+        abortSignal
       });
       return pivotTable;
     }
   } catch (e) {
+    if (e instanceof Error && e.name === "AbortError") {
+      throw e;
+    }
     eventTracking?.logError?.({
       type: "bug",
       // TODO: determine type
@@ -19912,7 +19917,7 @@ var init_tableProcessing = __esm({
       }
       return { rows, columns, rowCount, error };
     };
-    fetchTableByState = async (reportBuilderState, client, getToken, tenants, eventTracking, dashboardName, processing, customFields, rowsOnly, rowCountOnly, reportId, draftSessionId) => {
+    fetchTableByState = async (reportBuilderState, client, getToken, tenants, eventTracking, dashboardName, processing, customFields, rowsOnly, rowCountOnly, reportId, draftSessionId, abortSignal, filters) => {
       let rows = [];
       let columns = [];
       let rowCount;
@@ -19925,8 +19930,7 @@ var init_tableProcessing = __esm({
           processing,
           // report-builder-query reads `additionalProcessing` (same shape as /query); keep `processing` for compatibility
           additionalProcessing: processing,
-          filters: void 0,
-          // No dashboard filters for ReportBuilder table fetching
+          filters,
           dateField: void 0,
           rowsOnly,
           rowCountOnly,
@@ -19945,7 +19949,8 @@ var init_tableProcessing = __esm({
           client,
           task: "report-builder-query",
           metadata: requestMetadata,
-          getToken
+          getToken,
+          abortSignal
         });
         const resp = await parseFetchResponse(
           client,
@@ -19979,6 +19984,9 @@ var init_tableProcessing = __esm({
           });
         }
       } catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+          throw e;
+        }
         eventTracking?.logError?.({
           type: "bug",
           // TODO: determine type
@@ -20008,8 +20016,8 @@ var init_tableProcessing = __esm({
 function setChangelogHandler(handler) {
   changelogHandler = handler;
 }
-function notifyChangelogs(entries) {
-  changelogHandler?.(entries);
+function notifyChangelogs(entries2) {
+  changelogHandler?.(entries2);
 }
 var changelogHandler;
 var init_changelogNotify = __esm({
@@ -20019,6 +20027,147 @@ var init_changelogNotify = __esm({
   }
 });
 
+// src/utils/reportRequestPool.ts
+function createAbortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  return Object.assign(new Error("The operation was aborted"), {
+    name: "AbortError"
+  });
+}
+function stableStringify(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const object = value;
+  return `{${Object.keys(object).filter((key) => object[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
+}
+function normalizeAdditionalProcessing(value) {
+  if (!value || typeof value !== "object") return value ?? null;
+  const additionalProcessing = value;
+  const page = additionalProcessing.page;
+  if (!page || typeof page !== "object") return additionalProcessing;
+  const pagination = page;
+  return {
+    ...additionalProcessing,
+    page: {
+      ...pagination,
+      page: pagination.page ?? 0,
+      rowsPerPage: pagination.rowsPerPage ?? pagination.rowsPerRequest ?? void 0
+    }
+  };
+}
+function createSharedRequestKey({
+  client,
+  task,
+  metadata,
+  token
+}) {
+  return stableStringify({
+    endpoint: client.queryEndpoint,
+    clientId: client.id ?? client.clientId,
+    headers: client.queryHeaders,
+    withCredentials: client.withCredentials,
+    token,
+    task,
+    metadata: {
+      ...metadata,
+      draftSessionId: void 0,
+      overwriteCache: void 0,
+      // Initial editor requests send the saved pivot/state explicitly while
+      // dashboard requests ask the backend to resolve the same saved values.
+      pivot: void 0,
+      reportBuilderState: void 0,
+      additionalProcessing: normalizeAdditionalProcessing(
+        metadata?.additionalProcessing
+      )
+    }
+  });
+}
+function cloneResult(result) {
+  return JSON.parse(JSON.stringify(result));
+}
+async function getOrFetchSharedRequest({
+  key,
+  signal,
+  fetcher
+}) {
+  if (signal?.aborted) throw createAbortError(signal);
+  let entry = entries.get(key);
+  if (!entry) {
+    const controller = new AbortController();
+    entry = {
+      controller,
+      subscribers: 0,
+      settled: false,
+      promise: Promise.resolve({})
+    };
+    entry.promise = fetcher(controller.signal).then(
+      (result) => {
+        entry.settled = true;
+        if (result.error || result.status === "error") {
+          if (entries.get(key) === entry) entries.delete(key);
+          return result;
+        }
+        entry.expiryTimer = setTimeout(() => {
+          if (entries.get(key) === entry) entries.delete(key);
+        }, COMPLETED_TTL_MS);
+        return result;
+      },
+      (error) => {
+        if (entries.get(key) === entry) entries.delete(key);
+        throw error;
+      }
+    );
+    entries.set(key, entry);
+  }
+  clearTimeout(entry.abortTimer);
+  entry.subscribers += 1;
+  return new Promise((resolve, reject) => {
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      signal?.removeEventListener("abort", onAbort);
+      entry.subscribers -= 1;
+      if (entry.settled || entry.subscribers > 0) return;
+      entry.abortTimer = setTimeout(() => {
+        if (!entry.settled && entry.subscribers === 0) {
+          entry.controller.abort();
+          entries.delete(key);
+        }
+      }, ORPHAN_GRACE_MS);
+    };
+    const onAbort = () => {
+      release();
+      reject(createAbortError(signal));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    entry.promise.then(
+      (result) => {
+        release();
+        resolve(cloneResult(result));
+      },
+      (error) => {
+        release();
+        reject(error);
+      }
+    );
+  });
+}
+var ORPHAN_GRACE_MS, COMPLETED_TTL_MS, entries;
+var init_reportRequestPool = __esm({
+  "src/utils/reportRequestPool.ts"() {
+    "use strict";
+    ORPHAN_GRACE_MS = 100;
+    COMPLETED_TTL_MS = 15e3;
+    entries = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/utils/dataFetcher.tsx
 var dataFetcher_exports = {};
 __export(dataFetcher_exports, {
@@ -20491,7 +20640,7 @@ async function fetchSqlQueryFromState(reportBuilderState, client, getToken, data
     return { query: "", error: `Failed to generate query: ${error.message}` };
   }
 }
-async function fetchQueryDateRangesFromState(reportBuilderState, columns, client, getToken, databaseType, tenants, customFields, dashboardName, eventTracking) {
+async function fetchQueryDateRangesFromState(reportBuilderState, columns, client, getToken, databaseType, tenants, customFields, dashboardName, eventTracking, abortSignal) {
   try {
     const { data } = await quillFetch({
       client,
@@ -20505,7 +20654,8 @@ async function fetchQueryDateRangesFromState(reportBuilderState, columns, client
         customFields,
         dashboardName
       },
-      getToken
+      getToken,
+      abortSignal
     });
     if (!data || !data.rows) {
       return null;
@@ -20525,11 +20675,17 @@ async function fetchQueryDateRangesFromState(reportBuilderState, columns, client
     );
     return results;
   } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw error;
+    }
     return null;
   }
 }
-async function fetchRelevantInfoFromState(reportBuilderState, tables, columns, aliasedColumns, reportBuilderColumns, client, getToken, databaseType, tenants, customFields, dashboardName, eventTracking) {
+async function fetchRelevantInfoFromState(reportBuilderState, tables, columns, aliasedColumns, reportBuilderColumns, client, getToken, databaseType, tenants, customFields, dashboardName, eventTracking, abortSignal) {
   try {
+    if (abortSignal?.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
     const result = await getRelevantInfoFromQuery({
       tables,
       columns,
@@ -20552,6 +20708,9 @@ async function fetchRelevantInfoFromState(reportBuilderState, tables, columns, a
       error: result.error
     };
   } catch (error) {
+    if (abortSignal?.aborted || error instanceof Error && error.name === "AbortError") {
+      throw error;
+    }
     return { error: error.message };
   }
 }
@@ -20564,6 +20723,7 @@ var init_dataFetcher = __esm({
     init_tableProcessing();
     init_dates();
     init_changelogNotify();
+    init_reportRequestPool();
     quillFetch = async ({
       client,
       task,
@@ -20572,55 +20732,67 @@ var init_dataFetcher = __esm({
       abortSignal,
       credentials = "omit",
       urlParameters,
+      shareRequest = false,
       getToken
     }) => {
-      const token = await getToken();
       const queryString = urlParameters ?? `task=${task}`;
       const endpoint = client.queryEndpoint ? `${client.queryEndpoint}?${queryString}` : `${QUILL_SERVER}${QUILL_QUERY_ENDPOINT}?${queryString}`;
-      try {
-        const response = await fetch(endpoint, {
-          method,
-          headers: {
-            ...token ? { Authorization: `Bearer ${token}` } : {},
-            ...client.queryHeaders,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            metadata: {
-              task,
-              clientId: client.id ?? client.clientId,
-              ...metadata
-            }
-          }),
-          credentials: client.withCredentials ? "include" : credentials,
-          signal: abortSignal
-        });
-        if (!response.ok) {
-          throw new Error("API request failed");
-        }
-        let result = await response.json();
-        if (result.data?.data && (result.data.queries || result.data.status || result.data.error)) {
-          result = result.data;
-        }
-        const normalizedData = normalizeChangelogData(result.data);
-        if (task !== "fetch-changelog-list" && Array.isArray(normalizedData?.changelogs)) {
-          notifyChangelogs(normalizedData.changelogs);
-        }
-        return {
-          data: normalizedData,
-          queries: result.queries,
-          status: result.status,
-          error: result.error
-        };
-      } catch (e) {
-        if (e instanceof Error && e.name === "AbortError") {
-          throw e;
-        }
-        if (task !== "set-section-order") {
-          console.error("Failed to fetch:", e);
+      const execute = async (signal, resolvedToken) => {
+        const token2 = resolvedToken ?? await getToken();
+        try {
+          const response = await fetch(endpoint, {
+            method,
+            headers: {
+              ...token2 ? { Authorization: `Bearer ${token2}` } : {},
+              ...client.queryHeaders,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              metadata: {
+                task,
+                clientId: client.id ?? client.clientId,
+                ...metadata
+              }
+            }),
+            credentials: client.withCredentials ? "include" : credentials,
+            signal
+          });
+          if (!response.ok) {
+            throw new Error("API request failed");
+          }
+          let result = await response.json();
+          if (result.data?.data && (result.data.queries || result.data.status || result.data.error)) {
+            result = result.data;
+          }
+          const normalizedData = normalizeChangelogData(result.data);
+          if (task !== "fetch-changelog-list" && Array.isArray(normalizedData?.changelogs)) {
+            notifyChangelogs(normalizedData.changelogs);
+          }
+          return {
+            data: normalizedData,
+            queries: result.queries,
+            status: result.status,
+            error: result.error
+          };
+        } catch (e) {
+          if (e instanceof Error && e.name === "AbortError") {
+            throw e;
+          }
+          if (task !== "set-section-order") {
+            console.error("Failed to fetch:", e);
+          }
+          return { error: "Failed to fetch data" };
         }
-        return { error: "Failed to fetch data" };
+      };
+      if (!shareRequest) {
+        return execute(abortSignal);
       }
+      const token = await getToken();
+      return getOrFetchSharedRequest({
+        key: createSharedRequestKey({ client, task, metadata, token }),
+        signal: abortSignal,
+        fetcher: (signal) => execute(signal, token)
+      });
     };
     parseFetchResponse = async (client, task, response, getToken, useInMemory = false) => {
       try {
@@ -21929,13 +22101,15 @@ async function requestPivotTemplateTask({
   client,
   metadata,
   getToken,
-  abortSignal
+  abortSignal,
+  shareRequest = false
 }) {
   return quillFetch({
     client,
     task: "pivot-template",
     metadata,
     abortSignal,
+    shareRequest,
     getToken
   });
 }
@@ -22103,7 +22277,8 @@ async function fetchPivotTemplateReportForUseForm({
   abortSignal,
   baseReport,
   responseSelection,
-  draftSessionId
+  draftSessionId,
+  shareRequest = false
 }) {
   let fetchStep = "create-metadata";
   try {
@@ -22125,7 +22300,8 @@ async function fetchPivotTemplateReportForUseForm({
       client,
       metadata,
       getToken,
-      abortSignal
+      abortSignal,
+      shareRequest
     });
     fetchStep = "parse-task-response";
     const parsedResponse = await parsePivotTemplateTaskResponse({
@@ -22276,7 +22452,8 @@ async function fetchReport({
   pivot,
   reportBuilderState,
   skipPivotFetch,
-  draftSessionId
+  draftSessionId,
+  shareRequest = false
 }) {
   let reportInfo = void 0;
   let errorMessage = void 0;
@@ -22320,6 +22497,7 @@ async function fetchReport({
         ...resolvedDateBucket ? { dateBucket: resolvedDateBucket } : {}
       },
       abortSignal,
+      shareRequest,
       getToken
     });
     const resp = await parseFetchResponse(client, task, fetchResp, getToken);
@@ -22987,7 +23165,8 @@ var fetchReportBuilderDataFromState = async ({
   dashboardName,
   getToken,
   eventTracking,
-  draftSessionId
+  draftSessionId,
+  abortSignal
 }) => {
   let newRows = [];
   let newColumns = [];
@@ -23061,7 +23240,8 @@ var fetchReportBuilderDataFromState = async ({
       skipRowCount,
       rowCountOnly,
       curReport?.id ? String(curReport.id).trim() : void 0,
-      draftSessionId ? String(draftSessionId).trim() : void 0
+      draftSessionId ? String(draftSessionId).trim() : void 0,
+      abortSignal
     );
     if (tableData.error) {
       throw new Error(tableData.error);
@@ -23116,7 +23296,9 @@ var fetchReportBuilderDataFromState = async ({
         client.databaseType?.toLowerCase() || "postgresql",
         tenants,
         customFields,
-        dashboardName
+        dashboardName,
+        void 0,
+        abortSignal
       );
       const uniqueStrings = uniqueStringsByTable;
       const columnUniqueValues = uniqueStringsByColumn;
@@ -23136,7 +23318,9 @@ var fetchReportBuilderDataFromState = async ({
           client.databaseType?.toLowerCase() || "postgresql",
           tenants,
           customFields ?? [],
-          dashboardName
+          dashboardName,
+          void 0,
+          abortSignal
         );
         if (dateRanges === null) {
           throw new Error("Couldn't fetch date ranges");
@@ -23186,8 +23370,9 @@ var fetchReportBuilderDataFromState = async ({
           getToken,
           pivotQuery: skipPivotColumnFetch ? curReport?.pivotQuery : void 0,
           eventTracking,
-          reportBuilderState
+          reportBuilderState,
           // Pass reportBuilderState for ReportBuilder context
+          abortSignal
         });
         newPivot = pivot;
       }
@@ -23213,6 +23398,9 @@ var fetchReportBuilderDataFromState = async ({
     newRows = tableData.rows;
     newColumns = tableData.columns;
   } catch (e) {
+    if (e instanceof Error && e.name === "AbortError") {
+      throw e;
+    }
     eventTracking?.logError?.({
       type: "bug",
       // TODO: determine type
@@ -24166,15 +24354,226 @@ var applyFiltersInMemory = (rows, filters, options) => {
 // src/utils/cacheCab.ts
 init_inMemoryPivotEngine();
 import { openDB } from "idb";
-import { endOfDay as endOfDay3, max as maxDate, subMonths as subMonths4, min as minDate, startOfDay as startOfDay4 } from "date-fns";
+import {
+  endOfDay as endOfDay3,
+  max as maxDate,
+  subMonths as subMonths4,
+  min as minDate,
+  startOfDay as startOfDay4
+} from "date-fns";
 import { utcToZonedTime as utcToZonedTime2, zonedTimeToUtc } from "date-fns-tz";
+
+// src/utils/cloudCacheValidation.ts
+var LIMIT_CLAUSE_REGEX = /^limit\b\s+(?:all|\d+|\$\d+|:[a-zA-Z_][a-zA-Z0-9_]*|\?)/i;
+var SQL_CONTENT_TO_IGNORE_REGEX = /'(?:''|[^'])*'|"(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|--[^\n]*|\/\*[\s\S]*?\*\//g;
+function isWordChar(char) {
+  if (!char) {
+    return false;
+  }
+  return /[A-Za-z0-9_]/.test(char);
+}
+function getFinalSqlStatement(query) {
+  const statements = query.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+  return statements[statements.length - 1] ?? "";
+}
+function hasTopLevelLimitClause(statement) {
+  let depth = 0;
+  for (let i = 0; i < statement.length; i += 1) {
+    const char = statement[i];
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth !== 0) {
+      continue;
+    }
+    const previousChar = i > 0 ? statement[i - 1] : void 0;
+    if (isWordChar(previousChar)) {
+      continue;
+    }
+    if (!LIMIT_CLAUSE_REGEX.test(statement.slice(i))) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function unwrapIdentifier(identifier) {
+  if (!identifier) {
+    return "";
+  }
+  const trimmed = identifier.trim();
+  if (trimmed.length < 2) {
+    return trimmed;
+  }
+  const startsAndEndsWithDoubleQuote = trimmed.startsWith('"') && trimmed.endsWith('"');
+  const startsAndEndsWithSingleQuote = trimmed.startsWith("'") && trimmed.endsWith("'");
+  const startsAndEndsWithBackticks = trimmed.startsWith("`") && trimmed.endsWith("`");
+  const startsAndEndsWithBrackets = trimmed.startsWith("[") && trimmed.endsWith("]");
+  if (startsAndEndsWithDoubleQuote || startsAndEndsWithSingleQuote || startsAndEndsWithBackticks || startsAndEndsWithBrackets) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function normalizeIdentifier(identifier) {
+  return unwrapIdentifier(identifier).toLowerCase();
+}
+function hasRowFieldWithIdentifier(row, normalizedField) {
+  if (!row || !normalizedField) {
+    return false;
+  }
+  return Object.keys(row).some(
+    (fieldName) => normalizeIdentifier(fieldName) === normalizedField
+  );
+}
+function reportReferencesField(report, field, table) {
+  const normalizedField = normalizeIdentifier(field);
+  if (!normalizedField) {
+    return false;
+  }
+  const referencedColumns = report?.referencedColumns ?? {};
+  let entries2 = Object.entries(referencedColumns);
+  if (entries2.length === 0) {
+    return false;
+  }
+  const normalizedTable = normalizeIdentifier(table);
+  if (normalizedTable) {
+    entries2 = entries2.filter(
+      ([tableName]) => normalizeIdentifier(tableName) === normalizedTable
+    );
+  }
+  const referencedFields = entries2.flatMap(([, fields]) => fields ?? []);
+  if (referencedFields.length === 0) {
+    return false;
+  }
+  return referencedFields.some((referencedField) => {
+    const normalizedReferencedField = normalizeIdentifier(referencedField);
+    return normalizedReferencedField === normalizedField || normalizedReferencedField === "*";
+  });
+}
+function isDateFieldMissingInReport(report) {
+  if (!report?.dateField?.field || !report.dateField.table) {
+    return false;
+  }
+  const dateField = report.dateField;
+  if (!reportReferencesField(report, dateField.field, dateField.table)) {
+    return true;
+  }
+  const firstRow = report.rows?.[0];
+  if (!firstRow) {
+    return false;
+  }
+  const normalizedDateField = normalizeIdentifier(dateField.field);
+  const dateFieldExistsInFirstRow = hasRowFieldWithIdentifier(
+    firstRow,
+    normalizedDateField
+  );
+  return !dateFieldExistsInFirstRow;
+}
+function hasLimitClause(query) {
+  if (!query) {
+    return false;
+  }
+  const sanitizedQuery = query.replace(SQL_CONTENT_TO_IGNORE_REGEX, " ");
+  const finalStatement = getFinalSqlStatement(sanitizedQuery);
+  if (!finalStatement) {
+    return false;
+  }
+  return hasTopLevelLimitClause(finalStatement);
+}
+function reportUsesLimitClause(report) {
+  const queriesToInspect = report?.itemQuery && report.itemQuery.length > 0 ? report.itemQuery : report?.queryString ? [report.queryString] : [];
+  return queriesToInspect.some(hasLimitClause);
+}
+function getMissingDashboardFilterFields({
+  rows = [],
+  dashboardFilters = []
+}) {
+  const dateIndex = dashboardFilters.findIndex(
+    (filter) => filter.filterType === "date_range"
+  );
+  const requiredFields = dashboardFilters.flatMap((filter, index) => {
+    if (index === dateIndex || !filter.field) {
+      return [];
+    }
+    const normalizedField = normalizeIdentifier(filter.field);
+    if (!normalizedField) {
+      return [];
+    }
+    return [
+      {
+        displayField: unwrapIdentifier(filter.field),
+        normalizedField
+      }
+    ];
+  });
+  const dedupedRequiredFields = requiredFields.filter(
+    (field, index, fields) => fields.findIndex(
+      (candidate) => candidate.normalizedField === field.normalizedField
+    ) === index
+  );
+  return dedupedRequiredFields.filter(
+    ({ normalizedField }) => rows.some((row) => !hasRowFieldWithIdentifier(row, normalizedField))
+  ).map(({ displayField }) => displayField);
+}
+
+// src/utils/cacheCab.ts
+init_tableProcessing();
+
+// src/utils/cacheCabSource.ts
+var stableStringify2 = (value) => {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify2).join(",")}]`;
+  }
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify2(object[key])}`).join(",")}}`;
+};
+var createCacheCabSource = (reportBuilderState, config) => {
+  const tableNames = [...new Set(config.referencedTables)].sort();
+  const tables = reportBuilderState.tables;
+  return {
+    key: stableStringify2({
+      version: 1,
+      clientId: config.clientId,
+      databaseType: config.databaseType,
+      tenants: config.tenants ?? null,
+      flags: config.flags ?? null,
+      tables: tableNames,
+      dateField: config.dateField
+    }),
+    dateField: config.dateField,
+    state: {
+      tables,
+      columns: reportBuilderState.columns,
+      filterStack: [],
+      pivot: null,
+      sort: [],
+      limit: null
+    }
+  };
+};
+
+// src/utils/cacheCab.ts
 var TZ = "America/Los_Angeles";
+var MAX_CACHECAB_ROWS = 1e5;
 var CacheCab = class {
   fetchedRange = {};
   cachedReportIds = [];
   uncacheableReportIDs = [];
   uncacheableInFlight = /* @__PURE__ */ new Map();
+  reportMemoryCache = /* @__PURE__ */ new Map();
+  reportLoadInFlight = /* @__PURE__ */ new Map();
+  sourceAliases = /* @__PURE__ */ new Map();
+  sourceFetchInFlight = /* @__PURE__ */ new Map();
   storage;
+  metaReady;
   META_KEY = "cachecab:meta";
   DATA_PREFIX = "cachecab:data:";
   UNCACHEABLE_PREFIX = "cachecab:uncacheable:";
@@ -24182,13 +24581,38 @@ var CacheCab = class {
     storageType = "memory"
   } = {}) {
     this.storage = storageType !== "idb" ? new MemoryStorage() : new IdbStorage();
-    void this.loadMetaFromStorage();
+    this.metaReady = this.loadMetaFromStorage();
   }
-  async get(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, pageSize, getToken, eventTracking, forceRefresh) {
+  async get(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, pageSize, getToken, eventTracking, forceRefresh, sourceConfig) {
+    await this.metaReady;
     if (this.isCached(reportId, tenants) && !forceRefresh) {
-      return this.getFromCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking);
+      return this.getFromCache(
+        reportId,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        client,
+        tenants,
+        flags,
+        getToken,
+        eventTracking,
+        sourceConfig
+      );
     } else {
-      return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, true, forceRefresh);
+      return this.addToCache(
+        reportId,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        client,
+        tenants,
+        flags,
+        getToken,
+        eventTracking,
+        true,
+        forceRefresh,
+        sourceConfig
+      );
     }
   }
   isCached(reportId, tenants) {
@@ -24197,6 +24621,47 @@ var CacheCab = class {
   isCacheable(reportId) {
     return !this.uncacheableReportIDs.includes(reportId);
   }
+  /**
+   * Returns CacheCab's raw report without fetching or applying dashboard state.
+   * Consumers must only run report-builder operations locally when `complete`
+   * is true; otherwise the cached rows are an unsafe sample of the report.
+   */
+  async getReportSnapshot(reportId, tenants) {
+    await this.metaReady;
+    const cacheKey = this.getCacheKey(reportId, tenants);
+    if (!this.cachedReportIds.includes(cacheKey)) return null;
+    const cachedReport = await this.readCachedReport(cacheKey);
+    if (!cachedReport) return null;
+    try {
+      const report = { ...cachedReport, id: reportId };
+      const rowCount = report.rows?.length ?? 0;
+      const hasQueryLimit = Boolean(report.reportBuilderState?.limit) || reportUsesLimitClause(report);
+      const hitRowLimit = rowCount >= MAX_CACHECAB_ROWS;
+      const fetchedRange = this.fetchedRange[cacheKey];
+      const coversAllTime = fetchedRange?.allTimeDoneBefore === true;
+      const isSourceEntry = cacheKey.startsWith("source:");
+      return {
+        report,
+        complete: (coversAllTime || isSourceEntry) && !hasQueryLimit && !hitRowLimit,
+        reason: hasQueryLimit ? "query_limit" : hitRowLimit ? "row_limit" : !coversAllTime && !isSourceEntry ? "partial_date_range" : "complete",
+        rowCount,
+        fetchedRange
+      };
+    } catch {
+      return null;
+    }
+  }
+  async evictReport(reportId, tenants) {
+    await this.metaReady;
+    const cacheKey = this.getCacheKey(reportId, tenants);
+    this.cachedReportIds = this.cachedReportIds.filter(
+      (cachedKey) => cachedKey !== cacheKey
+    );
+    delete this.fetchedRange[cacheKey];
+    this.reportMemoryCache.delete(cacheKey);
+    await this.storage.removeItem(`${this.DATA_PREFIX}${cacheKey}`);
+    await this.persistMetaToStorage();
+  }
   async getUncacheableResult(reportId, client, tenants, flags, filters, additionalProcessing, pivot) {
     const key = this.getUncacheableRequestKey(
       reportId,
@@ -24242,7 +24707,10 @@ var CacheCab = class {
     if (!forceRefresh) {
       const raw = await this.storage.getItem(key);
       if (raw) {
-        return { report: JSON.parse(raw), fromCache: true };
+        return {
+          report: JSON.parse(raw),
+          fromCache: true
+        };
       }
       const inFlight = this.uncacheableInFlight.get(key);
       if (inFlight) {
@@ -24266,48 +24734,86 @@ var CacheCab = class {
       this.uncacheableInFlight.delete(key);
     }
   }
-  async addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, firstTime = true, forceRefresh = false) {
+  async addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, firstTime = true, forceRefresh = false, sourceConfig) {
     const tenantPart = tenants ? JSON.stringify(tenants) : "";
-    const cacheKey = this.getCacheKey(reportId, tenants);
+    let cacheKey = this.getCacheKey(reportId, tenants);
     if (firstTime) {
-      const result = await this.fetchInitialReport({ reportId, client, tenants, flags, filters: dashboardFilters, getToken, eventTracking, forceRefresh });
+      const result = await this.fetchInitialReport({
+        reportId,
+        client,
+        tenants,
+        flags,
+        filters: dashboardFilters,
+        getToken,
+        eventTracking,
+        forceRefresh,
+        sourceConfig
+      });
+      cacheKey = this.getCacheKey(reportId, tenants);
       try {
-        await this.storage.setItem(this.DATA_PREFIX + cacheKey, JSON.stringify(result));
+        await this.writeCachedReport(cacheKey, result);
         this.cachedReportIds.push(cacheKey);
         await this.persistMetaToStorage();
       } catch {
         console.warn(`Failed to cache report: ${reportId}. Cache full?`);
       }
-      const newRows = await this.applyPivotsAndFilters(result, dashboardFilters, customFilters, pivot, tenantPart, false);
+      const newRows = await this.applyPivotsAndFilters(
+        result,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        tenantPart,
+        false
+      );
       if (pivot) {
         const pivotColumns = generatePivotColumnsInMemory({
           pivot,
           pivotRows: newRows,
           sourceColumns: result.columnInternal ?? result.columns
         });
-        return { ...result, pivotRows: newRows, pivotColumns: pivotColumns ?? result.pivotColumns, pivotRowCount: newRows.length };
+        return {
+          ...result,
+          pivotRows: newRows,
+          pivotColumns: pivotColumns ?? result.pivotColumns,
+          pivotRowCount: newRows.length
+        };
       }
       return { ...result, rows: newRows, rowCount: newRows.length };
     } else {
-      const dbDateFilter = dashboardFilters.find((x) => x.filterType === "date_range");
+      const dbDateFilter = dashboardFilters.find(
+        (x) => x.filterType === "date_range"
+      );
       const { start: requestedStart, end: requestedEnd } = normalizePSTRanges(
         dbDateFilter?.startDate ? new Date(dbDateFilter.startDate) : void 0,
         dbDateFilter?.endDate ? new Date(dbDateFilter.endDate) : void 0
       );
       if (!requestedStart || !requestedEnd) {
-        return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, true);
+        return this.addToCache(
+          reportId,
+          dashboardFilters,
+          customFilters,
+          pivot,
+          client,
+          tenants,
+          flags,
+          getToken,
+          eventTracking,
+          true,
+          false,
+          sourceConfig
+        );
       }
       const currentRange = this.fetchedRange[cacheKey];
       const rangeStart = currentRange?.start ?? requestedStart;
       const rangeEnd = currentRange?.end ?? endOfDayPST(/* @__PURE__ */ new Date());
-      const existingRaw = await this.storage.getItem(this.DATA_PREFIX + cacheKey);
       let existing;
       let fetchedRows = [];
       try {
-        existing = JSON.parse(existingRaw);
-        if (!existing.rows) {
+        const cachedReport = await this.readCachedReport(cacheKey);
+        if (!cachedReport?.rows) {
           throw new Error("Invalid Cache!");
         }
+        existing = cachedReport;
         if (requestedStart < rangeStart) {
           const olderReport = await this.fetchReport({
             reportId,
@@ -24364,19 +24870,33 @@ var CacheCab = class {
         const filteredNew = filterNewRows(boundaryRows, fetchedRows);
         mergedRows = filteredNew.concat(existing.rows);
       } else {
-        mergedRows = filterNewRows(existing.rows, fetchedRows).concat(existing.rows);
+        mergedRows = filterNewRows(existing.rows, fetchedRows).concat(
+          existing.rows
+        );
       }
       const merged = { ...existing, rows: mergedRows };
-      await this.storage.setItem(this.DATA_PREFIX + cacheKey, JSON.stringify(merged));
+      await this.writeCachedReport(cacheKey, merged);
       await this.persistMetaToStorage();
-      const newRows = await this.applyPivotsAndFilters(merged, dashboardFilters, customFilters, pivot, tenantPart, false);
+      const newRows = await this.applyPivotsAndFilters(
+        merged,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        tenantPart,
+        false
+      );
       if (pivot) {
         const pivotColumns = generatePivotColumnsInMemory({
           pivot,
           pivotRows: newRows,
           sourceColumns: merged.columnInternal ?? merged.columns
         });
-        return { ...merged, pivotRows: newRows, pivotColumns: pivotColumns ?? merged.pivotColumns, pivotRowCount: newRows.length };
+        return {
+          ...merged,
+          pivotRows: newRows,
+          pivotColumns: pivotColumns ?? merged.pivotColumns,
+          pivotRowCount: newRows.length
+        };
       }
       return { ...merged, rows: newRows, rowCount: newRows.length };
     }
@@ -24384,37 +24904,88 @@ var CacheCab = class {
   /**
    * Returns cache entry (or re-queries if stale)
    */
-  async getFromCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking) {
-    const dateRangeFilter = dashboardFilters.find((x) => x.filterType === "date_range");
+  async getFromCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, sourceConfig) {
+    const dateRangeFilter = dashboardFilters.find(
+      (x) => x.filterType === "date_range"
+    );
     const cacheKey = this.getCacheKey(reportId, tenants);
     if (!dateRangeFilter || dateRangeFilter?.primaryRange.value === "ALL_TIME") {
       const fetchInfo = this.fetchedRange[cacheKey];
       if (!fetchInfo || fetchInfo?.allTimeDoneBefore === false || Date.now() - fetchInfo.fetchedAtUTCMS >= MS_IN_DAY) {
-        return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, true);
+        return this.addToCache(
+          reportId,
+          dashboardFilters,
+          customFilters,
+          pivot,
+          client,
+          tenants,
+          flags,
+          getToken,
+          eventTracking,
+          true,
+          false,
+          sourceConfig
+        );
       }
     } else if (this.weShouldReQuery(cacheKey, dateRangeFilter)) {
-      return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, false);
+      return this.addToCache(
+        reportId,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        client,
+        tenants,
+        flags,
+        getToken,
+        eventTracking,
+        false,
+        false,
+        sourceConfig
+      );
     }
     try {
-      const raw = await this.storage.getItem(this.DATA_PREFIX + cacheKey);
-      if (!raw) {
+      const parsed = await this.readCachedReport(cacheKey);
+      if (!parsed) {
         throw new Error("Invalid Cache!");
       }
-      const parsed = JSON.parse(raw);
       const tenantPart = tenants ? JSON.stringify(tenants) : "";
-      const newRows = await this.applyPivotsAndFilters(parsed, dashboardFilters, customFilters, pivot, tenantPart);
+      const newRows = await this.applyPivotsAndFilters(
+        parsed,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        tenantPart
+      );
       if (pivot) {
         const pivotColumns = generatePivotColumnsInMemory({
           pivot,
           pivotRows: newRows,
           sourceColumns: parsed.columnInternal ?? parsed.columns
         });
-        return { ...parsed, pivotRows: newRows, pivotColumns: pivotColumns ?? parsed.pivotColumns, pivotRowCount: newRows.length };
+        return {
+          ...parsed,
+          pivotRows: newRows,
+          pivotColumns: pivotColumns ?? parsed.pivotColumns,
+          pivotRowCount: newRows.length
+        };
       }
       return { ...parsed, rows: newRows, rowCount: newRows.length };
     } catch (err) {
       console.error(err);
-      return this.addToCache(reportId, dashboardFilters, customFilters, pivot, client, tenants, flags, getToken, eventTracking, false);
+      return this.addToCache(
+        reportId,
+        dashboardFilters,
+        customFilters,
+        pivot,
+        client,
+        tenants,
+        flags,
+        getToken,
+        eventTracking,
+        false,
+        false,
+        sourceConfig
+      );
     }
   }
   weShouldReQuery(cacheKey, dateRangeFilter) {
@@ -24435,13 +25006,17 @@ var CacheCab = class {
     filters = [],
     getToken,
     eventTracking,
-    forceRefresh
+    forceRefresh,
+    sourceConfig
   }) {
     let start;
     let end;
     const dateRangeFilter = filters.find((x) => x.filterType === "date_range");
     const cacheRange = dateRangeFilter?.initialCacheDateRange;
-    if (cacheRange && cacheRange.startDate) {
+    if (sourceConfig) {
+      start = sourceConfig.dateRange.startDate;
+      end = sourceConfig.dateRange.endDate;
+    } else if (cacheRange && cacheRange.startDate) {
       const startDate = dateRangeFilter?.startDate;
       start = startDate ? minDate([new Date(cacheRange.startDate), new Date(startDate)]) : new Date(cacheRange.startDate);
       end = endOfDayPST(/* @__PURE__ */ new Date());
@@ -24462,7 +25037,8 @@ var CacheCab = class {
       eventTracking,
       start: normalized.start,
       end: normalized.end,
-      forceRefresh
+      forceRefresh,
+      sourceConfig
     });
   }
   async fetchReport({
@@ -24475,7 +25051,8 @@ var CacheCab = class {
     eventTracking,
     start,
     end,
-    forceRefresh
+    forceRefresh,
+    sourceConfig
   }) {
     let reportInfo = void 0;
     try {
@@ -24483,100 +25060,225 @@ var CacheCab = class {
       const adjusted = [...filters].map((x) => {
         return { ...x, options: void 0 };
       });
-      const dateFilterIndex = adjusted.findIndex((x) => x.filterType === "date_range");
-      const isAllTime = dateFilterIndex !== -1 && adjusted[dateFilterIndex].primaryRange?.value === "ALL_TIME";
+      const dateFilterIndex = adjusted.findIndex(
+        (x) => x.filterType === "date_range"
+      );
+      const isAllTime = sourceConfig ? adjusted[dateFilterIndex]?.primaryRange?.value === "ALL_TIME" : dateFilterIndex === -1 || adjusted[dateFilterIndex].primaryRange?.value === "ALL_TIME";
       if (!isAllTime) {
-        const dateFilter = adjusted[dateFilterIndex];
-        if (dateFilter && dateFilter.startDate && dateFilter.endDate) {
-          adjusted[dateFilterIndex] = { ...dateFilter, startDate: s, endDate: e };
+        const dateFilter2 = adjusted[dateFilterIndex];
+        if (dateFilter2 && dateFilter2.startDate && dateFilter2.endDate) {
+          adjusted[dateFilterIndex] = {
+            ...dateFilter2,
+            startDate: s,
+            endDate: e
+          };
         }
       }
-      const fetchResp = await quillFetch({
+      const stateResponse = await quillFetch({
         client,
-        task: "report",
+        task: "report-builder-state",
         metadata: {
           reportId,
-          clientId: client.id,
-          databaseType: client.databaseType,
-          filters: adjusted,
-          additionalProcessing: { page: { rowsPerPage: 1e3, rowsPerRequest: 1e5 } },
-          useNewNodeSql: true,
-          tenants,
-          flags,
-          overwriteCache: forceRefresh ?? false
+          tenants
         },
         getToken
       });
-      const resp = await parseFetchResponse(
-        client,
-        "report",
-        fetchResp,
-        getToken,
-        true
-      );
-      reportInfo = await processReportResponse({
-        resp,
-        client,
-        filters: adjusted,
-        dateBucket: resp?.dateBucket,
-        additionalProcessing: { page: { rowsPerPage: 1e3, rowsPerRequest: 1e5 } },
-        getToken,
-        eventTracking,
-        tenants,
-        // CacheCab fetches with task: 'report'; keep pivot processing local.
-        skipPivotFetch: true,
-        overwriteCache: forceRefresh ?? false
+      if (stateResponse.error || stateResponse.status === "error") {
+        throw new Error(
+          stateResponse.error || "Could not load report builder state"
+        );
+      }
+      const reportBuilderState = stateResponse.data?.reportBuilderState;
+      if (!reportBuilderState) {
+        throw new Error("Report builder state was not returned");
+      }
+      const source = sourceConfig ? createCacheCabSource(reportBuilderState, sourceConfig) : void 0;
+      const sourceCacheKey = source ? this.bindReportToSource(reportId, tenants, source.key) : this.getCacheKey(reportId, tenants);
+      const sourceDateFilter = source ? {
+        filterType: "date_range",
+        field: source.dateField.field,
+        table: source.dateField.table,
+        dateField: [source.dateField],
+        label: "CacheCab date range",
+        dashboardName: "",
+        startDate: s,
+        endDate: e,
+        primaryRange: { label: "Custom", value: "CUSTOM" },
+        preset: { label: "Custom", value: "CUSTOM" },
+        presetOptions: [],
+        defaultPresetRanges: [],
+        options: void 0
+      } : void 0;
+      const filtersForSource = source ? isAllTime ? [] : [sourceDateFilter] : adjusted;
+      const builderFilters = filtersForSource.map((filter) => {
+        if ("table" in filter && filter.table) return filter;
+        const matchingTables = [
+          ...new Set(
+            reportBuilderState.columns.filter((column) => column.field === filter.field && column.table).map((column) => column.table)
+          )
+        ];
+        return matchingTables.length === 1 ? { ...filter, table: matchingTables[0] } : filter;
       });
+      const sourceState = source?.state ?? {
+        ...reportBuilderState,
+        pivot: null
+      };
+      const fetchSource = async () => {
+        const existingRange = this.fetchedRange[sourceCacheKey];
+        const rangeCovered = existingRange && (existingRange.allTimeDoneBefore || existingRange.start <= s && existingRange.end >= e);
+        if (source && rangeCovered && !forceRefresh) {
+          const existing = await this.readCachedReport(sourceCacheKey);
+          if (existing) return existing;
+        }
+        const tableData = await fetchTableByState(
+          sourceState,
+          client,
+          getToken,
+          tenants,
+          eventTracking,
+          "",
+          {
+            page: {
+              page: 0,
+              rowsPerPage: 1e3,
+              rowsPerRequest: 1e5
+            }
+          },
+          void 0,
+          true,
+          false,
+          reportId,
+          void 0,
+          void 0,
+          builderFilters
+        );
+        if (tableData.error) {
+          throw new Error(tableData.error);
+        }
+        const referencedColumns = sourceState.columns.reduce((result, column) => {
+          const table = column.table ?? "";
+          if (!result[table]) result[table] = [];
+          if (!result[table].includes(column.field)) {
+            result[table].push(column.field);
+          }
+          return result;
+        }, {});
+        return {
+          ...EMPTY_INTERNAL_REPORT,
+          id: reportId,
+          name: reportId,
+          rows: tableData.rows,
+          rowCount: tableData.rows.length,
+          columns: tableData.columns.map((column) => ({
+            field: column.field,
+            format: column.format,
+            label: column.label
+          })),
+          columnInternal: tableData.columns,
+          referencedTables: sourceState.tables.map((table) => table.name),
+          referencedColumns,
+          reportBuilderState,
+          pivot: reportBuilderState.pivot,
+          dateField: source?.dateField
+        };
+      };
+      const existingSourceRequest = source ? this.sourceFetchInFlight.get(sourceCacheKey) : void 0;
+      if (existingSourceRequest && !forceRefresh) {
+        return { ...await existingSourceRequest, id: reportId };
+      }
+      const sourceRequest = fetchSource();
+      if (source) this.sourceFetchInFlight.set(sourceCacheKey, sourceRequest);
+      try {
+        reportInfo = await sourceRequest;
+      } finally {
+        if (source) this.sourceFetchInFlight.delete(sourceCacheKey);
+      }
+      const dateFilter = builderFilters[dateFilterIndex];
+      const dateFilterTable = dateFilter && "table" in dateFilter ? dateFilter.table : void 0;
+      reportInfo.dateField = source?.dateField ?? (dateFilter?.field && dateFilterTable ? { field: dateFilter.field, table: dateFilterTable } : void 0);
       const dateField = reportInfo.dateField?.field;
       if (!isAllTime && dateField !== void 0 && reportInfo.rows.length > 0) {
         const cleanedDateField = removeQuotes(dateField);
-        const missingDateFieldCount = reportInfo.rows.some((row) => row[cleanedDateField] === void 0);
+        const missingDateFieldCount = reportInfo.rows.some(
+          (row) => row[cleanedDateField] === void 0
+        );
         if (missingDateFieldCount) {
           this.uncacheableReportIDs.push(reportId);
+          if (source) {
+            throw new Error(
+              `CacheCab source is missing date field ${dateField}`
+            );
+          }
           return EMPTY_INTERNAL_REPORT;
         }
       }
       const requiredFilterFields = adjusted.flatMap((x, idx) => {
-        if (idx === dateFilterIndex || !x.values && !x.selectedValue) return [];
+        if (idx === dateFilterIndex || !x.values && !x.selectedValue)
+          return [];
         return removeQuotes(x.field);
       });
-      const missingFields = [...new Set(requiredFilterFields.filter(
-        (field) => reportInfo?.rows.some((row) => row[field] === void 0)
-      ))];
+      const missingFields = [
+        ...new Set(
+          requiredFilterFields.filter(
+            (field) => reportInfo?.rows.some((row) => row[field] === void 0)
+          )
+        )
+      ];
       if (missingFields.length > 0) {
         this.uncacheableReportIDs.push(reportId);
+        if (source) {
+          throw new Error(
+            `CacheCab source is missing required fields: ${missingFields.join(", ")}`
+          );
+        }
         return EMPTY_INTERNAL_REPORT;
       }
       const cacheKey = this.getCacheKey(reportId, tenants);
       if (isAllTime) {
-        this.fetchedRange[cacheKey] = { start: /* @__PURE__ */ new Date(0), end: /* @__PURE__ */ new Date(), fetchedAtUTCMS: Date.now(), allTimeDoneBefore: true };
+        this.fetchedRange[cacheKey] = {
+          start: /* @__PURE__ */ new Date(0),
+          end: /* @__PURE__ */ new Date(),
+          fetchedAtUTCMS: Date.now(),
+          allTimeDoneBefore: true
+        };
       } else {
         const existing = this.fetchedRange[cacheKey];
         if (existing && !forceRefresh) {
           const oldStart = existing.start;
           const oldEnd = existing.end;
-          this.fetchedRange[cacheKey] = { start: getMinDate(oldStart, s), end: getMaxDate(oldEnd, e), fetchedAtUTCMS: Date.now(), allTimeDoneBefore: false };
+          this.fetchedRange[cacheKey] = {
+            start: getMinDate(oldStart, s),
+            end: getMaxDate(oldEnd, e),
+            fetchedAtUTCMS: Date.now(),
+            allTimeDoneBefore: false
+          };
         } else {
-          this.fetchedRange[cacheKey] = { start: s, end: e, fetchedAtUTCMS: Date.now(), allTimeDoneBefore: false };
+          this.fetchedRange[cacheKey] = {
+            start: s,
+            end: e,
+            fetchedAtUTCMS: Date.now(),
+            allTimeDoneBefore: false
+          };
         }
       }
     } catch (error) {
       console.warn(error);
-      if (error instanceof Error && error.name === "AbortError") {
+      if (sourceConfig || error instanceof Error && error.name === "AbortError") {
         throw error;
       }
     }
     return reportInfo || EMPTY_INTERNAL_REPORT;
   }
   async applyPivotsAndFilters(report, dashboardFilters, customFilters, pivot, tenantPart, useCache = true) {
-    const datasetVersion = this.fetchedRange[report.id + tenantPart]?.fetchedAtUTCMS ?? 0;
+    const reportCacheKey = this.sourceAliases.get(report.id + tenantPart) ?? report.id + tenantPart;
+    const datasetVersion = this.fetchedRange[reportCacheKey]?.fetchedAtUTCMS ?? 0;
     const keyParts = [
       report.queryString,
       tenantPart,
       datasetVersion,
       // prevents fetching stale filters on hard refresh
-      hashString(stableStringify(dashboardFilters)),
-      hashString(stableStringify(customFilters))
+      hashString(stableStringify3(dashboardFilters)),
+      hashString(stableStringify3(customFilters))
     ];
     const queryKey = this.DATA_PREFIX + keyParts.join("|");
     let filtersApplied;
@@ -24590,19 +25292,30 @@ var CacheCab = class {
       }
     }
     if (!filtersApplied) {
-      const dateIndex = dashboardFilters.findIndex((x) => x.filterType === "date_range");
-      const requiredFilterFields = dashboardFilters.flatMap((x, idx) => {
-        if (idx === dateIndex || !x.values?.length && !x.selectedValue) return [];
-        return removeQuotes(x.field);
-      });
-      const missingFields = [...new Set(requiredFilterFields.filter(
-        (field) => report.rows.some((row) => row[field] === void 0)
-      ))];
+      const dateIndex = dashboardFilters.findIndex(
+        (x) => x.filterType === "date_range"
+      );
+      const requiredFilterFields = dashboardFilters.flatMap(
+        (x, idx) => {
+          if (idx === dateIndex || !x.values?.length && !x.selectedValue)
+            return [];
+          return removeQuotes(x.field);
+        }
+      );
+      const missingFields = [
+        ...new Set(
+          requiredFilterFields.filter(
+            (field) => report.rows.some((row) => row[field] === void 0)
+          )
+        )
+      ];
       if (missingFields.length > 0) {
         this.uncacheableReportIDs.push(report.id);
         return [];
       }
-      const dbDateFilter = dashboardFilters.find((x) => x.filterType === "date_range");
+      const dbDateFilter = dashboardFilters.find(
+        (x) => x.filterType === "date_range"
+      );
       if (report.dateField && dbDateFilter?.startDate) {
         const { start: startDate, end: endDate } = normalizePSTRanges(
           new Date(dbDateFilter.startDate),
@@ -24613,22 +25326,82 @@ var CacheCab = class {
           const rowDate = new Date(x[fieldToUse]);
           return startDate <= rowDate && (endDate ? rowDate <= endDate : true);
         });
-        filtersApplied = applyFiltersInMemory(dateFilteredRows, [], { dashboardFilters, customFilters });
+        filtersApplied = applyFiltersInMemory(dateFilteredRows, [], {
+          dashboardFilters,
+          customFilters
+        });
       } else {
-        filtersApplied = applyFiltersInMemory(report.rows, [], { dashboardFilters, customFilters });
+        filtersApplied = applyFiltersInMemory(report.rows, [], {
+          dashboardFilters,
+          customFilters
+        });
       }
     }
     try {
       await this.storage.setItem(queryKey, JSON.stringify(filtersApplied));
     } catch {
     }
-    const withPivot = applyPivotInMemory(filtersApplied, pivot, dashboardFilters.concat(customFilters));
+    const withPivot = applyPivotInMemory(
+      filtersApplied,
+      pivot,
+      dashboardFilters.concat(customFilters)
+    );
     return withPivot;
   }
+  /**
+   * Reads and parses a persisted report at most once per CacheCab instance.
+   * Concurrent callers share the same storage read and JSON.parse operation.
+   */
+  async readCachedReport(cacheKey) {
+    const cached = this.reportMemoryCache.get(cacheKey);
+    if (cached) return cached;
+    const existingLoad = this.reportLoadInFlight.get(cacheKey);
+    if (existingLoad) return existingLoad;
+    const load = (async () => {
+      const raw = await this.storage.getItem(`${this.DATA_PREFIX}${cacheKey}`);
+      if (!raw) return null;
+      try {
+        const report = JSON.parse(raw);
+        this.reportMemoryCache.set(cacheKey, report);
+        return report;
+      } catch {
+        return null;
+      }
+    })();
+    this.reportLoadInFlight.set(cacheKey, load);
+    try {
+      return await load;
+    } finally {
+      this.reportLoadInFlight.delete(cacheKey);
+    }
+  }
+  /**
+   * Persists a report and updates the parsed in-memory copy atomically from
+   * CacheCab's perspective.
+   */
+  async writeCachedReport(cacheKey, report) {
+    await this.storage.setItem(
+      `${this.DATA_PREFIX}${cacheKey}`,
+      JSON.stringify(report)
+    );
+    this.reportMemoryCache.set(cacheKey, report);
+  }
   getCacheKey(reportId, tenants) {
-    const tenantPart = tenants ? JSON.stringify(tenants) : "";
+    const aliasKey = this.getReportAliasKey(reportId, tenants);
+    return this.sourceAliases.get(aliasKey) ?? aliasKey;
+  }
+  getReportAliasKey(reportId, tenants) {
+    const tenantPart = tenants ? stableStringify3(tenants) : "";
     return reportId + tenantPart;
   }
+  bindReportToSource(reportId, tenants, sourceKey) {
+    const cacheKey = `source:${hashString(sourceKey)}`;
+    this.sourceAliases.set(
+      this.getReportAliasKey(reportId, tenants),
+      cacheKey
+    );
+    return cacheKey;
+  }
   getUncacheableRequestKey(reportId, client, tenants, flags, filters, additionalProcessing, pivot) {
     const canonicalFilters = filters.map(
       (f) => canonicalizeFilterForUncacheableKey(f)
@@ -24637,11 +25410,13 @@ var CacheCab = class {
       reportId,
       client.id,
       client.databaseType,
-      hashString(stableStringify(canonicalizeForKey(tenants ?? null))),
-      hashString(stableStringify(canonicalizeForKey(flags ?? null))),
-      hashString(stableStringify(canonicalFilters)),
-      hashString(stableStringify(canonicalizeForKey(additionalProcessing ?? null))),
-      hashString(stableStringify(canonicalizeForKey(pivot ?? null)))
+      hashString(stableStringify3(canonicalizeForKey(tenants ?? null))),
+      hashString(stableStringify3(canonicalizeForKey(flags ?? null))),
+      hashString(stableStringify3(canonicalFilters)),
+      hashString(
+        stableStringify3(canonicalizeForKey(additionalProcessing ?? null))
+      ),
+      hashString(stableStringify3(canonicalizeForKey(pivot ?? null)))
     ];
     return this.UNCACHEABLE_PREFIX + keyParts.join("|");
   }
@@ -24652,6 +25427,9 @@ var CacheCab = class {
       const parsed = JSON.parse(meta);
       this.cachedReportIds = parsed.cached || [];
       this.uncacheableReportIDs = parsed.cannotBeCached;
+      this.sourceAliases = new Map(
+        Object.entries(parsed.sourceAliases ?? {})
+      );
       this.fetchedRange = Object.fromEntries(
         Object.entries(parsed.fetchedRange || {}).map(([id, range]) => [
           id,
@@ -24674,7 +25452,8 @@ var CacheCab = class {
       JSON.stringify({
         fetchedRange: serializableRange,
         cached: this.cachedReportIds,
-        cannotBeCached: this.uncacheableReportIDs
+        cannotBeCached: this.uncacheableReportIDs,
+        sourceAliases: Object.fromEntries(this.sourceAliases)
       })
     );
   }
@@ -24687,6 +25466,9 @@ var MemoryStorage = class {
   async setItem(key, value) {
     this.store.set(key, value);
   }
+  async removeItem(key) {
+    this.store.delete(key);
+  }
 };
 var DB_NAME = "quill.cachecab";
 var STORE_NAME = "kv";
@@ -24709,6 +25491,10 @@ var IdbStorage = class {
     const db = await this.dbPromise;
     await db.put(STORE_NAME, value, key);
   }
+  async removeItem(key) {
+    const db = await this.dbPromise;
+    await db.delete(STORE_NAME, key);
+  }
 };
 function removeQuotes(str) {
   return str.replace(/^['"]|['"]$/g, "");
@@ -24732,7 +25518,7 @@ function hashString(str) {
 }
 function filterNewRows(existingRows, newRows) {
   const seen = /* @__PURE__ */ new Set();
-  const getKey = (row) => stableStringify(row);
+  const getKey = (row) => stableStringify3(row);
   existingRows.forEach((row) => seen.add(getKey(row)));
   return newRows.filter((row) => {
     const k = getKey(row);
@@ -24741,13 +25527,13 @@ function filterNewRows(existingRows, newRows) {
     return true;
   });
 }
-function stableStringify(obj) {
+function stableStringify3(obj) {
   if (obj === null || typeof obj !== "object") return JSON.stringify(obj);
   if (Array.isArray(obj)) {
-    return `[${obj.map(stableStringify).join(",")}]`;
+    return `[${obj.map(stableStringify3).join(",")}]`;
   }
   const keys = Object.keys(obj).sort();
-  return `{${keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",")}}`;
+  return `{${keys.map((k) => JSON.stringify(k) + ":" + stableStringify3(obj[k])).join(",")}}`;
 }
 function canonicalizeForKey(value) {
   if (value instanceof Date) {
@@ -26903,6 +27689,7 @@ import jsPDF from "jspdf";
 
 // src/hooks/useDashboard.ts
 import { useContext, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { useQueryClient } from "@tanstack/react-query";
 init_dateRangePickerUtils();
 init_Filter();
 init_filterProcessing();
@@ -26946,10 +27733,11 @@ function isDashboardPivotTable(report) {
   return String(report?.chartType ?? "").toLowerCase() === "table" && Boolean(report?.pivot);
 }
 function getDashboardReportProcessing(report, serverPagination) {
-  return isDashboardPivotTable(report) ? {} : serverPagination;
+  return report.pivot ? {} : serverPagination;
 }
 
 // src/hooks/useDashboard.ts
+var DEFAULT_DASHBOARD_REPORT_STALE_TIME_MS = 5 * 60 * 1e3;
 var useDashboardInternal = (dashboardName, customFilters) => {
   const [dashboard] = useContext(DashboardContext);
   const {
@@ -27644,12 +28432,15 @@ var useDashboard = (dashboardName, config) => {
   const fetchedInitialReports = useRef2(false);
   const backfilledDashboards = useRef2(false);
   const [client] = useContext(ClientContext);
+  const queryClient = useQueryClient();
+  const reportStaleTimeMs = config?.reportStaleTimeMs ?? DEFAULT_DASHBOARD_REPORT_STALE_TIME_MS;
   const { tenants, flags } = useContext(TenantContext);
   const { getToken } = useContext(FetchContext);
   const { customReportFilters, customFiltersLoaded, setCustomFiltersLoaded } = useContext(ReportFiltersContext);
   const { eventTracking } = useContext(EventTrackingContext);
   const { getCacheCab } = useContext(CacheCabContext);
   const reportRequestIds = useRef2({});
+  const reportFetchAbortController = useRef2(null);
   const lastDashboardName = useRef2(null);
   const pendingNameChangeReload = useRef2(false);
   const [loadedDashes, setLoadedDashes] = useState2([]);
@@ -27659,6 +28450,12 @@ var useDashboard = (dashboardName, config) => {
     () => getCacheCab(config?.cacheType),
     [getCacheCab, config?.cacheType]
   );
+  useEffect2(() => {
+    return () => {
+      reportFetchAbortController.current?.abort();
+      reportFetchAbortController.current = null;
+    };
+  }, [dashboardName]);
   useEffect2(() => {
     const nameChanged = dashboardName !== lastDashboardName.current;
     if (nameChanged) {
@@ -27846,8 +28643,52 @@ var useDashboard = (dashboardName, config) => {
     if (!cacheEnabled) return;
     fetchReports([], dashboardFilters ?? [], config?.pageSize, true);
   };
+  const primeReportSource = async (reportId) => {
+    const reportInfo = allReportsById[reportId];
+    if (!reportInfo || !client) {
+      throw new Error(`Could not prime CacheCab for report ${reportId}`);
+    }
+    const dashboardDateFilter = dashboardFilters?.find(
+      (filter) => filter.filterType === "date_range" /* Date */ && filter.startDate && filter.endDate
+    );
+    const dateRange = config?.cacheDateRange ?? (dashboardDateFilter?.startDate && dashboardDateFilter.endDate ? {
+      startDate: new Date(dashboardDateFilter.startDate),
+      endDate: new Date(dashboardDateFilter.endDate)
+    } : void 0);
+    if (!dateRange) {
+      throw new Error(
+        `CacheCab source for report ${reportId} requires a date range`
+      );
+    }
+    await getCacheCab("memory").get(
+      reportId,
+      dashboardFilters ?? [],
+      customReportFilters[reportId] ?? [],
+      null,
+      client,
+      tenants,
+      flags,
+      void 0,
+      getToken,
+      eventTracking,
+      false,
+      {
+        referencedTables: reportInfo.referencedTables ?? [],
+        dateField: reportInfo.dateField,
+        clientId: client.id ?? client.clientId ?? "",
+        databaseType: client.databaseType,
+        tenants,
+        flags,
+        dateRange
+      }
+    );
+  };
   const fetchReports = async (customFilters, dashboardFilters2, pageSize, forceCacheToRefresh = false) => {
     if (!client || !sections) return;
+    reportFetchAbortController.current?.abort();
+    const abortController = new AbortController();
+    reportFetchAbortController.current = abortController;
+    const abortSignal = abortController.signal;
     const allReports = Object.values(sections).flat();
     const fetchStartTime = Date.now();
     let totalCached = 0;
@@ -27916,6 +28757,12 @@ var useDashboard = (dashboardName, config) => {
             eventTracking,
             forceCacheToRefresh
           );
+          const cachedReport = {
+            ...reportInfo,
+            ...report2,
+            id: reportId,
+            pivot: reportInfo.pivot ?? report2.pivot
+          };
           if (reportRequestIds.current[reportId] !== requestId) {
             return null;
           }
@@ -27924,7 +28771,7 @@ var useDashboard = (dashboardName, config) => {
               type: "UPDATE_REPORT",
               id: reportId,
               data: {
-                ...report2,
+                ...cachedReport,
                 pagination,
                 triggerReload: false
               }
@@ -27935,7 +28782,7 @@ var useDashboard = (dashboardName, config) => {
               data: false
             });
             totalCached += 1;
-            return report2;
+            return cachedReport;
           }
         }
         if (cacheEnabled && !cacheCab.isCacheable(reportId)) {
@@ -27958,6 +28805,7 @@ var useDashboard = (dashboardName, config) => {
                   filters: allFilters,
                   getToken,
                   eventTracking,
+                  abortSignal,
                   usePivotTask,
                   overwriteCache: forceCacheToRefresh
                 });
@@ -27997,6 +28845,7 @@ var useDashboard = (dashboardName, config) => {
                 tenants,
                 filters: allFilters,
                 getToken,
+                abortSignal,
                 additionalProcessing,
                 overwriteCache: forceCacheToRefresh
               }).then(({ rows, rowCount, columns, fields }) => {
@@ -28049,7 +28898,32 @@ var useDashboard = (dashboardName, config) => {
             return null;
           }
         }
-        const { report, error } = await fetchReport({
+        const requestFilters = allFilters.map(
+          (filter) => Object.fromEntries(
+            Object.entries(filter).filter(([key]) => key !== "options")
+          )
+        );
+        const queryKey = [
+          "quill",
+          "dashboard-report",
+          reportId,
+          {
+            dashboardName,
+            task: usePivotTask ? "pivot-template" : "report",
+            client: {
+              id: client.id ?? client.clientId,
+              databaseType: client.databaseType,
+              queryEndpoint: client.queryEndpoint,
+              queryHeaders: client.queryHeaders,
+              withCredentials: client.withCredentials
+            },
+            tenants,
+            flags,
+            filters: requestFilters,
+            additionalProcessing: reportAdditionalProcessing
+          }
+        ];
+        const fetchDashboardReport = () => fetchReport({
           reportId,
           client,
           tenants,
@@ -28058,10 +28932,23 @@ var useDashboard = (dashboardName, config) => {
           filters: allFilters,
           getToken,
           eventTracking,
+          abortSignal,
           usePivotTask,
-          overwriteCache: forceCacheToRefresh
-          // usePivotTask: false,
+          overwriteCache: forceCacheToRefresh,
+          shareRequest: !forceCacheToRefresh
         });
+        const result = forceCacheToRefresh ? await fetchDashboardReport() : await queryClient.fetchQuery({
+          queryKey,
+          queryFn: fetchDashboardReport,
+          staleTime: reportStaleTimeMs,
+          gcTime: Math.max(reportStaleTimeMs * 2, 10 * 60 * 1e3)
+        });
+        if (result.error) {
+          queryClient.removeQueries({ queryKey, exact: true });
+        } else if (forceCacheToRefresh) {
+          queryClient.setQueryData(queryKey, result);
+        }
+        const { report, error } = result;
         if (reportRequestIds.current[reportId] !== requestId) {
           return null;
         }
@@ -28093,6 +28980,7 @@ var useDashboard = (dashboardName, config) => {
             tenants,
             filters: allFilters,
             getToken,
+            abortSignal,
             additionalProcessing,
             overwriteCache: forceCacheToRefresh
           }).then(({ rows, rowCount, columns, fields }) => {
@@ -28126,7 +29014,11 @@ var useDashboard = (dashboardName, config) => {
         }
         return report;
       })
-    );
+    ).catch((error) => {
+      if (!(error instanceof Error) || error.name !== "AbortError") {
+        throw error;
+      }
+    });
     if (!loadedDashes.includes(dashboardName) || !cacheEnabled || forceCacheToRefresh) {
       setLoadedDashes(
         (prev) => prev.includes(dashboardName) ? prev : [...prev, dashboardName]
@@ -28147,6 +29039,7 @@ var useDashboard = (dashboardName, config) => {
     applyFilters,
     lastUpdated,
     forceCacheRefresh,
+    primeReportSource,
     reload
   };
 };
@@ -36840,164 +37733,6 @@ function DashboardFilter2({
 // src/Chart.tsx
 init_paginationProcessing();
 
-// src/utils/cloudCacheValidation.ts
-var LIMIT_CLAUSE_REGEX = /^limit\b\s+(?:all|\d+|\$\d+|:[a-zA-Z_][a-zA-Z0-9_]*|\?)/i;
-var SQL_CONTENT_TO_IGNORE_REGEX = /'(?:''|[^'])*'|"(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|--[^\n]*|\/\*[\s\S]*?\*\//g;
-function isWordChar(char) {
-  if (!char) {
-    return false;
-  }
-  return /[A-Za-z0-9_]/.test(char);
-}
-function getFinalSqlStatement(query) {
-  const statements = query.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
-  return statements[statements.length - 1] ?? "";
-}
-function hasTopLevelLimitClause(statement) {
-  let depth = 0;
-  for (let i = 0; i < statement.length; i += 1) {
-    const char = statement[i];
-    if (char === "(") {
-      depth += 1;
-      continue;
-    }
-    if (char === ")") {
-      depth = Math.max(0, depth - 1);
-      continue;
-    }
-    if (depth !== 0) {
-      continue;
-    }
-    const previousChar = i > 0 ? statement[i - 1] : void 0;
-    if (isWordChar(previousChar)) {
-      continue;
-    }
-    if (!LIMIT_CLAUSE_REGEX.test(statement.slice(i))) {
-      continue;
-    }
-    return true;
-  }
-  return false;
-}
-function unwrapIdentifier(identifier) {
-  if (!identifier) {
-    return "";
-  }
-  const trimmed = identifier.trim();
-  if (trimmed.length < 2) {
-    return trimmed;
-  }
-  const startsAndEndsWithDoubleQuote = trimmed.startsWith('"') && trimmed.endsWith('"');
-  const startsAndEndsWithSingleQuote = trimmed.startsWith("'") && trimmed.endsWith("'");
-  const startsAndEndsWithBackticks = trimmed.startsWith("`") && trimmed.endsWith("`");
-  const startsAndEndsWithBrackets = trimmed.startsWith("[") && trimmed.endsWith("]");
-  if (startsAndEndsWithDoubleQuote || startsAndEndsWithSingleQuote || startsAndEndsWithBackticks || startsAndEndsWithBrackets) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-function normalizeIdentifier(identifier) {
-  return unwrapIdentifier(identifier).toLowerCase();
-}
-function hasRowFieldWithIdentifier(row, normalizedField) {
-  if (!row || !normalizedField) {
-    return false;
-  }
-  return Object.keys(row).some(
-    (fieldName) => normalizeIdentifier(fieldName) === normalizedField
-  );
-}
-function reportReferencesField(report, field, table) {
-  const normalizedField = normalizeIdentifier(field);
-  if (!normalizedField) {
-    return false;
-  }
-  const referencedColumns = report?.referencedColumns ?? {};
-  let entries = Object.entries(referencedColumns);
-  if (entries.length === 0) {
-    return false;
-  }
-  const normalizedTable = normalizeIdentifier(table);
-  if (normalizedTable) {
-    entries = entries.filter(
-      ([tableName]) => normalizeIdentifier(tableName) === normalizedTable
-    );
-  }
-  const referencedFields = entries.flatMap(([, fields]) => fields ?? []);
-  if (referencedFields.length === 0) {
-    return false;
-  }
-  return referencedFields.some((referencedField) => {
-    const normalizedReferencedField = normalizeIdentifier(referencedField);
-    return normalizedReferencedField === normalizedField || normalizedReferencedField === "*";
-  });
-}
-function isDateFieldMissingInReport(report) {
-  if (!report?.dateField?.field || !report.dateField.table) {
-    return false;
-  }
-  const dateField = report.dateField;
-  if (!reportReferencesField(report, dateField.field, dateField.table)) {
-    return true;
-  }
-  const firstRow = report.rows?.[0];
-  if (!firstRow) {
-    return false;
-  }
-  const normalizedDateField = normalizeIdentifier(dateField.field);
-  const dateFieldExistsInFirstRow = hasRowFieldWithIdentifier(
-    firstRow,
-    normalizedDateField
-  );
-  return !dateFieldExistsInFirstRow;
-}
-function hasLimitClause(query) {
-  if (!query) {
-    return false;
-  }
-  const sanitizedQuery = query.replace(SQL_CONTENT_TO_IGNORE_REGEX, " ");
-  const finalStatement = getFinalSqlStatement(sanitizedQuery);
-  if (!finalStatement) {
-    return false;
-  }
-  return hasTopLevelLimitClause(finalStatement);
-}
-function reportUsesLimitClause(report) {
-  const queriesToInspect = report?.itemQuery && report.itemQuery.length > 0 ? report.itemQuery : report?.queryString ? [report.queryString] : [];
-  return queriesToInspect.some(hasLimitClause);
-}
-function getMissingDashboardFilterFields({
-  rows = [],
-  dashboardFilters = []
-}) {
-  const dateIndex = dashboardFilters.findIndex(
-    (filter) => filter.filterType === "date_range"
-  );
-  const requiredFields = dashboardFilters.flatMap((filter, index) => {
-    if (index === dateIndex || !filter.field) {
-      return [];
-    }
-    const normalizedField = normalizeIdentifier(filter.field);
-    if (!normalizedField) {
-      return [];
-    }
-    return [
-      {
-        displayField: unwrapIdentifier(filter.field),
-        normalizedField
-      }
-    ];
-  });
-  const dedupedRequiredFields = requiredFields.filter(
-    (field, index, fields) => fields.findIndex(
-      (candidate) => candidate.normalizedField === field.normalizedField
-    ) === index
-  );
-  return dedupedRequiredFields.filter(
-    ({ normalizedField }) => rows.some((row) => !hasRowFieldWithIdentifier(row, normalizedField))
-  ).map(({ displayField }) => displayField);
-}
-
 // src/components/Dashboard/MetricComponent.tsx
 init_dateRangePickerUtils();
 import { useContext as useContext12 } from "react";
@@ -43707,7 +44442,7 @@ function StaticChart(props) {
     pageLoading,
     nextPage,
     prevPage,
-    sortRows: sortRows2
+    sortRows: sortRows3
   } = useDashboardReportInternal(reportId);
   const baseStyle = report?.chartType && CHART_TYPE_STYLES[report.chartType] ? CHART_TYPE_STYLES[report.chartType] : DEFAULT_STYLE;
   const mergedStyle = className ? { ...containerStyle ?? {} } : { ...baseStyle, ...containerStyle ?? {} };
@@ -43727,7 +44462,7 @@ function StaticChart(props) {
     }
   };
   const onSortChange = (sort) => {
-    sortRows2({
+    sortRows3({
       field: sort.field,
       direction: sort.direction
     });
@@ -45154,7 +45889,7 @@ var PivotModal = ({
   setPivotRowField,
   pivotColumnField,
   setPivotColumnField,
-  pivotAggregations,
+  pivotAggregations: pivotAggregations2,
   setPivotAggregations,
   pivotSort,
   setPivotSort,
@@ -45271,18 +46006,18 @@ var PivotModal = ({
     columnField: pivotColumnField,
     columnFieldType: columnTypes[pivotColumnField ?? ""],
     dateBucket: pivotDateBucket,
-    aggregations: pivotAggregations?.map((p) => ({
+    aggregations: pivotAggregations2?.map((p) => ({
       valueField: p.valueField,
       valueFieldType: columnTypes[p.valueField ?? ""],
       valueField2: p.valueField2,
       valueField2Type: columnTypes[p.valueField2 ?? ""],
       aggregationType: p.aggregationType
     })),
-    valueField: pivotAggregations?.[0]?.valueField,
-    valueFieldType: columnTypes[pivotAggregations?.[0]?.valueField ?? ""],
-    valueField2: pivotAggregations?.[0]?.valueField2,
-    valueField2Type: columnTypes[pivotAggregations?.[0]?.valueField2 ?? ""],
-    aggregationType: pivotAggregations?.[0]?.aggregationType
+    valueField: pivotAggregations2?.[0]?.valueField,
+    valueFieldType: columnTypes[pivotAggregations2?.[0]?.valueField ?? ""],
+    valueField2: pivotAggregations2?.[0]?.valueField2,
+    valueField2Type: columnTypes[pivotAggregations2?.[0]?.valueField2 ?? ""],
+    aggregationType: pivotAggregations2?.[0]?.aggregationType
   });
   const getResolvedDateBucket = (pivot) => resolvePivotDateBucket({
     pivot,
@@ -45398,7 +46133,7 @@ var PivotModal = ({
   }, [showUpdatePivot, isOpen]);
   useEffect21(() => {
     const fetchPivotData = async () => {
-      if (pivotRowField && data && columns && pivotAggregations?.every((p) => p?.valueField && p?.aggregationType)) {
+      if (pivotRowField && data && columns && pivotAggregations2?.every((p) => p?.valueField && p?.aggregationType)) {
         const pivot = buildCurrentPivot();
         try {
           const { rows, columns: columns2 } = await generatePivotTable({
@@ -45621,17 +46356,17 @@ var PivotModal = ({
   };
   const onCommitPivot = () => {
     const errors2 = [];
-    if ((pivotAggregations?.length ?? 0) === 0) {
+    if ((pivotAggregations2?.length ?? 0) === 0) {
       errors2.push("You must have at least one aggregation");
     }
-    if (pivotAggregations.some(
+    if (pivotAggregations2.some(
       (p) => !p.valueField && p.aggregationType !== "count" && p.aggregationType !== "percentage"
     )) {
       errors2.push(
         "Value field cannot be empty when aggregation is not 'count' or 'percentage'"
       );
     }
-    if (pivotAggregations.some((p) => !p.aggregationType)) {
+    if (pivotAggregations2.some((p) => !p.aggregationType)) {
       errors2.push("Aggregation cannot be empty");
     }
     if (pivotRowField && !columnsToShow[pivotRowField]) {
@@ -45643,7 +46378,7 @@ var PivotModal = ({
     if (showLimitInput && limitInput && !Number.isInteger(Number(limitInput))) {
       errors2.push("Limit must be an integer");
     }
-    if (errors2.length === 0 && pivotAggregations?.every(
+    if (errors2.length === 0 && pivotAggregations2?.every(
       (p) => p.aggregationType && (p.valueField || p.aggregationType === "count" || p.aggregationType === "percentage")
     )) {
       const sort = showSortInput && !!sortFieldInput && !!sortDirectionInput;
@@ -45987,7 +46722,7 @@ var PivotModal = ({
         setPivotColumnField(void 0);
         setPivotDateBucket(void 0);
         setPivotAggregations(
-          pivotAggregations.map((agg) => {
+          pivotAggregations2.map((agg) => {
             return {
               ...agg,
               aggregationType: agg.aggregationType === "percentage" ? void 0 : agg.aggregationType
@@ -46007,9 +46742,9 @@ var PivotModal = ({
       if (!value && agg.valueField === agg.valueField2) {
         agg.valueField2 = void 0;
         setPivotAggregations([
-          ...pivotAggregations.slice(0, index),
-          { ...pivotAggregations[index], valueField2: void 0 },
-          ...pivotAggregations.slice(index + 1)
+          ...pivotAggregations2.slice(0, index),
+          { ...pivotAggregations2[index], valueField2: void 0 },
+          ...pivotAggregations2.slice(index + 1)
         ]);
       }
     });
@@ -46430,7 +47165,7 @@ var PivotModal = ({
                                               /* @__PURE__ */ jsx66("div", { style: { width: 200 }, children: /* @__PURE__ */ jsx66(SubheaderComponent, { label: "Aggregation Type" }) }),
                                               /* @__PURE__ */ jsx66("div", { style: { width: 200 }, children: /* @__PURE__ */ jsx66(SubheaderComponent, { label: "Value Field" }) })
                                             ] }),
-                                            pivotAggregations?.map((agg, index) => /* @__PURE__ */ jsxs47(PivotRowContainer, { children: [
+                                            pivotAggregations2?.map((agg, index) => /* @__PURE__ */ jsxs47(PivotRowContainer, { children: [
                                               /* @__PURE__ */ jsx66(
                                                 SelectComponent,
                                                 {
@@ -46438,12 +47173,12 @@ var PivotModal = ({
                                                   value: agg.aggregationType ?? "",
                                                   onChange: (e) => {
                                                     const newAgg = [
-                                                      ...pivotAggregations.slice(0, index),
+                                                      ...pivotAggregations2.slice(0, index),
                                                       {
                                                         ...agg,
                                                         aggregationType: e.target.value === "" ? void 0 : e.target.value
                                                       },
-                                                      ...pivotAggregations.slice(index + 1)
+                                                      ...pivotAggregations2.slice(index + 1)
                                                     ];
                                                     pivotFieldChange("aggregations", newAgg);
                                                     setPivotAggregations(newAgg);
@@ -46470,12 +47205,12 @@ var PivotModal = ({
                                                   value: agg.valueField ?? "",
                                                   onChange: (e) => {
                                                     const newAgg = [
-                                                      ...pivotAggregations.slice(0, index),
+                                                      ...pivotAggregations2.slice(0, index),
                                                       {
                                                         ...agg,
                                                         valueField: e.target.value === "" ? void 0 : e.target.value
                                                       },
-                                                      ...pivotAggregations.slice(index + 1)
+                                                      ...pivotAggregations2.slice(index + 1)
                                                     ];
                                                     pivotFieldChange("aggregations", newAgg);
                                                     setPivotAggregations(newAgg);
@@ -46503,8 +47238,8 @@ var PivotModal = ({
                                                     {
                                                       onClick: () => {
                                                         setPivotAggregations([
-                                                          ...pivotAggregations.slice(0, index),
-                                                          ...pivotAggregations.slice(index + 1)
+                                                          ...pivotAggregations2.slice(0, index),
+                                                          ...pivotAggregations2.slice(index + 1)
                                                         ]);
                                                       }
                                                     }
@@ -46531,7 +47266,7 @@ var PivotModal = ({
                                             label: "Add Aggregation",
                                             onClick: () => {
                                               setPivotAggregations([
-                                                ...pivotAggregations,
+                                                ...pivotAggregations2,
                                                 {
                                                   aggregationType: void 0,
                                                   valueField: void 0,
@@ -46765,7 +47500,7 @@ var PivotModal = ({
                                     label: "Save",
                                     disabled: showSortInput && (!sortFieldInput || !(samplePivotTable?.columns ?? []).some(
                                       (c) => c.field === sortFieldInput
-                                    ) || !sortDirectionInput) || !(pivotAggregations?.length > 0) || pivotAggregations.some(
+                                    ) || !sortDirectionInput) || !(pivotAggregations2?.length > 0) || pivotAggregations2.some(
                                       (agg) => !agg.aggregationType || !agg.valueField && agg.aggregationType !== "count" && (agg.aggregationType !== "percentage" || !pivotRowField || pivotColumnField)
                                     )
                                   }
@@ -48747,7 +49482,7 @@ function ChartBuilder({
   const [pivotColumnField, setPivotColumnField] = useState31(
     report?.pivot?.columnField
   );
-  const [pivotAggregations, setPivotAggregations] = useState31(
+  const [pivotAggregations2, setPivotAggregations] = useState31(
     report?.pivot?.aggregations ?? [
       {
         valueField: report?.pivot?.valueField,
@@ -50558,7 +51293,7 @@ function ChartBuilder({
                                       setPivotRowField,
                                       pivotColumnField,
                                       setPivotColumnField,
-                                      pivotAggregations,
+                                      pivotAggregations: pivotAggregations2,
                                       pivotSort,
                                       setPivotSort,
                                       pivotLimit,
@@ -54203,7 +54938,7 @@ var useReportBuilderInternal = ({
   const [pivotColumnField, setPivotColumnField] = useState34(
     void 0
   );
-  const [pivotAggregations, setPivotAggregations] = useState34([]);
+  const [pivotAggregations2, setPivotAggregations] = useState34([]);
   const [pivotDateBucket, setPivotDateBucket] = useState34(void 0);
   const [pivotLimit, setPivotLimit] = useState34(void 0);
   const [pivotSort, setPivotSort] = useState34(void 0);
@@ -54531,7 +55266,7 @@ var useReportBuilderInternal = ({
       if (changeField === "" || changeField === void 0) {
         setPivotColumnField(void 0);
         setPivotAggregations(
-          pivotAggregations.map((agg) => ({
+          pivotAggregations2.map((agg) => ({
             ...agg,
             aggregationType: agg.aggregationType === "percentage" ? void 0 : agg.aggregationType
           }))
@@ -55447,7 +56182,7 @@ var useReportBuilderInternal = ({
     pivotData,
     pivotRowField,
     pivotColumnField,
-    pivotAggregations,
+    pivotAggregations: pivotAggregations2,
     pivotLimit,
     pivotSort,
     pivotDateBucket,
@@ -56588,7 +57323,7 @@ function PivotForm({
   setPivotRowField,
   pivotColumnField,
   setPivotColumnField,
-  pivotAggregations,
+  pivotAggregations: pivotAggregations2,
   setPivotAggregations,
   pivotLimit,
   setPivotLimit,
@@ -56697,7 +57432,7 @@ function PivotForm({
           gap: 24
         },
         children: [
-          pivotAggregations.map((pivotAggregation, index) => /* @__PURE__ */ jsxs56(
+          pivotAggregations2.map((pivotAggregation, index) => /* @__PURE__ */ jsxs56(
             "div",
             {
               style: {
@@ -56724,12 +57459,12 @@ function PivotForm({
                           value: pivotAggregation.aggregationType,
                           onChange: (e) => {
                             setPivotAggregations([
-                              ...pivotAggregations.slice(0, index),
+                              ...pivotAggregations2.slice(0, index),
                               {
-                                ...pivotAggregations[index],
+                                ...pivotAggregations2[index],
                                 aggregationType: e.target.value === "" ? void 0 : e.target.value
                               },
-                              ...pivotAggregations.slice(index + 1)
+                              ...pivotAggregations2.slice(index + 1)
                             ]);
                           },
                           options: [
@@ -56755,12 +57490,12 @@ function PivotForm({
                           value: pivotAggregation.valueField,
                           onChange: (e) => {
                             setPivotAggregations([
-                              ...pivotAggregations.slice(0, index),
+                              ...pivotAggregations2.slice(0, index),
                               {
-                                ...pivotAggregations[index],
+                                ...pivotAggregations2[index],
                                 valueField: e.target.value === "" ? void 0 : e.target.value
                               },
-                              ...pivotAggregations.slice(index + 1)
+                              ...pivotAggregations2.slice(index + 1)
                             ]);
                           },
                           isLoading: uniqueValuesIsLoading,
@@ -56783,8 +57518,8 @@ function PivotForm({
                   {
                     onClick: () => {
                       setPivotAggregations([
-                        ...pivotAggregations.slice(0, index),
-                        ...pivotAggregations.slice(index + 1)
+                        ...pivotAggregations2.slice(0, index),
+                        ...pivotAggregations2.slice(index + 1)
                       ]);
                     }
                   }
@@ -56798,7 +57533,7 @@ function PivotForm({
             {
               onClick: () => {
                 setPivotAggregations([
-                  ...pivotAggregations,
+                  ...pivotAggregations2,
                   {
                     valueField: void 0,
                     aggregationType: void 0
@@ -58844,7 +59579,7 @@ function ChartEditor({
 }
 
 // src/Chat.tsx
-import { useContext as useContext37, useEffect as useEffect32, useRef as useRef25, useState as useState42 } from "react";
+import { useContext as useContext37, useEffect as useEffect33, useRef as useRef25, useState as useState43 } from "react";
 
 // src/ChatChartCard.tsx
 import { useMemo as useMemo34 } from "react";
@@ -58855,14 +59590,19 @@ init_ReportBuilder();
 import {
   useCallback as useCallback5,
   useContext as useContext36,
-  useEffect as useEffect31,
+  useEffect as useEffect32,
   useLayoutEffect as useLayoutEffect4,
   useMemo as useMemo33,
   useReducer as useReducer2,
   useRef as useRef24,
-  useState as useState41
+  useState as useState42
 } from "react";
-import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
+import {
+  keepPreviousData,
+  useMutation,
+  useQuery,
+  useQueryClient as useQueryClient2
+} from "@tanstack/react-query";
 init_util();
 init_columnType();
 init_columnProcessing();
@@ -60046,6 +60786,20 @@ function useFormReducer(state, action) {
   }
 }
 
+// src/hooks/useForm.refreshDebounce.ts
+import { useEffect as useEffect31, useState as useState41 } from "react";
+var REPORT_REFRESH_DEBOUNCE_MS = 200;
+function useDebouncedRefreshInput(value, delayMs = REPORT_REFRESH_DEBOUNCE_MS) {
+  const [debouncedValue, setDebouncedValue] = useState41(value);
+  useEffect31(() => {
+    const timeout = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delayMs);
+    return () => clearTimeout(timeout);
+  }, [delayMs, value]);
+  return debouncedValue;
+}
+
 // src/utils/pivotDateBuckets.ts
 import {
   eachDayOfInterval as eachDayOfInterval3,
@@ -60077,10 +60831,252 @@ function buildPivotDateBucketStarts(range, bucket) {
   );
 }
 
+// src/utils/cacheCabReportResolver.ts
+init_inMemoryPivotEngine();
+var availableRowKeys = (report) => {
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of report.rows?.slice(0, 10) ?? []) {
+    Object.keys(row).forEach((key) => keys.add(key));
+  }
+  for (const column of report.columnInternal ?? []) {
+    if (column.field) keys.add(column.field);
+  }
+  for (const column of report.reportBuilderState?.columns ?? []) {
+    if (column.field) keys.add(column.field);
+    if (column.alias) keys.add(column.alias);
+  }
+  return keys;
+};
+var createFieldResolver = (report) => {
+  const keys = availableRowKeys(report);
+  return (field, table) => {
+    const matchingColumns = (report.reportBuilderState?.columns ?? []).filter(
+      (column) => column.field === field && (!table || !column.table || column.table === table)
+    );
+    const candidates = [
+      ...matchingColumns.map((column) => column.alias).filter(Boolean),
+      field,
+      table ? `${table}.${field}` : void 0,
+      table ? `${table}__${field}` : void 0,
+      table ? `${table}_${field}` : void 0
+    ].filter((candidate) => Boolean(candidate));
+    return candidates.find((candidate) => keys.has(candidate));
+  };
+};
+var pivotAggregations = (pivot) => pivot.aggregations ?? (pivot.aggregationType ? [
+  {
+    aggregationType: pivot.aggregationType,
+    valueField: pivot.valueField,
+    valueField2: pivot.valueField2,
+    valueFieldType: pivot.valueFieldType,
+    valueField2Type: pivot.valueField2Type
+  }
+] : []);
+var resolvePivot = (pivot, resolveField) => {
+  const rowField = pivot.rowField ? resolveField(pivot.rowField, pivot.rowFieldTable) : void 0;
+  const columnField = pivot.columnField ? resolveField(pivot.columnField, pivot.columnFieldTable) : void 0;
+  if (pivot.rowField && !rowField || pivot.columnField && !columnField) {
+    return null;
+  }
+  const aggregations = pivotAggregations(pivot).map((aggregation) => ({
+    ...aggregation,
+    valueField: aggregation.valueField ? resolveField(aggregation.valueField, aggregation.valueFieldTable) : void 0,
+    valueField2: aggregation.valueField2 ? resolveField(aggregation.valueField2, aggregation.valueFieldTable) : void 0
+  }));
+  if (aggregations.some(
+    (aggregation, index) => pivotAggregations(pivot)[index]?.valueField && !aggregation.valueField || pivotAggregations(pivot)[index]?.valueField2 && !aggregation.valueField2
+  )) {
+    return null;
+  }
+  return {
+    ...pivot,
+    rowField,
+    columnField,
+    aggregations,
+    aggregationType: void 0,
+    valueField: void 0,
+    valueField2: void 0,
+    valueFieldType: void 0,
+    valueField2Type: void 0
+  };
+};
+var sortRows2 = (rows, state, resolveField) => {
+  if (!state.sort.length) return rows;
+  return [...rows].sort((left, right) => {
+    for (const sort of state.sort) {
+      const key = resolveField(sort.field);
+      if (!key) continue;
+      const a = left[key];
+      const b = right[key];
+      if (a === b) continue;
+      const comparison = a == null ? -1 : b == null ? 1 : a < b ? -1 : 1;
+      return sort.direction.toLowerCase() === "desc" ? -comparison : comparison;
+    }
+    return 0;
+  });
+};
+var buildUniqueValues = (report, resolveField) => {
+  const result = {};
+  const stringColumns = (report.columnInternal ?? []).filter(
+    (column) => column.jsType === "string" || /char|text|string|uuid/i.test(column.fieldType ?? "")
+  );
+  for (const column of stringColumns) {
+    const table = column.table ?? "";
+    const key = resolveField(column.field, column.table);
+    if (!key) continue;
+    const values = /* @__PURE__ */ new Set();
+    for (const row of report.rows ?? []) {
+      const value = row[key];
+      if (value !== null && value !== void 0) values.add(String(value));
+    }
+    result[table] ??= {};
+    result[table][column.field] = [...values].sort();
+  }
+  return result;
+};
+function resolveReportFromCacheCab({
+  snapshot,
+  reportBuilderState,
+  filters,
+  pivot = reportBuilderState?.pivot ?? null,
+  operation = "table",
+  rowLimit
+}) {
+  if (!snapshot) return { resolved: false, reason: "cache_miss" };
+  if (!snapshot.complete) {
+    return {
+      resolved: false,
+      reason: "incomplete_cache",
+      details: { snapshotReason: snapshot.reason }
+    };
+  }
+  const state = reportBuilderState ?? snapshot.report.reportBuilderState;
+  if (!state) return { resolved: false, reason: "missing_builder_state" };
+  const resolveField = createFieldResolver(snapshot.report);
+  const missingFields = [];
+  state.columns.forEach((column) => {
+    if (!resolveField(column.field, column.table)) {
+      missingFields.push({
+        role: "column",
+        field: column.field,
+        table: column.table
+      });
+    }
+  });
+  filters.forEach((filter) => {
+    if (filter.field && !resolveField(filter.field, filter.table)) {
+      missingFields.push({
+        role: "filter",
+        field: filter.field,
+        table: filter.table
+      });
+    }
+  });
+  if (pivot?.rowField && !resolveField(pivot.rowField, pivot.rowFieldTable)) {
+    missingFields.push({
+      role: "pivot-row",
+      field: pivot.rowField,
+      table: pivot.rowFieldTable
+    });
+  }
+  if (pivot?.columnField && !resolveField(pivot.columnField, pivot.columnFieldTable)) {
+    missingFields.push({
+      role: "pivot-column",
+      field: pivot.columnField,
+      table: pivot.columnFieldTable
+    });
+  }
+  if (pivot) {
+    pivotAggregations(pivot).forEach((aggregation) => {
+      [
+        [aggregation.valueField, aggregation.valueFieldTable],
+        [aggregation.valueField2, aggregation.valueFieldTable]
+      ].forEach(([field, table]) => {
+        if (field && !resolveField(field, table)) {
+          missingFields.push({
+            role: "aggregation",
+            field,
+            table
+          });
+        }
+      });
+    });
+  }
+  const resolvedPivot = pivot ? resolvePivot(pivot, resolveField) : null;
+  if (missingFields.length > 0 || pivot && !resolvedPivot) {
+    return {
+      resolved: false,
+      reason: "missing_field",
+      details: { missingFields }
+    };
+  }
+  const filteredRows = applyFiltersInMemory(
+    snapshot.report.rows ?? [],
+    filters,
+    {
+      columns: snapshot.report.columnInternal,
+      fieldKeyResolver: resolveField
+    }
+  );
+  const sortedRows = operation === "unique-values" ? [] : sortRows2(filteredRows, state, resolveField);
+  const effectiveRowLimit = Math.min(
+    state.limit?.value ?? Number.MAX_SAFE_INTEGER,
+    rowLimit ?? Number.MAX_SAFE_INTEGER
+  );
+  const limitedRows = sortedRows.length > effectiveRowLimit ? sortedRows.slice(0, effectiveRowLimit) : sortedRows;
+  const pivotRows = resolvedPivot ? applyPivotInMemory(filteredRows, resolvedPivot, filters) : void 0;
+  const pivotColumns = resolvedPivot ? generatePivotColumnsInMemory({
+    pivot: resolvedPivot,
+    pivotRows: pivotRows ?? [],
+    sourceColumns: snapshot.report.columnInternal
+  }) : void 0;
+  const requestedRowField = pivot?.rowField;
+  const resolvedRowField = resolvedPivot?.rowField;
+  const normalizedPivotRows = requestedRowField && resolvedRowField && requestedRowField !== resolvedRowField ? pivotRows?.map((row) => ({
+    ...row,
+    [requestedRowField]: row[resolvedRowField]
+  })) : pivotRows;
+  const normalizedPivotColumns = pivotColumns?.map(
+    (column) => requestedRowField && resolvedRowField && column.field === resolvedRowField ? { ...column, field: requestedRowField } : column
+  );
+  return {
+    resolved: true,
+    report: {
+      ...snapshot.report,
+      rows: limitedRows,
+      rowCount: filteredRows.length,
+      reportBuilderState: { ...state, pivot },
+      pivot,
+      pivotRows: normalizedPivotRows,
+      pivotColumns: normalizedPivotColumns,
+      pivotRowCount: normalizedPivotRows?.length,
+      pivotResultRowField: requestedRowField,
+      pivotResultSourceRowField: requestedRowField,
+      ...operation === "unique-values" ? {
+        uniqueStringsByTable: buildUniqueValues(
+          snapshot.report,
+          resolveField
+        )
+      } : {},
+      filtersApplied: filters
+    }
+  };
+}
+
 // src/hooks/useForm.queries.ts
 var QUERY_KEY_UNDEFINED = "__undefined__";
 var QUERY_KEY_FUNCTION = "__function__";
 var QUERY_KEY_BIGINT = "__bigint__";
+function createFilterUniqueValuesReportBuilderState(source, columns) {
+  return {
+    tables: source.tables,
+    columns,
+    filterStack: [],
+    pivot: null,
+    sort: [],
+    limit: null
+  };
+}
 function stableSerializeForQueryKey(value) {
   try {
     return JSON.stringify(value, (_key, nestedValue) => {
@@ -60141,6 +61137,7 @@ function createUseFormPivotTableDataRefreshQueryKey(input) {
     "pivot-table-data-refresh",
     input.reportId,
     input.reportBuilderStateHash,
+    input.pageSize,
     input.tenantHash,
     input.clientHash
   ];
@@ -60167,13 +61164,36 @@ function createUseFormReportNameQueryKey(input) {
   ];
 }
 function createUseFormQueryFn(loader) {
-  return async () => loader();
+  return ({ signal }) => loader(signal);
 }
 
 // src/hooks/useForm.pagination.ts
 var DEFAULT_PAGE_INDEX = 0;
 var DEFAULT_PAGE_SIZE = 10;
-var DEFAULT_USE_REPORT_ROWS_PER_REQUEST = DEFAULT_PAGE_SIZE * 10;
+var DEFAULT_USE_REPORT_ROWS_PER_REQUEST = DEFAULT_PAGE_SIZE;
+var isBareIdentifier = (value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+function getStablePaginationSort({
+  columns,
+  sort
+}) {
+  const outputColumns = (columns ?? []).map((column) => {
+    const field2 = String(column.field ?? "").trim();
+    const alias = String(column.alias ?? "").trim();
+    const outputField = isBareIdentifier(alias) ? alias : isBareIdentifier(field2) ? field2 : "";
+    return { field: field2, alias, outputField };
+  }).filter((column) => column.outputField);
+  const requestedSort = sort?.[0];
+  const requestedField = String(requestedSort?.field ?? "").trim();
+  const matchedColumn = requestedField ? outputColumns.find(
+    (column) => column.field === requestedField || column.alias === requestedField
+  ) : void 0;
+  const field = matchedColumn?.outputField ?? outputColumns[0]?.outputField;
+  if (!field) return void 0;
+  return {
+    field,
+    direction: String(requestedSort?.direction ?? "ASC").toUpperCase() === "DESC" ? "DESC" : "ASC"
+  };
+}
 function getDefaultPaginationState() {
   return { pageIndex: DEFAULT_PAGE_INDEX, pageSize: DEFAULT_PAGE_SIZE };
 }
@@ -60323,11 +61343,11 @@ var isMultiValueOperator = (operator) => {
 };
 var collectSelectedStringMultiselectValuesByField = (group) => {
   const out = /* @__PURE__ */ new Map();
-  const visit = (entries) => {
-    if (!entries) {
+  const visit = (entries2) => {
+    if (!entries2) {
       return;
     }
-    for (const entry of entries) {
+    for (const entry of entries2) {
       if (!entry || typeof entry === "string") {
         continue;
       }
@@ -60525,11 +61545,11 @@ var cloneQueryBuilderRuleGroup = (group) => JSON.parse(JSON.stringify(group));
 var canonicalizeMultiselectStringRulesToOptionValues = (group, optionsByField, configByName) => {
   const next = cloneQueryBuilderRuleGroup(group);
   let changed = false;
-  const visit = (entries) => {
-    if (!entries) {
+  const visit = (entries2) => {
+    if (!entries2) {
       return;
     }
-    for (const entry of entries) {
+    for (const entry of entries2) {
       if (!entry || typeof entry === "string") {
         continue;
       }
@@ -62894,15 +63914,17 @@ async function loadViaInMemoryEngines({
   pivot,
   reportBuilderState,
   allowReportTaskBootstrap = false,
-  draftSessionId
+  draftSessionId,
+  shareInitialRequest = false,
+  abortSignal
 }) {
   const requestedTask = allowReportTaskBootstrap ? "report" : "item";
-  const additionalProcessing = allowReportTaskBootstrap ? {
+  const additionalProcessing = {
     page: {
       ...DEFAULT_PAGINATION,
       rowsPerRequest: DEFAULT_USE_REPORT_ROWS_PER_REQUEST
     }
-  } : {};
+  };
   const { report, error } = await fetchReport({
     reportId,
     client,
@@ -62916,7 +63938,9 @@ async function loadViaInMemoryEngines({
     usePivotTask: false,
     pivot,
     reportBuilderState,
-    draftSessionId
+    draftSessionId,
+    shareRequest: shareInitialRequest,
+    abortSignal
   });
   if (error || !report) {
     return { report: null, error };
@@ -62982,7 +64006,9 @@ async function loadViaPivotTemplate({
   reportBuilderState,
   baseReport,
   schema,
-  draftSessionId
+  draftSessionId,
+  shareInitialRequest = false,
+  abortSignal
 }) {
   const pivotForTemplate = enrichPivotRowFieldTypeForTemplate(
     pivot,
@@ -63002,6 +64028,8 @@ async function loadViaPivotTemplate({
     reportBuilderState,
     baseReport,
     draftSessionId,
+    shareRequest: shareInitialRequest,
+    abortSignal,
     responseSelection: baseReport ? {
       includeRows: false,
       includeColumns: false,
@@ -63020,7 +64048,8 @@ async function fetchReportBuilderStateByReportId({
   client,
   getToken,
   draftSessionId,
-  tenants
+  tenants,
+  abortSignal
 }) {
   try {
     const { data, error, status } = await quillFetch({
@@ -63031,7 +64060,8 @@ async function fetchReportBuilderStateByReportId({
         tenants,
         ...draftSessionId ? { draftSessionId: String(draftSessionId).trim() } : {}
       },
-      getToken
+      getToken,
+      abortSignal
     });
     if (error || status === "error") {
       return null;
@@ -63043,6 +64073,9 @@ async function fetchReportBuilderStateByReportId({
     const parsedState = state;
     return parsedState;
   } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw error;
+    }
     return null;
   }
 }
@@ -63104,7 +64137,8 @@ async function fetchUniqueValuesFromTables({
   customFields,
   tenants,
   dashboardName,
-  getToken
+  getToken,
+  abortSignal
 }) {
   const normalizedTables = Array.from(
     new Set(
@@ -63121,6 +64155,9 @@ async function fetchUniqueValuesFromTables({
   }
   const fetchResults = await Promise.all(
     normalizedTables.map(async (tableName) => {
+      if (abortSignal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
       const tableColumns = stringColumnsByTable.filter((column) => {
         return String(column.table ?? "").trim() === tableName;
       });
@@ -63153,7 +64190,8 @@ async function fetchUniqueValuesFromTables({
         client,
         task: "report-builder-unique-values",
         metadata: requestMetadata,
-        getToken
+        getToken,
+        abortSignal
       });
       const responseData = fetchResult?.data;
       const responseRows = Array.isArray(responseData?.rows) && responseData.rows || Array.isArray(fetchResult?.queries?.queryResults?.[0]?.rows) && fetchResult.queries.queryResults[0].rows || [];
@@ -63216,7 +64254,9 @@ async function loadPivotTemplateInParallelWithReportTask({
   customFields,
   dashboardName,
   pivotRefreshOnly = false,
-  draftSessionId
+  draftSessionId,
+  shareInitialRequest = false,
+  abortSignal
 }) {
   if (pivotRefreshOnly) {
     const pivotOnlyResult = await loadViaPivotTemplate({
@@ -63230,7 +64270,9 @@ async function loadPivotTemplateInParallelWithReportTask({
       reportBuilderState,
       baseReport,
       schema,
-      draftSessionId
+      draftSessionId,
+      shareInitialRequest,
+      abortSignal
     });
     return pivotOnlyResult;
   }
@@ -63245,7 +64287,9 @@ async function loadPivotTemplateInParallelWithReportTask({
       pivot,
       reportBuilderState,
       allowReportTaskBootstrap: true,
-      draftSessionId
+      draftSessionId,
+      shareInitialRequest,
+      abortSignal
     }),
     loadViaPivotTemplate({
       reportId,
@@ -63258,14 +64302,17 @@ async function loadPivotTemplateInParallelWithReportTask({
       reportBuilderState,
       baseReport,
       schema,
-      draftSessionId
+      draftSessionId,
+      shareInitialRequest,
+      abortSignal
     }),
     fetchReportBuilderStateByReportId({
       reportId,
       client,
       getToken,
       draftSessionId,
-      tenants
+      tenants,
+      abortSignal
     })
   ]);
   const withFetchedReportBuilderState = (result) => applyFetchedReportBuilderState(result, fetchedReportBuilderState);
@@ -63300,7 +64347,8 @@ async function loadPivotTemplateInParallelWithReportTask({
       customFields,
       dashboardName: String(dashboardName ?? "").trim(),
       report: baseReport,
-      draftSessionId
+      draftSessionId,
+      abortSignal
     });
     if (reportBuilderStateFallbackResult.report && !reportBuilderStateFallbackResult.error) {
       return withFetchedReportBuilderState(reportBuilderStateFallbackResult);
@@ -63330,7 +64378,8 @@ async function loadViaReportBuilderState({
   pagination,
   paginationSort,
   rowsOnly,
-  rowCountOnly
+  rowCountOnly,
+  abortSignal
 }) {
   const baseReport = {
     ...EMPTY_INTERNAL_REPORT,
@@ -63369,7 +64418,8 @@ async function loadViaReportBuilderState({
     dashboardName,
     getToken,
     eventTracking: null,
-    draftSessionId
+    draftSessionId,
+    abortSignal
   });
   if (!reportBuilderInfo) {
     return {
@@ -63450,7 +64500,9 @@ async function loadReportForUseForm({
   dashboardName,
   useInMemoryEngines,
   draftSessionId,
-  rowsOnly = false
+  shareInitialRequest = false,
+  rowsOnly = false,
+  abortSignal
 }) {
   const effectivePivot = pivot ?? initialReportBuilderState?.pivot ?? void 0;
   const hasPivot = Boolean(effectivePivot);
@@ -63473,7 +64525,9 @@ async function loadReportForUseForm({
       customFields,
       dashboardName,
       pivotRefreshOnly: includeReportBuilderStateInPivotTask,
-      draftSessionId
+      draftSessionId,
+      shareInitialRequest,
+      abortSignal
     });
     const pivotRows = pivotResult.report?.pivotRows;
     const rowField = pivotResult.report?.pivotResultRowField ?? effectivePivot?.rowField;
@@ -63496,7 +64550,8 @@ async function loadReportForUseForm({
         customFields,
         dashboardName,
         report: baseReport ?? void 0,
-        draftSessionId
+        draftSessionId,
+        abortSignal
       });
       const rbPivotRows = rbResult.report?.pivotRows;
       const rbEmpty = !Array.isArray(rbPivotRows) || rbPivotRows.length === 0;
@@ -63521,7 +64576,9 @@ async function loadReportForUseForm({
         schema,
         customFields,
         dashboardName,
-        draftSessionId
+        draftSessionId,
+        shareInitialRequest,
+        abortSignal
       });
       const normalizedBootstrapResult = bootstrapResult.report?.pivot == null ? stripPivotFromResult(bootstrapResult) : bootstrapResult;
       return normalizedBootstrapResult;
@@ -63535,7 +64592,9 @@ async function loadReportForUseForm({
       tenants,
       flags,
       allowReportTaskBootstrap: shouldUseReportTaskForReload,
-      draftSessionId
+      draftSessionId,
+      shareInitialRequest,
+      abortSignal
     });
   }
   return loadViaReportBuilderState({
@@ -63549,7 +64608,8 @@ async function loadReportForUseForm({
     dashboardName,
     report: baseReport,
     draftSessionId,
-    rowsOnly
+    rowsOnly,
+    abortSignal
   });
 }
 function generateDraftSessionId() {
@@ -63557,10 +64617,10 @@ function generateDraftSessionId() {
 }
 function useReport(reportIdArg, options = {}) {
   const propReportId = String(reportIdArg ?? "").trim();
-  const [createdReportBootstrap, setCreatedReportBootstrap] = useState41(null);
+  const [createdReportBootstrap, setCreatedReportBootstrap] = useState42(null);
   const effectiveReportId = propReportId || createdReportBootstrap?.reportId || "";
   const { eventTracking } = useContext36(EventTrackingContext);
-  const [draftSessionId, setDraftSessionId] = useState41(generateDraftSessionId);
+  const [draftSessionId, setDraftSessionId] = useState42(generateDraftSessionId);
   const useInMemoryEngines = options.useInMemoryEngines ?? false;
   const dateBucketMode = options.dateBucketMode ?? "dynamic";
   const restrictFieldOptionsToSelectedDatasources = options.restrictFieldOptionsToSelectedDatasources ?? true;
@@ -63574,16 +64634,10 @@ function useReport(reportIdArg, options = {}) {
     ...getDefaultPaginationState(),
     ...options.initialState?.pagination ?? {}
   });
-  const [internalPagination, setInternalPagination] = useState41(
+  const [internalPagination, setInternalPagination] = useState42(
     initialPaginationRef.current
   );
-  const [paginationInteracted, setPaginationInteracted] = useState41(
-    () => Boolean(
-      options.state?.pagination || options.initialState?.pagination || options.onPaginationChange
-    )
-  );
   const pagination = controlledPagination ?? internalPagination;
-  const paginationActive = paginationInteracted || Boolean(controlledPagination);
   const paginationRef = useRef24(pagination);
   paginationRef.current = pagination;
   const onPaginationChangeRef = useRef24(options.onPaginationChange);
@@ -63594,10 +64648,7 @@ function useReport(reportIdArg, options = {}) {
   autoResetPageIndexRef.current = options.autoResetPageIndex ?? true;
   const paginationPageCountRef = useRef24(-1);
   const applyPaginationUpdate = useCallback5(
-    (updater, { activate = true } = {}) => {
-      if (activate) {
-        setPaginationInteracted(true);
-      }
+    (updater) => {
       onPaginationChangeRef.current?.(updater);
       if (!controlledPaginationRef.current) {
         setInternalPagination((old) => functionalUpdate(updater, old));
@@ -63676,13 +64727,13 @@ function useReport(reportIdArg, options = {}) {
     dateBucketSetViaSetReportRef.current = false;
     aggregationStateSetViaSetReportRef.current = false;
   }
-  const [chartPivotHydrationEpoch, setChartPivotHydrationEpoch] = useState41(0);
+  const [chartPivotHydrationEpoch, setChartPivotHydrationEpoch] = useState42(0);
   const [
     expandReportBuilderColumnsForFlatTable,
     setExpandReportBuilderColumnsForFlatTable
-  ] = useState41(false);
+  ] = useState42(false);
   const prevPivotStateForColumnExpansionRef = useRef24(null);
-  const [sourceReport, setSourceReport] = useState41(
+  const [sourceReport, setSourceReport] = useState42(
     null
   );
   const prevSourceReportIdForPivotHydrationRef = useRef24(null);
@@ -63697,18 +64748,21 @@ function useReport(reportIdArg, options = {}) {
       lastPivotHydrateCompletedSourceIdRef.current = null;
     }
   }
-  const [preserveSchemaWideOptions, setPreserveSchemaWideOptions] = useState41(false);
-  const [initialSchemaScopedTableNames, setInitialSchemaScopedTableNames] = useState41(null);
-  const [tableColumnsEditedSignature, setTableColumnsEditedSignature] = useState41(null);
-  useEffect31(() => {
+  const [preserveSchemaWideOptions, setPreserveSchemaWideOptions] = useState42(false);
+  const [initialSchemaScopedTableNames, setInitialSchemaScopedTableNames] = useState42(null);
+  const [tableColumnsEditedSignature, setTableColumnsEditedSignature] = useState42(null);
+  useEffect32(() => {
     setTableColumnsEditedSignature(null);
   }, [effectiveReportId]);
-  const [chartAxisEdits, setChartAxisEdits] = useState41({});
-  const [chartVisibilityOverrides, setChartVisibilityOverrides] = useState41({});
+  const [chartAxisEdits, setChartAxisEdits] = useState42({});
+  const [chartVisibilityOverrides, setChartVisibilityOverrides] = useState42({});
   const [client] = useContext36(ClientContext);
+  const queryClient = useQueryClient2();
   const [schemaData] = useContext36(SchemaDataContext);
   const { tenants, flags } = useContext36(TenantContext);
   const { getToken } = useContext36(FetchContext);
+  const { getCacheCab } = useContext36(CacheCabContext);
+  const cacheCab = useMemo33(() => getCacheCab(), [getCacheCab]);
   const clientDefaultDashboardName = String(
     client?.defaultDashboard?.name ?? ""
   ).trim();
@@ -63824,16 +64878,17 @@ function useReport(reportIdArg, options = {}) {
   filterStackRef.current = filterStack;
   const resolvedGroupRowsBy = decodePivotGroupOptionValue(groupRowsBy);
   const resolvedGroupColumnsBy = decodePivotGroupOptionValue(groupColumnsBy);
-  useEffect31(() => {
+  useEffect32(() => {
     if (propReportId) {
       setCreatedReportBootstrap(null);
     }
   }, [propReportId]);
-  useEffect31(() => {
+  useEffect32(() => {
     setChartAxisEdits({});
     setChartVisibilityOverrides({});
   }, [effectiveReportId]);
   const bootstrapReportTaskUsedForReportIdRef = useRef24(null);
+  const sharedInitialRequestUsedForReportIdRef = useRef24(null);
   const schemaScopeInitializedForReportIdRef = useRef24(null);
   const initializeSchemaScopeForReport = (report) => {
     if (!report) return;
@@ -63855,6 +64910,55 @@ function useReport(reportIdArg, options = {}) {
     () => customFiltersFromFilterStack(filterStack),
     [filterStack]
   );
+  const forceIncompleteCacheCabForParity = process.env.NODE_ENV === "test" && process.env.QUILL_FORCE_INCOMPLETE_CACHECAB_FOR_PARITY === "true";
+  const resolveCachedReport = useCallback5(
+    async ({
+      reportBuilderState,
+      filters,
+      pivot,
+      operation
+    }) => {
+      const startedAt = performance.now();
+      const snapshot = await cacheCab.getReportSnapshot(
+        effectiveReportId,
+        tenants
+      );
+      const state = reportBuilderState ?? snapshot?.report.reportBuilderState;
+      const resolution = resolveReportFromCacheCab({
+        snapshot: snapshot && forceIncompleteCacheCabForParity ? { ...snapshot, complete: true, reason: "complete" } : snapshot,
+        reportBuilderState: state,
+        filters: filters ?? customFiltersFromFilterStack(state?.filterStack ?? []),
+        pivot,
+        operation,
+        rowLimit: operation === "unique-values" ? void 0 : Math.max(
+          DEFAULT_USE_REPORT_ROWS_PER_REQUEST,
+          pagination.pageSize
+        )
+      });
+      const diagnostics = globalThis.__QUILL_CACHECAB_DIAGNOSTICS__;
+      if (Array.isArray(diagnostics)) {
+        diagnostics.push({
+          reportId: effectiveReportId,
+          operation,
+          outcome: resolution.resolved ? "hit" : "fallback",
+          reason: resolution.resolved ? "complete" : resolution.reason,
+          details: resolution.resolved ? void 0 : resolution.details,
+          snapshotReason: snapshot?.reason ?? "cache_miss",
+          forcedIncompleteSnapshot: Boolean(snapshot) && !snapshot?.complete && forceIncompleteCacheCabForParity,
+          rowCount: snapshot?.rowCount ?? 0,
+          durationMs: performance.now() - startedAt
+        });
+      }
+      return resolution.resolved ? resolution.report : null;
+    },
+    [
+      cacheCab,
+      effectiveReportId,
+      forceIncompleteCacheCabForParity,
+      pagination.pageSize,
+      tenants
+    ]
+  );
   const reloadKey = useMemo33(() => 0, []);
   const schemaForReportBuilderState = useMemo33(() => {
     if (schemaData.schemaWithCustomFields?.length) {
@@ -63928,7 +65032,7 @@ function useReport(reportIdArg, options = {}) {
     restrictFieldOptionsToSelectedDatasources,
     selectedBaseTableNamesForFieldOptions
   ]);
-  useEffect31(() => {
+  useEffect32(() => {
     if (reportOverride) return;
     if (propReportId) return;
     if (createdReportBootstrap) return;
@@ -64278,15 +65382,11 @@ function useReport(reportIdArg, options = {}) {
         return null;
       }
       return {
-        reportBuilderState: {
-          ...sourceReportBuilderState,
-          columns: columnsForUniqueValues,
-          // Distinct string options for the filter query builder must not use the
-          // live filterStack: on surfaces that call setFilters on every query-builder
-          // change, in-progress rules refetch unique values and the engine often
-          // returns empty columns (no rows / invalid stack), clearing all multiselects.
-          filterStack: []
-        },
+        // Distinct string options must not depend on presentation or live filters.
+        reportBuilderState: createFilterUniqueValuesReportBuilderState(
+          sourceReportBuilderState,
+          columnsForUniqueValues
+        ),
         stringColumns: stringColumns2,
         stringColumnsByTable: columnsForUniqueValues,
         dashboardName
@@ -64390,11 +65490,36 @@ function useReport(reportIdArg, options = {}) {
         databaseType: client?.databaseType
       })
     ],
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
       try {
         if (!client || !filterUniqueValuesRequest) {
           return { uniqueValuesByColumn: {} };
         }
+        const cachedReport = await resolveCachedReport({
+          reportBuilderState: filterUniqueValuesRequest.reportBuilderState,
+          filters: [],
+          pivot: null,
+          operation: "unique-values"
+        });
+        if (cachedReport?.uniqueStringsByTable) {
+          const localValues = {};
+          let hasEveryColumn = true;
+          for (const column of filterUniqueValuesRequest.stringColumnsByTable) {
+            const table2 = String(column.table ?? "").trim();
+            const field = String(column.field ?? "").trim();
+            const values = cachedReport.uniqueStringsByTable[table2]?.[field] ?? cachedReport.uniqueStringsByTable[""]?.[field];
+            if (!values) {
+              hasEveryColumn = false;
+              break;
+            }
+            localValues[field] = values;
+            const alias = String(column.alias ?? "").trim();
+            if (alias) localValues[alias] = values;
+          }
+          if (hasEveryColumn) {
+            return { uniqueValuesByColumn: localValues };
+          }
+        }
         const tablesForUniqueValues = filterUniqueValuesRequest.reportBuilderState?.tables?.map(
           (table2) => String(table2?.name ?? "").trim()
         ) ?? filterUniqueValuesRequest.stringColumnsByTable.map((column) => String(column.table ?? "").trim()).filter(Boolean);
@@ -64407,7 +65532,8 @@ function useReport(reportIdArg, options = {}) {
           customFields: schemaData.customFields ?? void 0,
           tenants,
           dashboardName: filterUniqueValuesRequest.dashboardName,
-          getToken
+          getToken,
+          abortSignal: signal
         });
         const aliasToField = {};
         for (const column of filterUniqueValuesRequest.stringColumnsByTable) {
@@ -64439,12 +65565,18 @@ function useReport(reportIdArg, options = {}) {
           }
         });
         return { uniqueValuesByColumn: normalizedUniqueValuesByColumn };
-      } catch {
+      } catch (error) {
+        if (signal.aborted || error instanceof Error && error.name === "AbortError") {
+          throw error;
+        }
         return { uniqueValuesByColumn: {} };
       }
     }),
     enabled: filterUniqueValuesEnabled,
-    retry: false
+    retry: false,
+    staleTime: 5 * 6e4,
+    gcTime: 15 * 6e4,
+    placeholderData: keepPreviousData
   });
   const backendUniqueValuesByFieldName = useMemo33(() => {
     const valuesByField = /* @__PURE__ */ new Map();
@@ -64824,14 +65956,15 @@ function useReport(reportIdArg, options = {}) {
     () => stableSerializeForQueryKey(reloadKey),
     [reloadKey]
   );
-  useEffect31(() => {
+  useEffect32(() => {
     if (!reportOverride) return;
     initializeSchemaScopeForReport(reportOverride);
     setSourceReport(reportOverride);
   }, [reportOverride, propReportId]);
-  useEffect31(() => {
+  useEffect32(() => {
     schemaScopeInitializedForReportIdRef.current = null;
     bootstrapReportTaskUsedForReportIdRef.current = null;
+    sharedInitialRequestUsedForReportIdRef.current = null;
     setPreserveSchemaWideOptions(false);
     setInitialSchemaScopedTableNames(null);
     if (!reportOverride) {
@@ -64885,7 +66018,33 @@ function useReport(reportIdArg, options = {}) {
       flagHash,
       clientHash
     }),
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
+      let cachedReportBuilderState = initialReportBuilderStateForLoad ?? void 0;
+      if (!cachedReportBuilderState) {
+        const snapshot = await cacheCab.getReportSnapshot(
+          effectiveReportId,
+          tenants
+        );
+        if (snapshot?.complete || snapshot && forceIncompleteCacheCabForParity) {
+          cachedReportBuilderState = await fetchReportBuilderStateByReportId({
+            reportId: effectiveReportId,
+            client,
+            getToken,
+            draftSessionId: draftSessionId || void 0,
+            tenants,
+            abortSignal: signal
+          }) ?? void 0;
+        }
+      }
+      const cachedReport = await resolveCachedReport({
+        reportBuilderState: cachedReportBuilderState,
+        filters: cachedReportBuilderState ? customFiltersFromFilterStack(cachedReportBuilderState.filterStack) : void 0,
+        pivot: cachedReportBuilderState?.pivot,
+        operation: "initial"
+      });
+      if (cachedReport) {
+        return { report: cachedReport };
+      }
       const allowReportTaskBootstrap = !initialReportBuilderStateForLoad && bootstrapReportTaskUsedForReportIdRef.current !== effectiveReportId;
       const loadTargetId = String(effectiveReportId ?? "").trim();
       const sourceReportIdentity = String(
@@ -64893,9 +66052,7 @@ function useReport(reportIdArg, options = {}) {
       ).trim();
       const formFiltersBelongToLoadTarget = Boolean(loadTargetId) && sourceReportIdentity === loadTargetId;
       const internalFiltersForLoad = useInMemoryEngines || !formFiltersBelongToLoadTarget ? [] : internalFilters;
-      if (allowReportTaskBootstrap) {
-        bootstrapReportTaskUsedForReportIdRef.current = effectiveReportId;
-      }
+      const shareInitialRequest = sharedInitialRequestUsedForReportIdRef.current !== effectiveReportId;
       const loadResult = await loadReportForUseForm({
         reportId: effectiveReportId,
         initialReportBuilderState: initialReportBuilderStateForLoad,
@@ -64911,8 +66068,18 @@ function useReport(reportIdArg, options = {}) {
         dashboardName: resolvedSourceDashboardName,
         useInMemoryEngines,
         draftSessionId: draftSessionId || void 0,
-        rowsOnly: isCreatedReportBootstrapLoad
+        shareInitialRequest,
+        rowsOnly: isCreatedReportBootstrapLoad,
+        abortSignal: signal
       });
+      if (loadResult.report && !loadResult.error) {
+        if (allowReportTaskBootstrap) {
+          bootstrapReportTaskUsedForReportIdRef.current = effectiveReportId;
+        }
+        if (shareInitialRequest) {
+          sharedInitialRequestUsedForReportIdRef.current = effectiveReportId;
+        }
+      }
       return loadResult;
     }),
     enabled: Boolean(effectiveReportId) && Boolean(client) && !reportOverride,
@@ -64924,7 +66091,7 @@ function useReport(reportIdArg, options = {}) {
       reportId: reportNameQueryReportId,
       clientHash
     }),
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
       if (!client) {
         return { name: null };
       }
@@ -64932,7 +66099,8 @@ function useReport(reportIdArg, options = {}) {
         reportId: reportNameQueryReportId,
         client,
         getToken,
-        tenants
+        tenants,
+        abortSignal: signal
       });
     }),
     enabled: Boolean(reportNameQueryReportId) && Boolean(client),
@@ -64945,13 +66113,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;
-  useEffect31(() => {
+  useEffect32(() => {
     if (reportOverride) return;
     const report = initialLoadQuery.data?.report ?? null;
     initializeSchemaScopeForReport(report);
     setSourceReport(report);
   }, [initialLoadQuery.data, reportOverride, effectiveReportId]);
-  useEffect31(() => {
+  useEffect32(() => {
     if (!sourceReport) {
       return;
     }
@@ -65019,14 +66187,14 @@ function useReport(reportIdArg, options = {}) {
           }) || void 0
         ) : shouldApplyPivotAggregationsFromSource ? [] : prev.aggregationTablesByIndex;
         const sourceRowGroupOption = encodePivotGroupOptionValue(
-          resolveColumnTableFromReportMetadata(
+          String(sourceReport.pivot?.rowFieldTable ?? "").trim() || resolveColumnTableFromReportMetadata(
             sourceReport,
             sourceReport.pivot?.rowField ?? ""
           ),
           sourceReport.pivot?.rowField ?? ""
         ) || sourceReport.pivot?.rowField;
         const sourceColumnGroupOption = encodePivotGroupOptionValue(
-          resolveColumnTableFromReportMetadata(
+          String(sourceReport.pivot?.columnFieldTable ?? "").trim() || resolveColumnTableFromReportMetadata(
             sourceReport,
             sourceReport.pivot?.columnField ?? ""
           ),
@@ -65177,7 +66345,7 @@ function useReport(reportIdArg, options = {}) {
     chartPivotHydrationEpoch
   ]);
   const hasDatePivotRow = Boolean(String(pivotState?.rowField ?? "").trim()) && isDateType(String(pivotState?.rowFieldType ?? ""));
-  useEffect31(() => {
+  useEffect32(() => {
     const previous = prevPivotStateForColumnExpansionRef.current;
     if (previous && !pivotState) {
       setExpandReportBuilderColumnsForFlatTable(true);
@@ -65442,7 +66610,7 @@ function useReport(reportIdArg, options = {}) {
     queryColumns,
     sourceReport
   ]);
-  useEffect31(() => {
+  useEffect32(() => {
     if (!Array.isArray(filterStack) || filterStack.length === 0) {
       return;
     }
@@ -65546,7 +66714,7 @@ function useReport(reportIdArg, options = {}) {
     [effectiveReportBuilderState]
   );
   const prevPaginationResetStateHashRef = useRef24(null);
-  useEffect31(() => {
+  useEffect32(() => {
     const prevHash = prevPaginationResetStateHashRef.current;
     prevPaginationResetStateHashRef.current = effectiveReportBuilderStateHash;
     if (prevHash === null || prevHash === effectiveReportBuilderStateHash) {
@@ -65558,9 +66726,7 @@ function useReport(reportIdArg, options = {}) {
     if (paginationRef.current.pageIndex === 0) {
       return;
     }
-    applyPaginationUpdate((old) => ({ ...old, pageIndex: 0 }), {
-      activate: false
-    });
+    applyPaginationUpdate((old) => ({ ...old, pageIndex: 0 }));
   }, [applyPaginationUpdate, effectiveReportBuilderStateHash]);
   const pivotTableDataReportBuilderState = useMemo33(() => {
     if (!effectiveReportBuilderState?.pivot) {
@@ -65622,22 +66788,60 @@ function useReport(reportIdArg, options = {}) {
     filterStack
   ]);
   const shouldForceTableRefreshFromFilters = !useInMemoryEngines && !pivotState;
-  const tableRefreshQueryEnabled = !reportOverride && tableRefreshVersion > 0 && Boolean(sourceReport) && Boolean(client) && Boolean(effectiveReportBuilderState) && !pendingPivotRefresh && sourceReportMatchesEffectiveReportId && (refreshDecision.shouldRefresh || shouldForceTableRefreshFromFilters && !shouldSkipRedundantFlatTableReportBuilderQuery);
+  const immediateTableRefreshInput = useMemo33(
+    () => ({
+      version: tableRefreshVersion,
+      reportBuilderStateHash: effectiveReportBuilderStateHash,
+      reportBuilderState: effectiveReportBuilderState,
+      shouldRefresh: refreshDecision.shouldRefresh || shouldForceTableRefreshFromFilters && !shouldSkipRedundantFlatTableReportBuilderQuery
+    }),
+    [
+      effectiveReportBuilderState,
+      effectiveReportBuilderStateHash,
+      refreshDecision.shouldRefresh,
+      shouldForceTableRefreshFromFilters,
+      shouldSkipRedundantFlatTableReportBuilderQuery,
+      tableRefreshVersion
+    ]
+  );
+  const debouncedTableRefreshInput = useDebouncedRefreshInput(
+    immediateTableRefreshInput
+  );
+  const disableTableRefreshDebounceForDiagnostics = process.env.NODE_ENV === "test" && process.env.QUILL_DISABLE_REPORT_REFRESH_DEBOUNCE === "true";
+  const tableRefreshInput = disableTableRefreshDebounceForDiagnostics ? immediateTableRefreshInput : debouncedTableRefreshInput;
+  const tableRefreshInputIsCurrent = tableRefreshInput.version === tableRefreshVersion && tableRefreshInput.reportBuilderStateHash === effectiveReportBuilderStateHash;
+  const completedTableRefreshRef = useRef24(null);
+  if (completedTableRefreshRef.current?.reportId !== effectiveReportId) {
+    completedTableRefreshRef.current = null;
+  }
+  const tableRefreshInputAlreadyCompleted = !disableTableRefreshDebounceForDiagnostics && completedTableRefreshRef.current?.reportId === effectiveReportId && completedTableRefreshRef.current.version >= tableRefreshInput.version;
+  const tableRefreshQueryEnabled = !reportOverride && tableRefreshInputIsCurrent && !tableRefreshInputAlreadyCompleted && tableRefreshInput.version > 0 && Boolean(sourceReport) && Boolean(client) && Boolean(tableRefreshInput.reportBuilderState) && !pendingPivotRefresh && sourceReportMatchesEffectiveReportId && tableRefreshInput.shouldRefresh;
   const tableRefreshQuery = useQuery({
     queryKey: createUseFormTableRefreshQueryKey({
       reportId: effectiveReportId,
-      tableRefreshVersion,
-      reportBuilderStateHash: effectiveReportBuilderStateHash,
+      tableRefreshVersion: tableRefreshInput.version,
+      reportBuilderStateHash: tableRefreshInput.reportBuilderStateHash,
       tenantHash,
       clientHash
     }),
-    queryFn: createUseFormQueryFn(async () => {
-      if (!effectiveReportBuilderState || !sourceReport || !client) {
+    queryFn: createUseFormQueryFn(async (signal) => {
+      if (!tableRefreshInput.reportBuilderState || !sourceReport || !client) {
         return { report: null, error: "Missing table refresh prerequisites" };
       }
+      const cachedReport = await resolveCachedReport({
+        reportBuilderState: tableRefreshInput.reportBuilderState,
+        filters: customFiltersFromFilterStack(
+          tableRefreshInput.reportBuilderState.filterStack
+        ),
+        pivot: null,
+        operation: "table"
+      });
+      if (cachedReport) {
+        return { report: cachedReport };
+      }
       return loadViaReportBuilderState({
         reportId: effectiveReportId,
-        reportBuilderState: effectiveReportBuilderState,
+        reportBuilderState: tableRefreshInput.reportBuilderState,
         client,
         getToken,
         tenants,
@@ -65645,7 +66849,8 @@ function useReport(reportIdArg, options = {}) {
         customFields: schemaData.customFields,
         dashboardName: resolvedSourceDashboardName,
         report: sourceReport,
-        draftSessionId: draftSessionId || void 0
+        draftSessionId: draftSessionId || void 0,
+        abortSignal: signal
       });
     }),
     enabled: tableRefreshQueryEnabled,
@@ -65660,7 +66865,7 @@ function useReport(reportIdArg, options = {}) {
       tenantHash,
       clientHash
     ],
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
       if (!createdBootstrapForInitialLoad || !initialReportBuilderStateForLoad || !client) {
         return { report: null, error: "Missing bootstrap count prerequisites" };
       }
@@ -65675,19 +66880,29 @@ function useReport(reportIdArg, options = {}) {
         dashboardName: resolvedSourceDashboardName,
         report: createdBootstrapForInitialLoad.report,
         draftSessionId: draftSessionId || void 0,
-        rowCountOnly: true
+        rowCountOnly: true,
+        abortSignal: signal
       });
     }),
     enabled: isCreatedReportBootstrapLoad && Boolean(client) && !reportOverride,
     retry: false
   });
-  useEffect31(() => {
+  useEffect32(() => {
     if (!tableRefreshQueryEnabled) return;
     const report = tableRefreshQuery.data?.report;
     if (tableRefreshQuery.data?.error || !report) return;
+    completedTableRefreshRef.current = {
+      reportId: effectiveReportId,
+      version: tableRefreshInput.version
+    };
     setSourceReport(report);
-  }, [effectiveReportId, tableRefreshQuery.data, tableRefreshQueryEnabled]);
-  useEffect31(() => {
+  }, [
+    effectiveReportId,
+    tableRefreshInput.version,
+    tableRefreshQuery.data,
+    tableRefreshQueryEnabled
+  ]);
+  useEffect32(() => {
     const countReport = createdBootstrapRowCountQuery.data?.report;
     if (createdBootstrapRowCountQuery.data?.error || !countReport) return;
     setSourceReport((currentReport) => {
@@ -65707,7 +66922,7 @@ function useReport(reportIdArg, options = {}) {
     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;
-  useEffect31(() => {
+  useEffect32(() => {
     if (!sourceReport) {
       return;
     }
@@ -66202,7 +67417,7 @@ function useReport(reportIdArg, options = {}) {
     );
     return hasSamePivot && sourceFilterStackHash === filterStackHash;
   }, [filterStackHash, nextPivot, sourceReport]);
-  useEffect31(() => {
+  useEffect32(() => {
     if (!pendingPivotRefresh) return;
     if (!nextPivot) {
       if (!sourceReport) {
@@ -66261,10 +67476,19 @@ function useReport(reportIdArg, options = {}) {
       flagHash,
       clientHash
     }),
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
       if (!effectiveReportBuilderState || !nextPivot || !sourceReport || !client) {
         return { report: null, error: "Missing pivot refresh prerequisites" };
       }
+      const cachedReport = await resolveCachedReport({
+        reportBuilderState: effectiveReportBuilderState,
+        filters: customFilters,
+        pivot: nextPivot,
+        operation: "pivot"
+      });
+      if (cachedReport) {
+        return { report: cachedReport };
+      }
       const pivotRefreshBaseReport = {
         ...sourceReport,
         reportBuilderState: effectiveReportBuilderState
@@ -66284,7 +67508,8 @@ function useReport(reportIdArg, options = {}) {
         customFields: schemaData.customFields,
         dashboardName: resolvedSourceDashboardName,
         useInMemoryEngines,
-        draftSessionId: draftSessionId || void 0
+        draftSessionId: draftSessionId || void 0,
+        abortSignal: signal
       });
       return pivotRefreshResult;
     }),
@@ -66295,16 +67520,28 @@ function useReport(reportIdArg, options = {}) {
     queryKey: createUseFormPivotTableDataRefreshQueryKey({
       reportId: effectiveReportId,
       reportBuilderStateHash: pivotTableDataReportBuilderStateHash,
+      pageSize: pagination.pageSize,
       tenantHash,
       clientHash
     }),
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
       if (!pivotTableDataReportBuilderState || !sourceReport || !client) {
         return {
           report: null,
           error: "Missing pivot table-data refresh prerequisites"
         };
       }
+      const cachedReport = await resolveCachedReport({
+        reportBuilderState: pivotTableDataReportBuilderState,
+        filters: customFiltersFromFilterStack(
+          pivotTableDataReportBuilderState.filterStack
+        ),
+        pivot: null,
+        operation: "pivot-table"
+      });
+      if (cachedReport) {
+        return { report: cachedReport };
+      }
       const tableDataResult = await loadViaReportBuilderState({
         reportId: effectiveReportId,
         reportBuilderState: pivotTableDataReportBuilderState,
@@ -66315,7 +67552,12 @@ function useReport(reportIdArg, options = {}) {
         customFields: schemaData.customFields,
         dashboardName: resolvedSourceDashboardName,
         report: sourceReport,
-        draftSessionId: draftSessionId || void 0
+        draftSessionId: draftSessionId || void 0,
+        pagination: {
+          pageIndex: 0,
+          pageSize: pagination.pageSize
+        },
+        abortSignal: signal
       });
       return tableDataResult;
     }),
@@ -66324,28 +67566,20 @@ function useReport(reportIdArg, options = {}) {
   });
   const tablePageReportBuilderState = pivotTableDataReportBuilderState ?? effectiveReportBuilderState;
   const tablePageReportBuilderStateHash = pivotTableDataReportBuilderState ? pivotTableDataReportBuilderStateHash : effectiveReportBuilderStateHash;
-  const tablePaginationSort = useMemo33(() => {
-    const sortEntry = tablePageReportBuilderState?.sort?.[0];
-    const field = String(sortEntry?.field ?? "").trim();
-    if (!field || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(field)) {
-      return void 0;
-    }
-    const isOutputColumn = (tablePageReportBuilderState?.columns ?? []).some(
-      (column) => String(column?.field ?? "").trim() === field
-    );
-    if (!isOutputColumn) {
-      return void 0;
-    }
-    const direction = String(sortEntry?.direction ?? "ASC").toUpperCase() === "DESC" ? "DESC" : "ASC";
-    return { field, direction };
-  }, [tablePageReportBuilderState]);
+  const tablePaginationSort = useMemo33(
+    () => getStablePaginationSort({
+      columns: tablePageReportBuilderState?.columns,
+      sort: tablePageReportBuilderState?.sort
+    }),
+    [tablePageReportBuilderState]
+  );
   const baseWindowRowsLength = Array.isArray(sourceReport?.rows) ? sourceReport.rows.length : 0;
   const sourceReportRowCount = typeof sourceReport?.rowCount === "number" ? sourceReport.rowCount : void 0;
   const trustedSourceRowCount = sourceReportRowCount !== void 0 && (sourceReportRowCount > 0 || baseWindowRowsLength === 0) && sourceReportRowCount >= baseWindowRowsLength ? sourceReportRowCount : void 0;
   const paginationRangeStart = pagination.pageIndex * pagination.pageSize;
   const paginationRangeEnd = paginationRangeStart + pagination.pageSize;
   const pageWithinBaseWindow = paginationRangeEnd <= baseWindowRowsLength || trustedSourceRowCount !== void 0 && trustedSourceRowCount <= baseWindowRowsLength;
-  const tablePageQueryEnabled = paginationActive && !pageWithinBaseWindow && !reportOverride && !useInMemoryEngines && Boolean(client) && Boolean(sourceReport) && Boolean(tablePageReportBuilderState) && sourceReportMatchesEffectiveReportId && !pendingPivotRefresh;
+  const tablePageQueryEnabled = !pageWithinBaseWindow && !reportOverride && !useInMemoryEngines && Boolean(client) && Boolean(sourceReport) && Boolean(tablePageReportBuilderState) && sourceReportMatchesEffectiveReportId && !pendingPivotRefresh;
   const tablePageQuery = useQuery({
     queryKey: createUseFormTablePageQueryKey({
       reportId: effectiveReportId,
@@ -66356,7 +67590,7 @@ function useReport(reportIdArg, options = {}) {
       tenantHash,
       clientHash
     }),
-    queryFn: createUseFormQueryFn(async () => {
+    queryFn: createUseFormQueryFn(async (signal) => {
       if (!tablePageReportBuilderState || !sourceReport || !client) {
         return { report: null, error: "Missing table page prerequisites" };
       }
@@ -66376,7 +67610,8 @@ function useReport(reportIdArg, options = {}) {
           pageSize: pagination.pageSize
         },
         paginationSort: tablePaginationSort,
-        rowsOnly: true
+        rowsOnly: true,
+        abortSignal: signal
       });
     }),
     enabled: tablePageQueryEnabled,
@@ -66410,7 +67645,7 @@ function useReport(reportIdArg, options = {}) {
     pagination.pageSize
   );
   paginationPageCountRef.current = paginationPageCount;
-  useEffect31(() => {
+  useEffect32(() => {
     if (!pivotTableDataRefreshQueryEnabled) return;
     if (pivotTableDataRefreshQuery.status !== "success" && pivotTableDataRefreshQuery.status !== "error") {
       return;
@@ -66451,7 +67686,7 @@ function useReport(reportIdArg, options = {}) {
     pivotTableDataRefreshQueryEnabled,
     effectiveReportId
   ]);
-  useEffect31(() => {
+  useEffect32(() => {
     if (!pivotRefreshQueryEnabled) return;
     if (pivotRefreshQuery.status !== "success" && pivotRefreshQuery.status !== "error") {
       return;
@@ -66841,18 +68076,18 @@ function useReport(reportIdArg, options = {}) {
       resolvedYAxisFieldsForDisplay
     );
     if (String(baseChart.chartType ?? "").toLowerCase() === "table" && baseChart.pivot) {
-      const pivotAggregations = getPivotAggregations(baseChart);
+      const pivotAggregations2 = getPivotAggregations(baseChart);
       const hasCustomMeasureLabel = resolvedYAxisFields.some((axis) => {
         const aggregation = findAggregationForFieldStrict(
           axis.field,
-          pivotAggregations
+          pivotAggregations2
         );
         if (!aggregation) return false;
         const label = String(axis.label ?? "").trim();
         const defaultLabel = buildAggregationLabel(aggregation, baseChart);
         return Boolean(label) && label !== defaultLabel;
       });
-      if (pivotAggregations.length > 1 || hasCustomMeasureLabel) {
+      if (pivotAggregations2.length > 1 || hasCustomMeasureLabel) {
         columns2 = mergePivotTableDisplayColumnLabelsFromYAxis({
           columns: columns2 ?? baseChart.columns,
           yAxisFields: resolvedYAxisFieldsForDisplay,
@@ -67204,7 +68439,7 @@ function useReport(reportIdArg, options = {}) {
   );
   const table = useMemo33(() => {
     const baseWindowRows = Array.isArray(sourceReport?.rows) ? sourceReport.rows : [];
-    const rawRows = !paginationActive ? baseWindowRows : tablePageRows ?? baseWindowRows.slice(paginationRangeStart, paginationRangeEnd);
+    const rawRows = tablePageRows ?? baseWindowRows.slice(paginationRangeStart, paginationRangeEnd);
     const { columns: mergedFromReport } = mergeDisplayAndSourceForTableFormats({
       effectiveReportBuilderTableNames,
       scopedSchemaColumns,
@@ -67313,7 +68548,6 @@ function useReport(reportIdArg, options = {}) {
     sourceReport,
     tableColumnsEditedSignature,
     pagination,
-    paginationActive,
     paginationPageCount,
     paginationRangeEnd,
     paginationRangeStart,
@@ -68399,15 +69633,54 @@ 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 ?? {})
       });
     }
@@ -68457,8 +69730,19 @@ function useReport(reportIdArg, options = {}) {
       tenants,
       draftSessionId: draftSessionId || void 0
     });
+    const savedReportId = String(
+      resp?.id ?? resp?._id ?? effectiveReportId ?? ""
+    ).trim();
+    if (savedReportId && resp && resp.name !== "error" && !resp.error) {
+      await cacheCab.evictReport(savedReportId, tenants);
+      await queryClient.invalidateQueries({
+        queryKey: ["quill", "dashboard-report", savedReportId],
+        refetchType: "none"
+      });
+    }
     return resp;
   }, [
+    cacheCab,
     client,
     dashboardNameForNewReport,
     draftSessionId,
@@ -68467,6 +69751,7 @@ function useReport(reportIdArg, options = {}) {
     eventTracking,
     formReportName,
     getToken,
+    queryClient,
     resolvedXAxisField,
     resolvedXAxisFormat,
     resolvedXAxisLabel,
@@ -68850,7 +70135,7 @@ function ToolCallBlock({ toolCall }) {
   );
 }
 function ToolCallResult({ content }) {
-  const [expanded, setExpanded] = useState42(false);
+  const [expanded, setExpanded] = useState43(false);
   if (!content) return null;
   const isLong = content.length > 300;
   const displayed = isLong && !expanded ? content.slice(0, 300) + "..." : content;
@@ -68905,15 +70190,15 @@ function Chat({
   const [client] = useContext37(ClientContext);
   const { getToken } = useContext37(FetchContext);
   const { tenants } = useContext37(TenantContext);
-  const [messages, setMessages] = useState42([]);
-  const [input, setInput] = useState42("");
-  const [inputError, setInputError] = useState42("");
-  const [isLoading, setIsLoading] = useState42(false);
-  const [model, setModel] = useState42("gemini-3-flash-preview");
+  const [messages, setMessages] = useState43([]);
+  const [input, setInput] = useState43("");
+  const [inputError, setInputError] = useState43("");
+  const [isLoading, setIsLoading] = useState43(false);
+  const [model, setModel] = useState43("gemini-3-flash-preview");
   const containerRef = useRef25(null);
   const textareaRef = useRef25(null);
   const abortControllerRef = useRef25(null);
-  useEffect32(() => {
+  useEffect33(() => {
     if (!containerRef.current) {
       return;
     }
@@ -69347,7 +70632,7 @@ function Chat({
 }
 
 // src/hooks/useReportFilterDraft.ts
-import { useCallback as useCallback6, useEffect as useEffect33, useMemo as useMemo35, useRef as useRef26, useState as useState43 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect34, useMemo as useMemo35, useRef as useRef26, useState as useState44 } from "react";
 var normalizeOperatorKey = (operator) => String(operator ?? "").trim().toLowerCase().replace(/[_\s]+/g, "");
 var defaultFilterRuleValueForOperator = (operator) => {
   const key = normalizeOperatorKey(operator);
@@ -69409,11 +70694,11 @@ function useReportFilterDraft(args) {
     () => fieldCatalogSignature(effectiveFields),
     [effectiveFields]
   );
-  const [resetEpoch, setResetEpoch] = useState43(0);
-  const [draftQuery, setDraftQuery] = useState43(committed);
-  const [hasUnappliedFilterChanges, setHasUnappliedFilterChanges] = useState43(false);
+  const [resetEpoch, setResetEpoch] = useState44(0);
+  const [draftQuery, setDraftQuery] = useState44(committed);
+  const [hasUnappliedFilterChanges, setHasUnappliedFilterChanges] = useState44(false);
   const draftResetKey = `${reportId}|${committedSignature}|${resetEpoch}`;
-  useEffect33(() => {
+  useEffect34(() => {
     setDraftQuery(committedRef.current);
     setHasUnappliedFilterChanges(false);
   }, [draftResetKey]);
@@ -69505,7 +70790,7 @@ import {
   useContext as useContext38,
   useLayoutEffect as useLayoutEffect5,
   useRef as useRef27,
-  useState as useState44
+  useState as useState45
 } from "react";
 import { jsx as jsx89, jsxs as jsxs66 } from "react/jsx-runtime";
 var CHART_MIN_PX = 220;
@@ -69607,14 +70892,14 @@ function ReportDetail({
   const useDetailTableFromUseForm = isTableChart && !isPivotTableChartConfig(chart);
   const showBottomRawTable = !isTableChart;
   const chartSlotRef = useRef27(null);
-  const [chartHeightPx, setChartHeightPx] = useState44(360);
+  const [chartHeightPx, setChartHeightPx] = useState45(360);
   useLayoutEffect5(() => {
     const el = chartSlotRef.current;
     if (!el) {
       return;
     }
-    const ro = new ResizeObserver((entries) => {
-      const entry = entries[0];
+    const ro = new ResizeObserver((entries2) => {
+      const entry = entries2[0];
       if (!entry) return;
       const h = Math.floor(entry.contentRect.height);
       if (h >= CHART_MIN_PX) {
@@ -69733,7 +71018,7 @@ function ReportDetail({
 init_valueFormatter();
 
 // src/hooks/useTenants.ts
-import { useContext as useContext39, useEffect as useEffect34 } from "react";
+import { useContext as useContext39, useEffect as useEffect35 } from "react";
 var useTenants = (dashboardName) => {
   const {
     tenants,
@@ -69747,12 +71032,12 @@ var useTenants = (dashboardName) => {
     getMappedTenantsForDashboard,
     getViewerTenantsByOwner
   } = useContext39(TenantContext);
-  useEffect34(() => {
+  useEffect35(() => {
     if (dashboardName) {
       fetchViewerTenantsForDashboard(dashboardName);
     }
   }, [dashboardName, fetchViewerTenantsForDashboard]);
-  useEffect34(() => {
+  useEffect35(() => {
     if (dashboardName) {
       fetchMappedTenantsForDashboard(dashboardName);
     }
@@ -69771,7 +71056,7 @@ var useTenants = (dashboardName) => {
 };
 
 // src/hooks/useQuill.ts
-import { useContext as useContext40, useEffect as useEffect35, useMemo as useMemo36, useState as useState45 } from "react";
+import { useContext as useContext40, useEffect as useEffect36, useMemo as useMemo36, useState as useState46 } from "react";
 init_paginationProcessing();
 init_tableProcessing();
 init_dataProcessing();
@@ -69794,9 +71079,9 @@ var useQuill = (reportId, pagination) => {
   const [client, isClientLoading] = useContext40(ClientContext);
   const { tenants } = useContext40(TenantContext);
   const { eventTracking } = useContext40(EventTrackingContext);
-  const [loading, setLoading] = useState45(true);
-  const [error, setError] = useState45(void 0);
-  const [previousPage, setPreviousPage] = useState45(0);
+  const [loading, setLoading] = useState46(true);
+  const [error, setError] = useState46(void 0);
+  const [previousPage, setPreviousPage] = useState46(0);
   const processedReport = useMemo36(() => {
     return reportId && allReportsById[reportId] ? convertInternalReportToReport(
       mergeComparisonRange(allReportsById[reportId]),
@@ -69805,7 +71090,7 @@ var useQuill = (reportId, pagination) => {
       "useQuill"
     ) : void 0;
   }, [reportId, reportId && allReportsById[reportId], specificReportFilters]);
-  const [additionalProcessing, setAdditionProcessing] = useState45(
+  const [additionalProcessing, setAdditionProcessing] = useState46(
     pagination ? {
       page: pagination
     } : void 0
@@ -69954,7 +71239,7 @@ var useQuill = (reportId, pagination) => {
       setLoading(false);
     }
   };
-  useEffect35(() => {
+  useEffect36(() => {
     if (isClientLoading) return;
     if (reportId && specificReportFilters) {
       fetchReportHelper(reportId, {
@@ -70021,7 +71306,7 @@ var useMemoizedRows = (reportId) => {
 };
 
 // src/hooks/useAskQuill.tsx
-import { useContext as useContext41, useEffect as useEffect36, useState as useState46 } from "react";
+import { useContext as useContext41, useEffect as useEffect37, useState as useState47 } from "react";
 init_astProcessing();
 init_astFilterProcessing();
 init_pivotProcessing();
@@ -70054,8 +71339,8 @@ var useAskQuill = (dashboardName) => {
   const { tenants } = useContext41(TenantContext);
   const { getToken } = useContext41(FetchContext);
   const { eventTracking } = useContext41(EventTrackingContext);
-  const [astInfo, setAstInfo] = useState46(void 0);
-  const [data, setData] = useState46({
+  const [astInfo, setAstInfo] = useState47(void 0);
+  const [data, setData] = useState47({
     rows: [],
     columns: [],
     pivot: null,
@@ -70065,9 +71350,9 @@ var useAskQuill = (dashboardName) => {
     pivotColumnFields: [],
     pivotValueFields: []
   });
-  const [loading, setLoading] = useState46(false);
-  const [error, setError] = useState46(void 0);
-  const [ask, setAsk] = useState46(
+  const [loading, setLoading] = useState47(false);
+  const [error, setError] = useState47(void 0);
+  const [ask, setAsk] = useState47(
     async () => void 0
   );
   const askHelper = async (query) => {
@@ -70267,7 +71552,7 @@ var useAskQuill = (dashboardName) => {
     });
     setLoading(false);
   };
-  useEffect36(() => {
+  useEffect37(() => {
     setAsk(() => askHelper);
   }, [schemaData.schema]);
   return {
@@ -70281,13 +71566,13 @@ var useAskQuill = (dashboardName) => {
 };
 
 // src/hooks/useVirtualTables.tsx
-import { useContext as useContext42, useState as useState47 } from "react";
+import { useContext as useContext42, useState as useState48 } from "react";
 var useVirtualTables = () => {
   const [schemaData, setSchemaData] = useContext42(SchemaDataContext);
   const { tenants } = useContext42(TenantContext);
   const { getToken, quillFetchWithToken } = useContext42(FetchContext);
   const { eventTracking } = useContext42(EventTrackingContext);
-  const [loadingTables, setLoadingTables] = useState47({});
+  const [loadingTables, setLoadingTables] = useState48({});
   const handleReload = async (client, caller) => {
     setSchemaData({ ...schemaData, isSchemaLoading: true });
     setLoadingTables(
@@ -70457,14 +71742,14 @@ var useChangelogRefresh = () => {
   const [, setSchemaData] = useContext43(SchemaDataContext);
   const { allReportsById } = useAllReports();
   const { reloadSome } = useVirtualTables();
-  const refreshChangelogEntries = async (entries, client) => {
+  const refreshChangelogEntries = async (entries2, client) => {
     const dashboardsToReload = /* @__PURE__ */ new Set();
     let reloadAllDashboards = false;
     const schemaIds = [];
     const schemaIdsToRemove = /* @__PURE__ */ new Set();
     const dashboardsToRemove = /* @__PURE__ */ new Set();
     const reportsToRemove = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
+    for (const entry of entries2) {
       if (!entry.entityId || !entry.entityType) continue;
       const changeType = getChangeType(entry);
       switch (entry.entityType) {