@pythia-software/query-table-react 0.9.1 → 0.9.3

package/README.md

@@ -120,3 +120,23 @@ and reject them through `validateQuery` so users can repair the selected tags.
 `api.aggregations.preview(clauses, signal)` evaluates a draft without modifying the query. `replace(clauses, expected?)` commits the entire dashboard as one undoable change and can reject a stale editor baseline. Presentation-only changes reuse computation. Advanced remote execution uses `fetchMetrics` plus explicit v2 `metricCapabilities`; v1 transports continue to support representable simple metrics. All-matching scope requires the complete client dataset or a server metric service. Shown-row fallback uses committed inputs and reports missing dependencies.
 
 See [the metrics integration guide](../../docs/metrics.md) for scopes, cancellation, worker-isolated regex, capability negotiation, computed revisions, and snapshot requirements.
+
+For host-managed row windows, pass `metricTransport` to fetch metrics separately
+while `clientRows` continues through local filtering, sorting, and paging.
+`metricExecution` overrides the metric handshake independently of
+`computedExecution`. Both default to the existing row transport/execution
+selection. Computed grouping choices in `api.computed.catalogue` use the metric
+transport and handshake, including definition revisions; row selection,
+filtering, sorting, and value access keep their row capabilities.
+Use `metricRowsReady(query)` to confirm that the external row window
+matches the current query and origin before local shown-row evaluation or
+previews. Remote `allMatching` metrics run while that gate is false.
+
+A V2 transport must explicitly advertise `metricCapabilities.shownRows: true`
+to execute supported shown-row clauses remotely. False or omitted uses the
+committed page, provided its inputs are loaded. See the
+[migration example](../../docs/metrics.md#independent-remote-metrics).
+
+Standalone `useAggregations` calls with a complete client dataset derive the
+shown page when readiness options are omitted. An explicit `rowsReady: false`
+still blocks automatic shown-row evaluation and previews.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { FieldSchema, WhereClause, QueryState, GroupedRow, GroupingModel, GroupingView, SummaryOp, RepresentativeRow, SummaryColumn, SelectColumn, PropertyViewState, SavedPropertyView, PropertyViewStorage, QueryLink, QuerySnapshot, ItemPropertyMode, ItemPageOptions, ItemDetailMode, ItemDetailsState, RelationshipAdapter, RowId, FormulaNode, FormulaValue, FormulaResult, ComputedColumn, FieldDef, ComputedColumnDraft, FormulaPlan, ColumnPreview, SavedQuery, StorageAdapter, AggOp, AggregationClause, AggregationResult, DistinctValuesResult, FieldStats, OrderByClause, Transport, ComputedColumnStore, ComputedExecution, QueryLinkOptions, ObjectReference, ResolvedObjectReference } from '@pythia-software/query-table-core';
+import { FieldSchema, WhereClause, QueryState, GroupedRow, GroupingModel, GroupingView, SummaryOp, RepresentativeRow, SummaryColumn, SelectColumn, PropertyViewState, SavedPropertyView, PropertyViewStorage, QueryLink, QuerySnapshot, ItemPropertyMode, ItemPageOptions, ItemDetailMode, ItemDetailsState, RelationshipAdapter, RowId, FormulaNode, FormulaValue, FormulaResult, ComputedColumn, FieldDef, ComputedColumnDraft, FormulaPlan, ColumnPreview, SavedQuery, StorageAdapter, AggOp, AggregationClause, AggregationResult, DistinctValuesResult, FieldStats, OrderByClause, Transport, ComputedExecution, ComputedColumnStore, QueryLinkOptions, ObjectReference, ResolvedObjectReference } from '@pythia-software/query-table-core';
 
 /** Filter controls for either the result query or grouping's source query. */
 type QueryFilterApi<Row> = Pick<QueryTableApi<Row>, "query" | "setQuery" | "loading" | "addFilter" | "updateFilter" | "removeFilter" | "clearFilters" | "updatePredicate" | "removePredicate" | "negatePredicate" | "reorderFilters" | "mergeFilters" | "filterValues" | "fieldStats">;
@@ -266,8 +266,15 @@ interface UseQueryTableOptions<Row> {
     /** Disable row-producing grouping for this instance. Enabled for complete client datasets by default. */
     grouping?: boolean;
     schema: FieldSchema<Row>;
-    /** Data access. Omit for a purely client-side table driven by `clientRows`. */
+    /** Row data access. Omit to filter, sort, and page `clientRows` locally. */
     transport?: Transport<Row>;
+    /** Metric-only data access; defaults to transport and never selects server row mode. */
+    metricTransport?: Transport<Row>;
+    /** Authoritative metric handshake; defaults to the existing row execution selection. */
+    metricExecution?: ComputedExecution;
+    /** Additional host readiness gate for committed-page metrics and previews.
+     * Does not delay remote allMatching requests. Re-evaluated on each render. */
+    metricRowsReady?: (query: QueryState) => boolean;
     /** Dataset already available in memory. Remote grouping/aggregation belongs
      * on the server; do not download a population to supply this option. */
     clientRows?: Row[];

package/dist/index.js

@@ -828,6 +828,8 @@ function evaluateFormulaRows(ast, inputs, signal, factory = createFormulaWorker)
 // src/useComputedColumns.ts
 function useComputedColumns(options) {
   const { schema, query, rows, transport, clientRows, workerFactory } = options;
+  const metricTransport = options.metricTransport ?? transport;
+  const metricExecution = options.metricExecution ?? options.execution;
   const store = useMemo3(
     () => options.store ?? memoryComputedColumnStore(),
     [options.store]
@@ -1042,7 +1044,7 @@ function useComputedColumns(options) {
         },
         aggregate: {
           measure: !!entry?.plan,
-          groupable: (!!transport?.fetchMetrics && transport.metricCapabilities?.version === 2 || !!transport?.fetchQueryV3) && !!options.execution?.fields[computedFieldName(def.id)]?.group && executionRevision(options.execution, def.id) === def.revision && !!entry?.plan && !hasRegex(entry.plan)
+          groupable: (!!metricTransport?.fetchMetrics && metricTransport.metricCapabilities?.version === 2 || !!metricTransport?.fetchQueryV3) && !!metricExecution?.fields[computedFieldName(def.id)]?.group && executionRevision(metricExecution, def.id) === def.revision && !!entry?.plan && !hasRegex(entry.plan)
         }
       };
     });
@@ -1076,6 +1078,8 @@ function useComputedColumns(options) {
     loading,
     transport,
     options.execution,
+    metricTransport,
+    metricExecution,
     options.serverComputed,
     options.serverExecution
   ]);
@@ -1189,7 +1193,7 @@ import {
   toServerQuery as toServerQuery2,
   queriesEqual as queriesEqual2,
   isOrGroup as isOrGroup2,
-  metricPlans as metricPlans3,
+  metricPlans as metricPlans2,
   validateMetric as validateMetric2,
   metricDependencies,
   isComputedField as isComputedField4,
@@ -1261,7 +1265,7 @@ function observeTransport(transport, publish, nextId) {
     }
   });
 }
-function useRequestActivity(source) {
+function useRequestActivity(source, metricSource) {
   const [entries, setEntries] = useState5([]);
   const sequence = useRef5(0), mounted = useRef5(true);
   useEffect5(() => {
@@ -1284,19 +1288,21 @@ function useRequestActivity(source) {
     () => setEntries((previous) => previous.filter((e) => e.status === "pending")),
     []
   );
+  const metricTransport = useMemo4(
+    () => !metricSource || metricSource === source ? transport : observeTransport(metricSource, publish, () => ++sequence.current),
+    [metricSource, source, transport, publish]
+  );
   const activity = useMemo4(
     () => ({ entries, clear }),
     [entries, clear]
   );
-  return { transport, activity };
+  return { transport, metricTransport, activity };
 }
 
 // src/useAggregations.ts
 import { useCallback as useCallback6, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef6, useState as useState6 } from "react";
 import {
-  metricComputationKey,
-  metricPlans as metricPlans2,
-  hasRegex as hasRegex3
+  metricComputationKey
 } from "@pythia-software/query-table-core";
 
 // src/metricExecution.ts
@@ -1319,6 +1325,9 @@ import {
 var abort = (signal) => {
   if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
 };
+function usesLocalMetricPage(clause, context) {
+  return !context.executeV3 && clause.scope === "shownRows" && (!context.transport?.fetchMetrics || context.transport.metricCapabilities?.version !== 2 || context.transport.metricCapabilities.shownRows !== true || !!clause.dateGrouping || metricPlans(clause, context.schema, context.resolveComputed).some(hasRegex2));
+}
 async function localMetrics(rows, query, context, signal) {
   const originalClauses = query.aggregations ?? [];
   const advanced = (query.aggregations ?? []).filter(
@@ -1433,16 +1442,13 @@ async function executeMetrics(query, context, signal) {
   const clauses = query.aggregations ?? [];
   if (!clauses.length) return { metrics: [] };
   if (context.executeV3) return context.executeV3(query, signal);
+  if (context.rowsReady === false && clauses.some((c) => usesLocalMetricPage(c, context)))
+    throw Error("Wait for the current table page before previewing shown-row metrics.");
   const supportsV2 = !!context.transport?.fetchMetrics && context.transport.metricCapabilities?.version === 2;
   if (context.clientRows && !supportsV2 && !context.transport?.fetchAggregations)
     return localMetrics(context.clientRows, query, context, signal);
-  const needsWorker = (c) => metricPlans(c, context.schema, context.resolveComputed).some(hasRegex2);
-  const shown = clauses.filter(
-    (c) => c.scope === "shownRows" && (!supportsV2 || needsWorker(c) || !!c.dateGrouping)
-  );
-  let matching = clauses.filter(
-    (c) => c.scope !== "shownRows" || supportsV2 && !needsWorker(c) && !c.dateGrouping
-  );
+  const shown = clauses.filter((c) => usesLocalMetricPage(c, context));
+  let matching = clauses.filter((c) => !shown.includes(c));
   const results = [];
   if (shown.length) {
     if (!context.rowsReady || !context.shownRows)
@@ -1608,140 +1614,153 @@ function loadedPath(row, path) {
 }
 
 // src/useAggregations.ts
-function useAggregations(query, schema, transport, clientRows, debounceMs, nonce, validateQuery, options = {}, enabled = true) {
-  const [results, setResults] = useState6(null);
-  const [loading, setLoading] = useState6(false);
-  const [error, setError] = useState6(null);
-  const latest = useRef6({
-    query,
-    schema,
-    transport,
-    clientRows,
-    options,
+function localPage(clause, context) {
+  try {
+    return usesLocalMetricPage(clause, context);
+  } catch {
+    return !context.executeV3 && clause.scope === "shownRows";
+  }
+}
+function useMetricBatch(query, clauses, context, debounceMs, nonce, validateQuery, enabled, page) {
+  const shown = clauses.some((c) => c.scope === "shownRows");
+  const key = JSON.stringify([
+    query.where,
+    metricComputationKey(clauses),
+    shown ? [query.orderBy, query.limit, query.offset] : null,
+    context.revisions ?? {},
+    context.execution ?? null,
+    context.now,
+    context.strictLocalMetrics,
+    context.queryContextKey,
+    page ? context.shownFields : null
+  ]);
+  const localDataset = !context.executeV3 && !(context.transport?.fetchMetrics && context.transport.metricCapabilities?.version === 2) && !context.transport?.fetchAggregations;
+  const pageReady = context.rowsReady ?? (localDataset && context.clientRows !== void 0);
+  const validationToken = useMemo5(() => ({}), [
+    key,
+    context.schema,
+    context.transport,
+    nonce,
     validateQuery,
     enabled
-  });
-  latest.current = {
-    query,
-    schema,
-    transport,
-    clientRows,
-    options,
+  ]);
+  const token = useMemo5(() => ({}), [
+    key,
+    context.schema,
+    context.transport,
+    localDataset ? context.clientRows : void 0,
+    debounceMs,
+    nonce,
     validateQuery,
-    enabled
-  };
-  const preview = useCallback6(
-    async (clauses, signal) => {
-      const current = latest.current;
-      if (!current.enabled) throw Error("Resolve the query link before previewing metrics.");
-      const draft = { ...current.query, aggregations: clauses };
-      current.validateQuery?.(draft);
-      return executeMetrics(
-        draft,
-        {
-          schema: current.schema,
-          transport: current.transport,
-          clientRows: current.clientRows,
-          ...current.options
-        },
-        signal
-      );
-    },
-    []
-  );
-  const shown = (query.aggregations ?? []).some((c) => c.scope === "shownRows");
-  const localPage = !options.executeV3 && shown && (!transport?.fetchMetrics || transport.metricCapabilities?.version !== 2 || (query.aggregations ?? []).some((clause) => {
-    if (clause.scope !== "shownRows") return false;
-    try {
-      return metricPlans2(clause, schema, options.resolveComputed).some(
-        hasRegex3
-      );
-    } catch {
-      return true;
-    }
-  }));
-  const key = useMemo5(
-    () => JSON.stringify([
-      query.where,
-      metricComputationKey(query.aggregations ?? []),
-      shown ? [query.orderBy, query.limit, query.offset] : null
-    ]),
-    [
-      query.where,
-      query.aggregations,
-      query.orderBy,
-      query.limit,
-      query.offset,
-      shown
-    ]
-  );
-  const dependencyKey = JSON.stringify([
-    options.revisions ?? {},
-    options.execution ?? null,
-    options.now,
-    options.strictLocalMetrics,
-    options.queryContextKey
+    enabled,
+    page,
+    context.workerFactory,
+    page ? context.shownRows : void 0,
+    page ? context.rowsReady : void 0,
+    page ? context.rowsError : void 0
   ]);
+  const latest = useRef6({ query, clauses, context, validateQuery });
+  latest.current = { query, clauses, context, validateQuery };
+  const [state, setState] = useState6(
+    { token, results: null, loading: enabled && clauses.length > 0, error: null }
+  );
   useEffect6(() => {
-    if (!enabled || !latest.current.query.aggregations?.length) {
-      setResults(null);
-      setLoading(false);
-      setError(null);
-      return;
-    }
+    if (!enabled || !latest.current.clauses.length) return;
     const ac = new AbortController();
-    setLoading(true);
-    setResults(null);
-    if (localPage && transport && !options.rowsReady) {
-      try {
-        latest.current.validateQuery?.(latest.current.query);
-        setError(options.rowsError ?? null);
-        if (options.rowsError) setLoading(false);
-      } catch (e) {
-        setError(e instanceof Error ? e : Error(String(e)));
-        setLoading(false);
-      }
-      return;
-    }
     const timer = setTimeout(() => {
-      setError(null);
+      const current = latest.current;
       try {
-        latest.current.validateQuery?.(latest.current.query);
+        current.validateQuery?.(current.query);
       } catch (e) {
-        setError(e instanceof Error ? e : Error(String(e)));
-        setLoading(false);
+        setState({ token, validationToken, results: null, loading: false, error: e instanceof Error ? e : Error(String(e)) });
         return;
       }
-      void preview(latest.current.query.aggregations ?? [], ac.signal).then((result) => {
-        if (!ac.signal.aborted) setResults(result);
+      if (page && !pageReady) return;
+      void executeMetrics({ ...current.query, aggregations: current.clauses }, current.context, ac.signal).then((results) => {
+        if (!ac.signal.aborted) setState({ token, results, loading: false, error: null });
       }).catch((e) => {
-        if (!ac.signal.aborted)
-          setError(e instanceof Error ? e : Error(String(e)));
-      }).finally(() => {
-        if (!ac.signal.aborted) setLoading(false);
+        if (!ac.signal.aborted) setState({ token, results: null, loading: false, error: e instanceof Error ? e : Error(String(e)) });
       });
     }, debounceMs);
     return () => {
       ac.abort();
       clearTimeout(timer);
     };
-  }, [
-    key,
-    schema,
-    transport,
-    clientRows,
-    debounceMs,
-    nonce,
-    validateQuery,
-    enabled,
-    dependencyKey,
-    localPage,
-    localPage ? options.shownRows : void 0,
-    localPage ? options.rowsReady : void 0,
-    localPage ? options.rowsError : void 0,
-    preview
+  }, [token]);
+  if (!enabled || !clauses.length) return { results: null, loading: false, error: null };
+  if (state.validationToken === validationToken && state.error) return state;
+  if (page && !pageReady && context.rowsError)
+    return { results: null, loading: false, error: context.rowsError };
+  if (state.token !== token) return { results: null, loading: true, error: null };
+  return state;
+}
+function useAggregations(query, schema, transport, clientRows, debounceMs, nonce, validateQuery, options = {}, enabled = true) {
+  const context = { schema, transport, clientRows, ...options };
+  const clauses = query.aggregations ?? [];
+  const pageClauses = clauses.filter((c) => localPage(c, context));
+  const otherClauses = clauses.filter((c) => !pageClauses.includes(c));
+  const other = useMetricBatch(query, otherClauses, context, debounceMs, nonce, validateQuery, enabled, false);
+  const page = useMetricBatch(query, pageClauses, context, debounceMs, nonce, validateQuery, enabled, true);
+  const previewKey = JSON.stringify([
+    query.where,
+    query.orderBy,
+    query.limit,
+    query.offset,
+    metricComputationKey(clauses),
+    options.revisions,
+    options.execution,
+    options.now,
+    options.strictLocalMetrics,
+    options.queryContextKey
   ]);
-  return { results, loading, error, preview };
+  const previewToken = useMemo5(() => ({}), [previewKey, schema, transport, nonce, validateQuery, enabled, options.workerFactory]);
+  const pageKey = JSON.stringify([query.orderBy, query.limit, query.offset, options.shownFields]);
+  const pageToken = useMemo5(() => ({}), [previewToken, pageKey, clientRows, options.shownRows, options.rowsReady, options.rowsError]);
+  const latest = useRef6({ query, context, validateQuery, enabled, previewToken, pageToken });
+  latest.current = { query, context, validateQuery, enabled, previewToken, pageToken };
+  const previews = useRef6(/* @__PURE__ */ new Set());
+  useEffect6(() => () => {
+    for (const pending of previews.current)
+      if (pending.previewToken === previewToken) pending.controller.abort();
+  }, [previewToken]);
+  useEffect6(() => () => {
+    for (const pending of previews.current)
+      if (pending.page && pending.pageToken === pageToken) pending.controller.abort();
+  }, [pageToken]);
+  const preview = useCallback6(async (draftClauses, signal) => {
+    const current = latest.current;
+    if (!current.enabled) throw Error("Resolve the query link before previewing metrics.");
+    const draft = { ...current.query, aggregations: draftClauses };
+    current.validateQuery?.(draft);
+    const pending = {
+      controller: new AbortController(),
+      page: draftClauses.some((c) => localPage(c, current.context)),
+      previewToken: current.previewToken,
+      pageToken: current.pageToken
+    };
+    const cancel = () => pending.controller.abort();
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted) cancel();
+    previews.current.add(pending);
+    try {
+      const result = await executeMetrics(draft, current.context, pending.controller.signal);
+      if (pending.controller.signal.aborted || current.previewToken !== latest.current.previewToken || pending.page && current.pageToken !== latest.current.pageToken)
+        throw new DOMException("Aborted", "AbortError");
+      return result;
+    } finally {
+      previews.current.delete(pending);
+      signal?.removeEventListener("abort", cancel);
+    }
+  }, []);
+  const orderKey = JSON.stringify(clauses.map((c) => c.id));
+  const results = useMemo5(() => {
+    if (!pageClauses.length) return other.results;
+    if (!otherClauses.length) return page.results;
+    if (!page.results || !other.results) return null;
+    const byId = new Map([...page.results.metrics, ...other.results.metrics].map((m) => [m.id, m]));
+    return { metrics: clauses.flatMap((c) => byId.get(c.id) ?? []) };
+  }, [orderKey, pageClauses.length, otherClauses.length, page.results, other.results]);
+  return { results, loading: page.loading || other.loading, error: page.error ?? other.error, preview };
 }
 
 // src/useSelection.ts
@@ -2248,7 +2267,7 @@ function useQueryTable(opts) {
   const active = opts.active !== false;
   const urlSyncEnabled = opts.syncUrl === true;
   const syncUrl = urlSyncEnabled && active;
-  const { transport: metadataTransport, activity: requestActivity } = useRequestActivity(sourceTransport);
+  const { transport: metadataTransport, metricTransport, activity: requestActivity } = useRequestActivity(sourceTransport, opts.metricTransport);
   const transport = metadataTransport;
   const storage = useMemo9(
     () => opts.storage ?? memoryStorageAdapter(),
@@ -2478,6 +2497,8 @@ function useQueryTable(opts) {
     serverComputed,
     ...serverExecution ? { serverExecution } : {},
     ...opts.computedExecution ? { execution: opts.computedExecution } : {},
+    ...metricTransport ? { metricTransport } : {},
+    ...opts.metricExecution ? { metricExecution: opts.metricExecution } : {},
     ...opts.computedColumnStore ? { store: opts.computedColumnStore } : {},
     ...opts.formulaWorkerFactory ? { workerFactory: opts.formulaWorkerFactory } : {},
     ...transport ? { transport } : {},
@@ -2487,18 +2508,19 @@ function useQueryTable(opts) {
     (name) => isComputedField4(name) ? computed.compile(`[${name.replace(/]/g, "]] ".trim())}]`) : void 0,
     [computed.compile]
   );
+  const metricCompileSchema = useMemo9(() => opts.metricExecution ? sourceExecutionSchema(displaySchema, opts.metricExecution, computed.definitions) : displaySchema, [displaySchema, opts.metricExecution, computed.definitions]);
   const metricCompile = useCallback12(
     (clause) => {
       const diagnostics = validateMetric2(
         clause,
-        displaySchema,
+        metricCompileSchema,
         resolveComputed
       );
       if (diagnostics.length)
         throw new Error(diagnostics.map((d) => d.message).join(" "));
-      return metricPlans3(clause, displaySchema, resolveComputed);
+      return metricPlans2(clause, metricCompileSchema, resolveComputed);
     },
-    [displaySchema, resolveComputed]
+    [metricCompileSchema, resolveComputed]
   );
   const computedRevisions = useMemo9(
     () => Object.fromEntries(computed.definitions.map((d) => [d.id, d.revision])),
@@ -2759,11 +2781,18 @@ function useQueryTable(opts) {
   const dataToken = useRef9(0);
   const dataVersion = useMemo9(
     () => ++dataToken.current,
-    [schema, transport, clientRows, nonce, definitionKey, executionKey]
+    [schema, transport, clientRows, rows, nonce, definitionKey, executionKey, metricTransport, opts.metricExecution]
+  );
+  const metricRowsReady = pageReady && (opts.metricRowsReady?.(query) ?? true);
+  const metricExecution = opts.metricExecution ?? (opts.computedExecution ? pageReady && serverExecution ? serverExecution : opts.computedExecution : void 0);
+  const v3MetricExecution = opts.metricExecution ?? opts.computedExecution;
+  const metricSourceCatalogue = useMemo9(
+    () => sourceExecutionSchema(sourceSchema, v3MetricExecution),
+    [sourceSchema, v3MetricExecution]
   );
   const executeV3Metrics = useCallback12(async (metricQuery, signal) => {
-    if (!transport?.fetchQueryV3 || transport.queryCapabilities?.version !== 3) throw Error("The v3 query executor is unavailable.");
-    const capabilities = transport.queryCapabilities;
+    if (!metricTransport?.fetchQueryV3 || metricTransport.queryCapabilities?.version !== 3) throw Error("The v3 query executor is unavailable.");
+    const capabilities = metricTransport.queryCapabilities;
     const refused = /* @__PURE__ */ new Map();
     for (const clause of metricQuery.aggregations ?? []) {
       const issue = metricPopulationError2(clause, { filters: capabilities.metricFilters, minCount: capabilities.metricMinCount });
@@ -2777,12 +2806,12 @@ function useQueryTable(opts) {
         query.grouping ? { ...scoped, grouping: query.grouping } : scoped,
         sourceSchema,
         capabilities,
-        opts.computedExecution,
+        v3MetricExecution,
         { now: groupingNow ?? (opts.evaluationNow ?? Date.now)(), rows: false }
       );
       if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
-      const result = await transport.fetchQueryV3(request, signal);
-      validateQueryResultV3(result, request, query.grouping ? schema : sourceCatalogue);
+      const result = await metricTransport.fetchQueryV3(request, signal);
+      validateQueryResultV3(result, request, query.grouping ? schema : metricSourceCatalogue);
       metrics = result.metrics;
     }
     if (!refused.size) return { metrics };
@@ -2793,7 +2822,7 @@ function useQueryTable(opts) {
       const metric = byId.get(clause.id);
       return metric ? [metric] : [];
     }) };
-  }, [transport, sourceSchema, sourceCatalogue, schema, opts.computedExecution, groupKey, groupingNow, opts.evaluationNow]);
+  }, [metricTransport, sourceSchema, metricSourceCatalogue, schema, v3MetricExecution, groupKey, groupingNow, opts.evaluationNow]);
   const previewGrouping = useCallback12(async (draft, signal) => {
     if (!active || !storageReady || restoration.loading || restoration.error) throw Error("Wait for query restoration before previewing groups.");
     if (!transport?.fetchQueryV3 || !transport.queryCapabilities?.groupedRows || !draft.grouping) throw Error("The server group preview is unavailable.");
@@ -2812,23 +2841,21 @@ function useQueryTable(opts) {
   const aggState = useAggregations(
     executionQuery,
     schema,
-    transport,
+    metricTransport,
     clientRows,
     debounceMs,
     nonce,
     validateExecution,
     {
-      ...transport?.fetchQueryV3 && transport.queryCapabilities?.version === 3 && (query.grouping || query.aggregations?.some((metric) => metric.dateGrouping) || query.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => isComputedField4(predicate.field)))) ? { executeV3: executeV3Metrics, queryContextKey: groupKey } : {},
+      ...metricTransport?.fetchQueryV3 && metricTransport.queryCapabilities?.version === 3 && (query.grouping || query.aggregations?.some((metric) => metric.dateGrouping) || query.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => isComputedField4(predicate.field)))) ? { executeV3: executeV3Metrics, queryContextKey: groupKey } : {},
       ...groupingNow !== void 0 ? { now: groupingNow, strictLocalMetrics: true } : {},
       shownRows: rows,
-      rowsReady: pageReady,
+      rowsReady: metricRowsReady,
       rowsError: error,
       ...transport ? { shownFields: committedFields } : {},
       resolveComputed,
       revisions: computedRevisions,
-      ...opts.computedExecution ? {
-        execution: pageReady && serverExecution ? serverExecution : opts.computedExecution
-      } : {},
+      ...metricExecution ? { execution: metricExecution } : {},
       ...opts.formulaWorkerFactory ? { workerFactory: opts.formulaWorkerFactory } : {}
     },
     active && storageReady && !restoration.loading && !restoration.error
@@ -3100,7 +3127,7 @@ function useQueryTable(opts) {
       preview: aggState.preview,
       replace: replaceAggregations,
       compile: metricCompile,
-      contextKey: `${dataVersion}:${pageContext}:${pageReady}:${JSON.stringify(query.where)}`
+      contextKey: `${dataVersion}:${pageContext}:${metricRowsReady}:${JSON.stringify(query.where)}`
     }),
     [
       query.aggregations,
@@ -3116,7 +3143,7 @@ function useQueryTable(opts) {
       replaceAggregations,
       metricCompile,
       pageContext,
-      pageReady,
+      metricRowsReady,
       dataVersion,
       query.where
     ]