@pythia-software/query-table-react 0.9.9 → 1.0.1

package/dist/index.js

@@ -339,12 +339,15 @@ import {
   createGroupingModel,
   prepareGrouping,
   withoutGrouping as withoutGrouping2,
-  sourceExecutionSchema as sourceExecutionSchema2,
-  toQueryRequestV3 as toQueryRequestV32,
-  validateQueryResultV3 as validateQueryResultV32,
-  metricPopulationError as metricPopulationError2
+  sourceExecutionSchema as sourceExecutionSchema3,
+  toQueryRequestV3 as toQueryRequestV33,
+  validateQueryResultV3 as validateQueryResultV33,
+  fetchDistinctValuesV3,
+  fetchFieldStatsV3,
+  fetchRowV3,
+  isPushdownFilter
 } from "@pythia-software/query-table-core";
-import { ITEM_DETAILS_COLUMN, itemPageFields } from "@pythia-software/query-table-core";
+import { ITEM_DETAILS_COLUMN, itemPageFields, QueryError as QueryError2 } from "@pythia-software/query-table-core";
 
 // src/useItemDetails.ts
 import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
@@ -577,6 +580,10 @@ function useDetailProperties(mode, schema, config, query, setQuery, enabled, rea
   }, [enabled, queryViewKey, localViewKey, properties.loading, properties.setView, setQuery]);
   return properties;
 }
+function projectedFields(schema, row) {
+  const keys = new Set(Object.keys(row));
+  return schema.fields.filter((field) => keys.has(field.name) || keys.has((field.source.kind === "backend" ? field.source.path ?? field.name : field.name).split(".")[0])).map((field) => field.name);
+}
 function useItemDetails({
   schema,
   query,
@@ -585,7 +592,7 @@ function useItemDetails({
   rows,
   clientRows,
   rowId,
-  transport,
+  fetchRow,
   refreshKey,
   links,
   queryReady = true,
@@ -621,7 +628,9 @@ function useItemDetails({
   const hasLookup = Boolean(lookupRow);
   const hasCustomLoad = Boolean(customLoad);
   const sourceType = config?.objectType ?? detailSchema.name;
-  const fallbackRows = !customLoad && !clientRows && !transport?.fetchRow ? rows : void 0;
+  const fallbackRows = !customLoad && !clientRows && !fetchRow ? rows : void 0;
+  const detailSchemaRef = useRef3(detailSchema);
+  detailSchemaRef.current = detailSchema;
   const loadRow = useCallback3(async (id, signal) => {
     if (lookupRef.current) return lookupRef.current(id) ?? null;
     if (customLoadRef.current) return customLoadRef.current(id, signal);
@@ -629,13 +638,13 @@ function useItemDetails({
       const row2 = clientRows.find((row3) => rowId(row3) === id);
       return row2 ? { row: row2 } : null;
     }
-    if (transport?.fetchRow) {
-      const row2 = await transport.fetchRow(id, signal);
-      return row2 ? { row: row2 } : null;
+    if (fetchRow) {
+      const row2 = await fetchRow(id, signal);
+      return row2 ? { row: row2, loadedFields: projectedFields(detailSchemaRef.current, row2) } : null;
     }
     const row = rows.find((row2) => rowId(row2) === id);
-    return row ? { row, loadedFields: Object.keys(row) } : null;
-  }, [hasLookup, hasCustomLoad, sourceType, clientRows, transport?.fetchRow, fallbackRows, rowId]);
+    return row ? { row, loadedFields: projectedFields(detailSchemaRef.current, row) } : null;
+  }, [hasLookup, hasCustomLoad, sourceType, clientRows, fetchRow, fallbackRows, rowId]);
   const [retryKey, setRetryKey] = useState3(0);
   const [result, setResult] = useState3({ source: void 0, epoch: "", id: void 0, record: null, loading: false, error: null });
   const activeId = enabled && !lookupRow ? active?.id : void 0;
@@ -768,116 +777,53 @@ function useItemDetails({
 }
 
 // src/computedExecution.ts
-import {
-  predicatesOf as predicatesOf2,
-  isComputedField,
-  readFieldValue
-} from "@pythia-software/query-table-core";
 function executionRevision(execution, id) {
   return execution?.resolvedRevisions[id] ?? execution?.resolvedRevisions[`@computed/${id}`];
 }
-function validateComputedResponse(request, result, schema) {
-  const execution = result.execution;
-  if (result.version !== 2 || !execution || execution.profile !== request.profile || request.planToken && execution.planToken !== request.planToken || request.snapshot !== void 0 && execution.snapshot !== request.snapshot)
-    throw Error(
-      "Server computed execution identity changed. Refresh the handshake."
-    );
-  const executed = /* @__PURE__ */ new Set([
-    ...request.select.filter(isComputedField),
-    ...request.orderBy.map((term) => term.field).filter(isComputedField),
-    ...request.where.flatMap((term) => predicatesOf2(term).map((predicate) => predicate.field)).filter(isComputedField)
-  ]);
-  for (const [name, revision] of Object.entries(request.expectedRevisions)) {
-    const id = name.replace(/^@computed\//, "");
-    if (!executed.has(`@computed/${id}`)) continue;
-    if (executionRevision(execution, id) !== revision)
-      throw Error(
-        "Server computed definition revision changed. Refresh the handshake."
-      );
-  }
-  const idField = schema.fields.find((f) => f.name === schema.idField);
-  if (!idField)
-    throw Error("Stable row identity is required for computed values.");
-  const ids = new Set(result.rows.map((row) => readFieldValue(idField, row)));
-  if (ids.has(null) || ids.has(void 0) || ids.size !== result.rows.length)
-    throw Error(
-      "Computed response contains missing or duplicate row identities."
-    );
-  const sidecars = new Map(
-    result.computed.map((item) => [item.id, item.values])
-  );
-  if (sidecars.size !== result.computed.length || [...sidecars.keys()].some((id) => !ids.has(id)))
-    throw Error("Computed sidecars do not match returned row identities.");
-  for (const field of request.select.filter(isComputedField)) {
-    const id = field.slice("@computed/".length);
-    for (const rowId of ids) {
-      const value = sidecars.get(rowId)?.[id];
-      if (!value || value.value !== null && !["string", "number", "boolean"].includes(typeof value.value) || typeof value.value === "number" && !Number.isFinite(value.value))
-        throw Error(`Missing or invalid server computed result: ${field}.`);
-    }
-  }
-}
 
 // src/previewRows.ts
 import {
-  predicatesOf as predicatesOf3,
+  predicatesOf as predicatesOf2,
   sourceExecutionSchema,
   toQueryRequestV3,
-  toServerQuery,
-  toServerQueryV2,
   validateQueryResultV3
 } from "@pythia-software/query-table-core";
 async function fetchPreviewRows(transport, query, schema, execution, definitions, now, signal, baseSchema = schema) {
   if (signal.aborted) throw new DOMException("Aborted", "AbortError");
   const sourceSchema = sourceExecutionSchema(baseSchema, execution, definitions);
-  let result;
-  const computedFilter = query.where.some((term) => predicatesOf3(term).some((predicate) => predicate.field.startsWith("@computed/")));
-  if (transport.fetchRowsV2 && execution && !query.grouping && !computedFilter) {
-    const request = toServerQueryV2(query, sourceSchema, execution);
-    if (request.diagnostics.length)
-      throw Error(request.diagnostics.map((issue) => issue.message).join(" "));
-    for (const definition of definitions) {
-      if (executionRevision(execution, definition.id) !== definition.revision && (request.select.includes(`@computed/${definition.id}`) || request.orderBy.some((term) => term.field === `@computed/${definition.id}`) || request.where.some((term) => predicatesOf3(term).some((predicate) => predicate.field === `@computed/${definition.id}`))))
-        throw Error("Computed definitions changed. Refresh the server execution handshake.");
-    }
-    const response = await transport.fetchRowsV2(request, signal);
-    validateComputedResponse(request, response, sourceSchema);
-    result = response;
-  } else if (transport.fetchQueryV3 && transport.queryCapabilities?.version === 3) {
-    const request = toQueryRequestV3(
-      { ...query, aggregations: [] },
-      sourceSchema,
-      transport.queryCapabilities,
-      execution,
-      { now }
-    );
-    if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
-    const response = await transport.fetchQueryV3(request, signal);
-    validateQueryResultV3(response, request, query.grouping ? schema : sourceSchema);
-    result = { rows: response.rows, total: response.total };
-  } else if (transport.fetchRows && !query.grouping && !(computedFilter && transport.fetchRowsV2 && execution)) {
-    result = await transport.fetchRows(toServerQuery(query, schema), signal);
-  } else {
-    throw Error("Row execution requires fetchRows, negotiated fetchRowsV2, or negotiated fetchQueryV3.");
-  }
+  const request = toQueryRequestV3(
+    { ...query, aggregations: [] },
+    sourceSchema,
+    transport.queryCapabilities,
+    execution,
+    { now }
+  );
+  const executed = /* @__PURE__ */ new Set([
+    ...request.result.select,
+    ...request.result.orderBy.map((term) => term.field),
+    ...[...request.source.where, ...request.result.where].flatMap((term) => predicatesOf2(term).map((predicate) => predicate.field))
+  ]);
+  for (const definition of definitions)
+    if (executed.has(`@computed/${definition.id}`) && executionRevision(execution, definition.id) !== definition.revision)
+      throw Error("Computed definitions changed. Refresh the server execution handshake.");
+  const response = await transport.fetchQueryV3(request, signal);
   if (signal.aborted) throw new DOMException("Aborted", "AbortError");
-  if (!Number.isSafeInteger(result.total) || result.total < 0 || !Array.isArray(result.rows) || result.rows.length > query.limit)
-    throw Error("Invalid preview row response.");
-  return result;
+  validateQueryResultV3(response, request, query.grouping ? schema : sourceSchema);
+  if (response.rows.length > query.limit) throw Error("Invalid preview row response.");
+  return { rows: response.rows, total: response.total };
 }
 
 // src/useComputedColumns.ts
 import { useCallback as useCallback4, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef4, useState as useState4 } from "react";
 import {
-  predicatesOf as predicatesOf4,
   isGroupLinkField,
   applyQuery,
   compileFormula,
   computedFieldName,
   groupPreview,
-  isComputedField as isComputedField2,
+  isComputedField,
   memoryComputedColumnStore,
-  readFieldValue as readFieldValue2,
+  readFieldValue,
   validateComputedColumn,
   isSelectable,
   hasRegex
@@ -1036,7 +982,7 @@ function useComputedColumns(options) {
       const stack = new Set(editingId ? [editingId] : []);
       let expanded = 0;
       const resolve = (name) => {
-        if (!isComputedField2(name)) return void 0;
+        if (!isComputedField(name)) return void 0;
         const id = name.slice("@computed/".length), def = definitions.find((d) => d.id === id);
         if (!def) throw new Error(`Computed column unavailable: ${id}`);
         if (stack.has(id))
@@ -1094,7 +1040,7 @@ function useComputedColumns(options) {
         const values = /* @__PURE__ */ Object.create(null);
         for (const name of plan.dependencies) {
           const field = inputFields.find((f) => f.name === name);
-          const raw = readFieldValue2(field, row);
+          const raw = readFieldValue(field, row);
           values[name] = raw instanceof Date ? raw.toISOString() : raw;
         }
         size += JSON.stringify(values).length;
@@ -1108,14 +1054,14 @@ function useComputedColumns(options) {
     [inputFields]
   );
   const activeSelect = query.select.length ? query.select : schema.defaultSelect ?? [];
-  const activeIds = activeSelect.filter((c) => isComputedField2(c.field)).map((c) => c.field.slice("@computed/".length)).sort().join(",");
+  const activeIds = activeSelect.filter((c) => isComputedField(c.field)).map((c) => c.field.slice("@computed/".length)).sort().join(",");
   const [evaluated, setEvaluated] = useState4(null);
   useEffect4(() => {
     const ac = new AbortController();
     const values = /* @__PURE__ */ new Map();
     void (async () => {
       for (const id of activeIds.split(",").filter(Boolean)) {
-        if (options.execution?.fields[computedFieldName(id)]?.select && (transport?.fetchRowsV2 || transport?.fetchQueryV3))
+        if (options.execution?.fields[computedFieldName(id)]?.select && transport)
           continue;
         const entry = plans.get(id);
         if (!entry?.plan) continue;
@@ -1167,7 +1113,7 @@ function useComputedColumns(options) {
           dependencies: entry?.plan ? backendDependencies(entry.plan) : [],
           accessor: (row) => {
             if (entry?.error) return { computedError: entry.error };
-            if (options.execution?.fields[computedFieldName(def.id)]?.select && (transport?.fetchRowsV2 || transport?.fetchQueryV3)) {
+            if (options.execution?.fields[computedFieldName(def.id)]?.select && transport) {
               if (options.serverExecution?.profile !== options.execution.profile || options.serverExecution?.planToken !== options.execution.planToken || options.serverExecution?.snapshot !== options.execution.snapshot || executionRevision(options.execution, def.id) !== def.revision || executionRevision(options.serverExecution, def.id) !== def.revision)
                 return {
                   computedError: "Definition changed or values are pending. Refresh the server handshake."
@@ -1175,7 +1121,7 @@ function useComputedColumns(options) {
               const idField = schema.fields.find(
                 (f) => f.name === schema.idField
               );
-              const id = idField ? readFieldValue2(idField, row) : null;
+              const id = idField ? readFieldValue(idField, row) : null;
               const server = id === null ? void 0 : options.serverComputed?.get(id)?.[def.id];
               return server ? server.error ? { computedError: server.error.code } : server.value : { computedError: "Server computed result unavailable." };
             }
@@ -1185,16 +1131,16 @@ function useComputedColumns(options) {
         },
         filter: { enabled: options.execution?.fields[computedFieldName(def.id)]?.filter === true && executionRevision(options.execution, def.id) === def.revision && !!entry?.plan && !hasRegex(entry.plan) },
         sort: {
-          enabled: !!(transport?.fetchRowsV2 || transport?.fetchQueryV3) && !!options.execution?.fields[computedFieldName(def.id)]?.sort && executionRevision(options.execution, def.id) === def.revision && !!entry?.plan && !hasRegex(entry.plan)
+          enabled: !!transport && !!options.execution?.fields[computedFieldName(def.id)]?.sort && executionRevision(options.execution, def.id) === def.revision && !!entry?.plan && !hasRegex(entry.plan)
         },
         aggregate: {
           measure: !!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)
+          groupable: !!metricTransport && !!metricExecution?.fields[computedFieldName(def.id)]?.group && executionRevision(metricExecution, def.id) === def.revision && !!entry?.plan && !hasRegex(entry.plan)
         }
       };
     });
     for (const col of activeSelect)
-      if (isComputedField2(col.field) && !fields.some((f) => f.name === col.field))
+      if (isComputedField(col.field) && !fields.some((f) => f.name === col.field))
         fields.push({
           name: col.field,
           label: col.field.slice(10),
@@ -1271,9 +1217,7 @@ function useComputedColumns(options) {
             offset: 0
           };
           const now = options.now ?? Date.now();
-          const computedFilter = request.where.some((term) => predicatesOf4(term).some((predicate) => isComputedField2(predicate.field)));
-          const v3 = !(transport.fetchRowsV2 && options.execution && !request.grouping && !computedFilter) && transport.fetchQueryV3 && transport.queryCapabilities?.version === 3;
-          const pageSize = Math.min(500, v3 ? transport.queryCapabilities.maxRows : 500);
+          const pageSize = Math.min(500, transport.queryCapabilities.maxRows);
           if (!Number.isInteger(pageSize) || pageSize < 1) throw Error("Invalid negotiated preview row limit.");
           while (batch.length < count) {
             const res = await fetchPreviewRows(
@@ -1361,41 +1305,34 @@ import {
   memoryStorageAdapter,
   normalizeQueryState as normalizeQueryState3,
   parseHostQueryState,
-  readFieldValue as readFieldValue4,
+  readFieldValue as readFieldValue3,
   selectedFields as selectedFields2,
-  toServerQuery as toServerQuery2,
+  toServerQuery,
   queriesEqual as queriesEqual2,
   isWhereConjunction as isWhereConjunction2,
   isWhereGroup,
-  predicatesOf as predicatesOf6,
+  predicatesOf as predicatesOf4,
+  opsForField as opsForField2,
   metricPlans as metricPlans2,
   validateMetric as validateMetric2,
   metricDependencies as metricDependencies2,
-  isComputedField as isComputedField4,
+  isComputedField as isComputedField3,
   computedFieldName as computedFieldName2,
-  toServerQueryV2 as toServerQueryV22,
   groupKeyField,
   groupKeyFields as groupKeyFields2
 } from "@pythia-software/query-table-core";
 
 // src/useRequestActivity.ts
 import { useCallback as useCallback5, useEffect as useEffect5, useMemo as useMemo4, useRef as useRef5, useState as useState5 } from "react";
-var methods = /* @__PURE__ */ new Set([
-  "fetchRows",
-  "fetchRowsV2",
-  "fetchQueryV3",
-  "fetchMetrics",
-  "fetchAggregations",
-  "fetchRow",
-  "fetchDistinctValues",
-  "fetchFieldStats"
-]);
+function requestKind(request) {
+  return request?.distinct ? "DistinctValues" : request?.rows ? "Rows" : "Metrics";
+}
 function observeTransport(transport, publish, nextId) {
   const wrappers = /* @__PURE__ */ new Map();
   return new Proxy(Object.create(transport), {
     get(_target, key) {
       const method = Reflect.get(transport, key, transport);
-      if (!methods.has(String(key)) || typeof method !== "function")
+      if (key !== "fetchQueryV3" || typeof method !== "function")
         return method;
       if (!wrappers.has(key))
         wrappers.set(key, async (...args) => {
@@ -1403,7 +1340,7 @@ function observeTransport(transport, publish, nextId) {
           const start = performance.now();
           const entry = {
             id: nextId(),
-            kind: String(key).replace(/^fetch/, ""),
+            kind: requestKind(args[0]),
             startedAt: Date.now(),
             status: "pending"
           };
@@ -1484,6 +1421,7 @@ import {
 
 // src/metricExecution.ts
 import {
+  QueryError,
   applyAggregations,
   normalizeQueryState as normalizeQueryState2,
   evaluateMetrics,
@@ -1493,25 +1431,77 @@ import {
   metricPopulationError,
   hasMetricSeries,
   planMetricSeries,
-  predicatesOf as predicatesOf5,
-  toAggregationQuery,
-  toMetricQuery,
+  predicatesOf as predicatesOf3,
+  sourceExecutionSchema as sourceExecutionSchema2,
+  toQueryRequestV3 as toQueryRequestV32,
+  validateQueryResultV3 as validateQueryResultV32,
   validateMetric,
   selectMetricShownRows,
-  readFieldValue as readFieldValue3,
+  readFieldValue as readFieldValue2,
   resolveFieldName,
-  isComputedField as isComputedField3
+  isComputedField as isComputedField2
 } from "@pythia-software/query-table-core";
 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));
+  if (clause.scope !== "shownRows") return false;
+  if (!context.executeV3 && !context.transport) return true;
+  if (context.transport?.queryCapabilities.regexAggregateExpressions) return false;
+  try {
+    return metricPlans(clause, context.schema, context.resolveComputed).some(hasRegex2);
+  } catch {
+    return false;
+  }
+}
+async function executeV3Metrics(transport, query, baseSchema, resultSchema, execution, now, signal) {
+  const capabilities = transport.queryCapabilities;
+  const refused = /* @__PURE__ */ new Map();
+  for (const clause of query.aggregations ?? []) {
+    if (clause.unsupportedOp) {
+      refused.set(clause.id, new QueryError("invalid_metric", `Metric ${clause.id} uses an unsupported operation: ${clause.unsupportedOp}.`, { metricId: clause.id }));
+      continue;
+    }
+    const issue = metricPopulationError(clause, { filters: capabilities.metricFilters, minCount: capabilities.metricMinCount, minCountMeasures: capabilities.metricMinCountMeasures });
+    if (issue) refused.set(clause.id, new QueryError("capability_unsupported", issue, { metricId: clause.id }));
+  }
+  let runnable = (query.aggregations ?? []).filter((clause) => !refused.has(clause.id));
+  const refusal = (q) => {
+    try {
+      toQueryRequestV32(q, baseSchema, capabilities, execution, { now, rows: false });
+    } catch (error) {
+      if (error instanceof QueryError) return error;
+      throw error;
+    }
+  };
+  const unpaged = { ...query, orderBy: [], offset: 0 };
+  const shown = runnable.filter((clause) => clause.scope === "shownRows");
+  const page = shown.length ? refusal({ ...query, aggregations: [] }) : void 0;
+  if (page && !refusal({ ...unpaged, aggregations: [] })) {
+    for (const clause of shown) refused.set(clause.id, page);
+    runnable = runnable.filter((clause) => clause.scope !== "shownRows");
+  }
+  let metrics = [];
+  if (runnable.length) {
+    const paged = runnable.some((clause) => clause.scope === "shownRows");
+    const request = toQueryRequestV32({ ...paged ? query : unpaged, aggregations: runnable }, baseSchema, capabilities, execution, { now, rows: false });
+    const result = await transport.fetchQueryV3(request, signal);
+    validateQueryResultV32(result, request, resultSchema);
+    metrics = result.metrics;
+  }
+  if (!refused.size) return { metrics };
+  const byId = new Map(metrics.map((metric) => [metric.id, metric]));
+  return { metrics: (query.aggregations ?? []).flatMap((clause) => {
+    const issue = refused.get(clause.id);
+    if (issue) return [{ id: clause.id, buckets: [], error: issue.message, errorCode: issue.code }];
+    const metric = byId.get(clause.id);
+    return metric ? [metric] : [];
+  }) };
 }
 async function localMetrics(rows, query, context, signal) {
   const originalClauses = query.aggregations ?? [];
   const advanced = (query.aggregations ?? []).filter(
-    (c) => context.strictLocalMetrics || c.dateGrouping || isComputedField3(c.field ?? "") || c.groupBy.some(isComputedField3) || c.diagnostics?.length || c.expression !== void 0 || c.expressionY !== void 0 || c.scope !== void 0 || c.distribution || c.sort || c.groupLimit !== void 0 || c.where !== void 0 || c.minCount !== void 0 || hasMetricSeries(c)
+    (c) => context.strictLocalMetrics || c.dateGrouping || isComputedField2(c.field ?? "") || c.groupBy.some(isComputedField2) || c.diagnostics?.length || c.expression !== void 0 || c.expressionY !== void 0 || c.scope !== void 0 || c.distribution || c.sort || c.groupLimit !== void 0 || c.where !== void 0 || c.minCount !== void 0 || hasMetricSeries(c)
   );
   if (advanced.length && (originalClauses.length > 20 || normalizeQueryState2(query).aggregations?.length !== originalClauses.length))
     return evaluateMetrics(rows, query, context.schema, {
@@ -1545,7 +1535,7 @@ async function localMetrics(rows, query, context, signal) {
       context.resolveComputed
     );
     if (diagnostics.length)
-      throw Error(diagnostics.map((d) => d.message).join(" "));
+      throw new QueryError("invalid_metric", diagnostics.map((d) => d.message).join(" "), { metricId: clause.id });
   }
   const requiresPage = (query.aggregations ?? []).some(
     (clause) => clause.scope === "shownRows"
@@ -1573,7 +1563,7 @@ async function localMetrics(rows, query, context, signal) {
           for (const name of plan.dependencies) {
             const field = context.schema.fields.find((f) => f.name === name);
             if (!field) throw Error(`Unavailable metric input: ${name}`);
-            const raw = readFieldValue3(field, row);
+            const raw = readFieldValue2(field, row);
             values2[name] = raw instanceof Date ? raw.toISOString() : raw ?? null;
           }
           bytes += JSON.stringify(values2).length;
@@ -1631,14 +1621,33 @@ async function executeMetrics(query, context, signal) {
     );
     return { metrics: series.combine(parts.flatMap((part) => part.metrics)) };
   }
-  if (context.executeV3) return context.executeV3(query, signal);
+  if (context.executeV3 || context.transport) {
+    const page = clauses.filter((c) => usesLocalMetricPage(c, context));
+    const remote = (q) => context.executeV3 ? context.executeV3(q, signal) : executeV3Metrics(
+      context.transport,
+      q,
+      context.schema,
+      sourceExecutionSchema2(context.schema, context.execution),
+      context.execution,
+      context.now ?? Date.now(),
+      signal
+    );
+    if (!page.length) return remote(query);
+    const { executeV3: _executeV3, transport: _transport, ...local } = context;
+    const rest = clauses.filter((c) => !page.includes(c));
+    const [own, served] = await Promise.all([
+      executeMetrics({ ...query, aggregations: page }, local, signal),
+      rest.length ? remote({ ...query, aggregations: rest }) : { metrics: [] }
+    ]);
+    const byId2 = new Map([...own.metrics, ...served.metrics].map((metric) => [metric.id, metric]));
+    return { metrics: clauses.flatMap((c) => byId2.get(c.id) ?? []) };
+  }
   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)
+  if (context.clientRows)
     return localMetrics(context.clientRows, query, context, signal);
   const shown = clauses.filter((c) => usesLocalMetricPage(c, context));
-  let matching = clauses.filter((c) => !shown.includes(c));
+  const matching = clauses.filter((c) => !shown.includes(c));
   const results = [];
   if (shown.length) {
     if (!context.rowsReady || !context.shownRows)
@@ -1649,7 +1658,7 @@ async function executeMetrics(query, context, signal) {
       shown.flatMap((clause) => [
         ...clause.groupBy,
         ...(clause.where ?? []).flatMap(
-          (term) => predicatesOf5(term).map((predicate) => predicate.field)
+          (term) => predicatesOf3(term).map((predicate) => predicate.field)
         ),
         // Includes a measured minimum's field, which the page must also hold.
         ...metricDependencies(clause, context.schema, context.resolveComputed)
@@ -1681,103 +1690,10 @@ async function executeMetrics(query, context, signal) {
       ...(await localMetrics(context.shownRows, pageQuery, context, signal)).metrics
     );
   }
-  const unsupported = (clause, error) => results.push({ id: clause.id, buckets: [], error });
-  const calendar = matching.filter((c) => c.dateGrouping);
-  for (const clause of calendar)
-    unsupported(
-      clause,
-      "This server does not support calendar grouping. Enable the v3 query executor."
+  if (matching.length)
+    throw Error(
+      "Remote all-matching metrics require a metric-capable server transport."
     );
-  matching = matching.filter((c) => !c.dateGrouping);
-  {
-    const transport = context.transport;
-    if (transport?.fetchMetrics || transport?.fetchAggregations) {
-      const support = transport.fetchMetrics && transport.metricCapabilities?.version === 2 ? transport.metricCapabilities : {};
-      matching = matching.filter((c) => {
-        const error = metricPopulationError(c, support);
-        if (error) unsupported(c, error);
-        return !error;
-      });
-    }
-  }
-  if (matching.length) {
-    const transport = context.transport;
-    if (transport?.fetchMetrics && transport.metricCapabilities?.version === 2) {
-      const capabilities = transport.metricCapabilities;
-      const request = toMetricQuery(
-        { ...query, aggregations: matching },
-        context.schema,
-        context.execution
-      );
-      if (request.diagnostics.length)
-        throw Error(request.diagnostics.map((d) => d.message).join(" "));
-      if (request.profile && capabilities.profile && request.profile !== capabilities.profile)
-        throw Error(
-          "Metric transport and computed execution profiles do not match. Refresh the handshake."
-        );
-      const remoteFields = new Map(
-        context.schema.fields.map((field) => [field.name, field])
-      );
-      for (const [name, capability] of Object.entries(
-        context.execution?.fields ?? {}
-      ))
-        if (isComputedField3(name))
-          remoteFields.set(name, {
-            name,
-            label: name,
-            type: capability.type,
-            source: { kind: "backend" }
-          });
-      const remoteSchema = {
-        ...context.schema,
-        fields: [...remoteFields.values()]
-      };
-      const wire = new Map(request.metrics.map((m) => [m.id, m]));
-      const limitation = (clause) => {
-        if (clause.scope === "shownRows" && !capabilities.shownRows)
-          return "This server does not support shown-row metrics.";
-        if (!capabilities.computedFields && [
-          ...clause.groupBy,
-          ...metricPlans(clause, remoteSchema).flatMap(
-            (plan) => plan.dependencies
-          )
-        ].some(isComputedField3))
-          return "This metric server does not support computed fields.";
-        const sent = wire.get(clause.id);
-        if (!capabilities.expressions && sent && !sent.distribution && (sent.expression !== void 0 || sent.expressionY !== void 0))
-          return "This server does not support composed metric expressions.";
-        if (!capabilities.distributions && clause.distribution && (!clause.display || ["box", "histogram"].includes(clause.display.kind)))
-          return "This server does not support distributions.";
-        return void 0;
-      };
-      const rejected = /* @__PURE__ */ new Set();
-      for (const clause of matching) {
-        const error = limitation(clause);
-        if (error) {
-          rejected.add(clause.id);
-          unsupported(clause, error);
-        }
-      }
-      const metrics = request.metrics.filter((m) => !rejected.has(m.id));
-      if (metrics.length)
-        results.push(
-          ...(await transport.fetchMetrics({ ...request, metrics }, signal)).metrics
-        );
-    } else if (transport?.fetchAggregations) {
-      const request = toAggregationQuery(
-        { ...query, aggregations: matching },
-        context.schema
-      );
-      if (request.diagnostics?.length)
-        throw Error(request.diagnostics.map((d) => d.message).join(" "));
-      results.push(
-        ...(await transport.fetchAggregations(request, signal)).metrics
-      );
-    } else
-      throw Error(
-        "Remote all-matching metrics require a metric-capable server transport."
-      );
-  }
   abort(signal);
   const byId = new Map(results.map((r) => [r.id, r]));
   return {
@@ -1785,7 +1701,8 @@ async function executeMetrics(query, context, signal) {
       (c) => byId.get(c.id) ?? {
         id: c.id,
         buckets: [],
-        error: "Server omitted this metric."
+        error: "Server omitted this metric.",
+        errorCode: "internal"
       }
     )
   };
@@ -1823,7 +1740,7 @@ function useMetricBatch(query, clauses, context, debounceMs, nonce, validateQuer
     context.queryContextKey,
     page ? context.shownFields : null
   ]);
-  const localDataset = !context.executeV3 && !(context.transport?.fetchMetrics && context.transport.metricCapabilities?.version === 2) && !context.transport?.fetchAggregations;
+  const localDataset = !context.executeV3 && !context.transport;
   const pageReady = context.rowsReady ?? (localDataset && context.clientRows !== void 0);
   const validationToken = useMemo5(() => ({}), [
     key,
@@ -2056,12 +1973,10 @@ function useSelect(query, setQuery, schema) {
     return schema.fields.filter((f) => !shown.has(f.name) && (f.select?.enabled ?? true));
   }, [schema, fields]);
   const writeSelect = useCallback8(
-    (mutate, clearFitToScreen = false) => {
+    (mutate) => {
       setQuery((prev) => {
         const current = prev.select.length ? prev.select : visible;
-        const next = { ...prev, select: mutate([...current]) };
-        if (clearFitToScreen) delete next.fitToScreen;
-        return next;
+        return { ...prev, select: mutate([...current]) };
       });
     },
     [setQuery, visible]
@@ -2079,7 +1994,7 @@ function useSelect(query, setQuery, schema) {
     [writeSelect]
   );
   const setWidth = useCallback8(
-    (field, width) => writeSelect((c) => c.map((x) => x.field === field ? { ...x, width: Math.round(width) } : x), true),
+    (field, width) => writeSelect((c) => c.map((x) => x.field === field ? { ...x, width: Math.round(width) } : x)),
     [writeSelect]
   );
   const reset = useCallback8(() => setQuery((prev) => ({ ...prev, select: [] })), [setQuery]);
@@ -2372,7 +2287,7 @@ function cloneQueryState(q) {
     limit: q.limit,
     offset: q.offset
   };
-  if (q.fitToScreen) clone.fitToScreen = true;
+  if (q.fit) clone.fit = q.fit;
   if (q.hostState) clone.hostState = { version: q.hostState.version, params: Object.fromEntries(Object.entries(q.hostState.params).map(([name, values]) => [name, [...values]])) };
   if (q.aggregations)
     clone.aggregations = JSON.parse(
@@ -2401,7 +2316,7 @@ function asDistinctValue(value) {
 }
 function fieldHasNullInRows(field, rows) {
   for (const row of rows) {
-    if (isNullLike(readFieldValue4(field, row))) return true;
+    if (isNullLike(readFieldValue3(field, row))) return true;
   }
   return false;
 }
@@ -2411,7 +2326,7 @@ function distinctValuesFromRows(field, rows, search) {
   const seen = /* @__PURE__ */ new Set();
   let hasMore = false;
   rowsLoop: for (const row of rows) {
-    const value = readFieldValue4(field, row);
+    const value = readFieldValue3(field, row);
     const candidates = field.type === "textarray" && Array.isArray(value) ? value : [value];
     for (const candidate of candidates) {
       const raw = asDistinctValue(candidate);
@@ -2465,7 +2380,6 @@ function writeHostParameters(url, host, state) {
     for (const value of state?.params[name] ?? []) next.searchParams.append(name, value);
   return next.toString();
 }
-var HOST_REQUEST_METHODS = /* @__PURE__ */ new Set(["fetchRows", "fetchRowsV2", "fetchQueryV3", "fetchMetrics", "fetchAggregations", "fetchDistinctValues"]);
 function withHostTransport(transport, hostStateKey) {
   if (!transport || !hostStateKey) return transport;
   const hostState = JSON.parse(hostStateKey);
@@ -2473,7 +2387,7 @@ function withHostTransport(transport, hostStateKey) {
   return new Proxy(Object.create(transport), {
     get(_target, key) {
       const method = Reflect.get(transport, key, transport);
-      if (!HOST_REQUEST_METHODS.has(String(key)) || typeof method !== "function") return method;
+      if (key !== "fetchQueryV3" || typeof method !== "function") return method;
       if (!wrappers.has(key))
         wrappers.set(key, (request, signal) => method.call(transport, { ...request, hostState }, signal));
       return wrappers.get(key);
@@ -2571,10 +2485,10 @@ function useQueryTable(opts) {
   const metadataTransport = useMemo9(() => withHostTransport(activityTransport, hostStateKey), [activityTransport, hostStateKey]);
   const metricTransport = useMemo9(() => withHostTransport(activityMetricTransport, hostStateKey), [activityMetricTransport, hostStateKey]);
   const transport = metadataTransport;
-  const sourceCatalogue = useMemo9(() => sourceExecutionSchema2(sourceSchema, opts.computedExecution), [sourceSchema, opts.computedExecution]);
+  const sourceCatalogue = useMemo9(() => sourceExecutionSchema3(sourceSchema, opts.computedExecution), [sourceSchema, opts.computedExecution]);
   const sourceRows = providedRows;
   const groupingModel = useMemo9(() => createGroupingModel(sourceCatalogue), [sourceCatalogue]);
-  const remoteGrouping = !!transport?.fetchQueryV3 && transport.queryCapabilities?.version === 3 && transport.queryCapabilities.groupedRows;
+  const remoteGrouping = !!transport && transport.queryCapabilities.version === 3 && transport.queryCapabilities.groupedRows;
   const groupingSupported = (!transport && sourceRows !== void 0 || remoteGrouping) && opts.grouping !== false;
   const groupKey = JSON.stringify(query.grouping ?? null);
   const groupingNow = useMemo9(
@@ -2775,10 +2689,10 @@ function useQueryTable(opts) {
     ...clientRows ? { clientRows } : {}
   });
   const resolveComputed = useCallback12(
-    (name) => isComputedField4(name) ? computed.compile(`[${name.replace(/]/g, "]] ".trim())}]`) : void 0,
+    (name) => isComputedField3(name) ? computed.compile(`[${name.replace(/]/g, "]] ".trim())}]`) : void 0,
     [computed.compile]
   );
-  const metricCompileSchema = useMemo9(() => opts.metricExecution ? sourceExecutionSchema2(displaySchema, opts.metricExecution, computed.definitions) : displaySchema, [displaySchema, opts.metricExecution, computed.definitions]);
+  const metricCompileSchema = useMemo9(() => opts.metricExecution ? sourceExecutionSchema3(displaySchema, opts.metricExecution, computed.definitions) : displaySchema, [displaySchema, opts.metricExecution, computed.definitions]);
   const metricCompile = useCallback12(
     (clause) => {
       const diagnostics = validateMetric2(
@@ -2787,7 +2701,7 @@ function useQueryTable(opts) {
         resolveComputed
       );
       if (diagnostics.length)
-        throw new Error(diagnostics.map((d) => d.message).join(" "));
+        throw new QueryError2("invalid_metric", diagnostics.map((d) => d.message).join(" "), { metricId: clause.id });
       return metricPlans2(clause, metricCompileSchema, resolveComputed);
     },
     [metricCompileSchema, resolveComputed]
@@ -2799,7 +2713,6 @@ function useQueryTable(opts) {
   const definitionKey = JSON.stringify(computedRevisions);
   const queryKey = useMemo9(() => JSON.stringify(query), [query]);
   const serverRowQuery = useMemo9(() => {
-    const execution2 = opts.computedExecution;
     const detailConfig = typeof opts.itemDetails === "object" ? opts.itemDetails : void 0;
     const page = query.itemDetails?.page ?? detailConfig?.page;
     const pageEnabled = Boolean(opts.itemDetails) && (query.itemDetails?.modes ?? initialDetailModes(detailConfig)).includes("page") && (!detailConfig?.modes || detailConfig.modes.includes("page"));
@@ -2808,20 +2721,7 @@ function useQueryTable(opts) {
       ...query.select.length ? query.select : defaults.select,
       ...pageFields.filter((name) => displaySchema.fields.some((field) => field.name === name)).map((field) => ({ field }))
     ] } : executionQuery;
-    const v2Request = execution2 && transport?.fetchRowsV2 ? toServerQueryV22(requestQuery, displaySchema, execution2) : void 0;
-    const request = v2Request ?? toServerQuery2(requestQuery, displaySchema);
-    if (v2Request)
-      for (const definition of computed.definitions) {
-        if ((execution2?.fields[computedFieldName2(definition.id)]?.select || v2Request.orderBy.some(
-          (term) => term.field === computedFieldName2(definition.id)
-        )) && executionRevision(execution2, definition.id) !== void 0 && executionRevision(execution2, definition.id) !== definition.revision)
-          v2Request.diagnostics.push({
-            from: 0,
-            to: 1,
-            code: "definition_changed",
-            message: "Computed definitions changed. Refresh the server execution handshake."
-          });
-      }
+    const request = toServerQuery(requestQuery, displaySchema);
     for (const clause of query.aggregations ?? [])
       if (clause.scope === "shownRows") {
         try {
@@ -2844,16 +2744,14 @@ function useQueryTable(opts) {
   }, [
     queryKey,
     displaySchema,
-    transport,
-    computedRevisions,
     schema,
     resolveComputed,
-    opts.computedExecution,
     opts.itemDetails,
     defaults
   ]);
+  const serverDefinitionKey = JSON.stringify(computed.definitions.flatMap((definition) => executionRevision(opts.computedExecution, definition.id) !== void 0 ? [[definition.id, definition.revision]] : []));
   const rowQueryKey = useMemo9(
-    () => transport ? `server:${JSON.stringify(serverRowQuery)}:${transport.fetchQueryV3 ? JSON.stringify([
+    () => transport ? `server:${JSON.stringify(serverRowQuery)}:${serverDefinitionKey}:${JSON.stringify([
       groupKey,
       groupingNow,
       query.select.map((column) => column.field),
@@ -2861,10 +2759,11 @@ function useQueryTable(opts) {
       query.orderBy,
       query.limit,
       query.offset
-    ]) : ""}` : `client:${JSON.stringify([query.where, query.orderBy, query.limit, query.offset])}`,
+    ])}` : `client:${JSON.stringify([query.where, query.orderBy, query.limit, query.offset])}`,
     [
       transport,
       serverRowQuery,
+      serverDefinitionKey,
       groupKey,
       groupingNow,
       query.select,
@@ -2893,67 +2792,37 @@ function useQueryTable(opts) {
       try {
         validateExecution(query);
         if (transport) {
-          if (transport.fetchQueryV3 && transport.queryCapabilities?.version === 3 && (query.grouping || query.select.some((column) => isComputedField4(column.field)) || query.orderBy.some((term) => isComputedField4(term.field)) || query.where.some((term) => predicatesOf6(term).some((predicate) => isComputedField4(predicate.field))) || !transport.fetchRows && !(transport.fetchRowsV2 && opts.computedExecution))) {
-            const request = toQueryRequestV32(
-              { ...query, aggregations: [], select: [
-                ...query.select.filter((column) => isComputedField4(column.field)),
-                ...serverRowQuery.select.map((field) => ({ field }))
-              ] },
-              sourceSchema,
-              transport.queryCapabilities,
-              opts.computedExecution,
-              { now: groupingNow ?? (opts.evaluationNow ?? Date.now)() }
-            );
-            if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
-            const result = await transport.fetchQueryV3(request, ac.signal);
-            validateQueryResultV32(result, request, query.grouping ? schema : sourceCatalogue);
-            if (!cancelled) {
-              setCommittedFields(request.result.select);
-              setServerExecution(result.execution);
-              setServerComputed(new Map(result.rows.map((row) => [
-                row[schema.idField],
-                Object.fromEntries(Object.entries(row).filter(([name]) => isComputedField4(name)).map(([name, value]) => [name.slice(10), value && typeof value === "object" && "computedError" in value ? { value: null, error: { code: String(value.computedError) } } : { value }]))
-              ])));
-              setRows(result.rows);
-              setTotal(result.total);
-              setCommittedPage(pageContext);
-              setCommittedSource({ schema, transport, clientRows });
-            }
-            return;
+          const request = toQueryRequestV33(
+            { ...query, aggregations: [], select: [
+              ...query.select.filter((column) => isComputedField3(column.field)),
+              ...serverRowQuery.select.map((field) => ({ field }))
+            ] },
+            sourceSchema,
+            transport.queryCapabilities,
+            opts.computedExecution,
+            { now: groupingNow ?? (opts.evaluationNow ?? Date.now)() }
+          );
+          const executed = /* @__PURE__ */ new Set([
+            ...request.result.select,
+            ...request.result.orderBy.map((term) => term.field),
+            ...[...request.source.where, ...request.result.where].flatMap((term) => predicatesOf4(term).map((predicate) => predicate.field))
+          ]);
+          for (const definition of computed.definitions) {
+            const revision = executionRevision(opts.computedExecution, definition.id);
+            if (executed.has(computedFieldName2(definition.id)) && revision !== void 0 && revision !== definition.revision)
+              throw Error("Computed definitions changed. Refresh the server execution handshake.");
           }
-          const useV2 = "version" in serverRowQuery && transport.fetchRowsV2;
-          if (!useV2 && !transport.fetchRows)
-            throw Error("Row execution requires fetchRows, negotiated fetchRowsV2, or negotiated fetchQueryV3.");
-          if ("diagnostics" in serverRowQuery && Array.isArray(serverRowQuery.diagnostics) && serverRowQuery.diagnostics.length)
-            throw Error(
-              serverRowQuery.diagnostics.map((d) => d.message).join(" ")
-            );
-          if (!useV2 && query.orderBy.some((s) => isComputedField4(s.field)))
-            throw Error(
-              "Global computed sorting requires a server execution handshake and fetchRowsV2."
-            );
-          const res = useV2 ? await transport.fetchRowsV2(
-            serverRowQuery,
-            ac.signal
-          ) : await transport.fetchRows(serverRowQuery, ac.signal);
-          if (useV2)
-            validateComputedResponse(
-              serverRowQuery,
-              res,
-              schema
-            );
+          const result = await transport.fetchQueryV3(request, ac.signal);
+          validateQueryResultV33(result, request, query.grouping ? schema : sourceCatalogue);
           if (!cancelled) {
-            setCommittedFields(serverRowQuery.select);
-            setServerExecution(
-              useV2 ? res.execution : void 0
-            );
-            if ("computed" in res && Array.isArray(res.computed))
-              setServerComputed(
-                new Map(res.computed.map((c) => [c.id, c.values]))
-              );
-            else setServerComputed(/* @__PURE__ */ new Map());
-            setRows(res.rows);
-            setTotal(res.total);
+            setCommittedFields(request.result.select);
+            setServerExecution(result.execution);
+            setServerComputed(new Map(result.rows.map((row) => [
+              row[schema.idField],
+              Object.fromEntries(Object.entries(row).filter(([name]) => isComputedField3(name)).map(([name, value]) => [name.slice(10), value && typeof value === "object" && "computedError" in value ? { value: null, error: { code: String(value.computedError) } } : { value }]))
+            ])));
+            setRows(result.rows);
+            setTotal(result.total);
             setCommittedPage(pageContext);
             setCommittedSource({ schema, transport, clientRows });
           }
@@ -3016,7 +2885,7 @@ function useQueryTable(opts) {
   );
   const rowId = useCallback12(
     (row) => (() => {
-      const value = idField ? readFieldValue4(idField, row) : row?.[schema.idField];
+      const value = idField ? readFieldValue3(idField, row) : row?.[schema.idField];
       return typeof value === "string" || typeof value === "number" && Number.isFinite(value) ? value : null;
     })(),
     [idField, schema.idField]
@@ -3075,55 +2944,33 @@ function useQueryTable(opts) {
   const metricExecution = opts.metricExecution ?? (opts.computedExecution ? pageReady && serverExecution ? serverExecution : opts.computedExecution : void 0);
   const v3MetricExecution = opts.metricExecution ?? opts.computedExecution;
   const metricSourceCatalogue = useMemo9(
-    () => sourceExecutionSchema2(sourceSchema, v3MetricExecution),
+    () => sourceExecutionSchema3(sourceSchema, v3MetricExecution),
     [sourceSchema, v3MetricExecution]
   );
-  const executeV3Metrics = useCallback12(async (metricQuery, signal) => {
-    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, minCountMeasures: capabilities.metricMinCountMeasures });
-      if (issue) refused.set(clause.id, issue);
-    }
-    const runnable = (metricQuery.aggregations ?? []).filter((clause) => !refused.has(clause.id));
-    let metrics = [];
-    if (runnable.length) {
-      const scoped = { ...metricQuery, aggregations: runnable };
-      const request = toQueryRequestV32(
-        query.grouping ? { ...scoped, grouping: query.grouping } : scoped,
-        sourceSchema,
-        capabilities,
-        v3MetricExecution,
-        { now: groupingNow ?? (opts.evaluationNow ?? Date.now)(), rows: false }
-      );
-      if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
-      const result = await metricTransport.fetchQueryV3(request, signal);
-      validateQueryResultV32(result, request, query.grouping ? schema : metricSourceCatalogue);
-      metrics = result.metrics;
-    }
-    if (!refused.size) return { metrics };
-    const byId = new Map(metrics.map((metric) => [metric.id, metric]));
-    return { metrics: (metricQuery.aggregations ?? []).flatMap((clause) => {
-      const issue = refused.get(clause.id);
-      if (issue) return [{ id: clause.id, buckets: [], error: issue }];
-      const metric = byId.get(clause.id);
-      return metric ? [metric] : [];
-    }) };
+  const executeV3Metrics2 = useCallback12(async (metricQuery, signal) => {
+    if (!metricTransport) throw Error("The v3 query executor is unavailable.");
+    return executeV3Metrics(
+      metricTransport,
+      query.grouping ? { ...metricQuery, grouping: query.grouping } : metricQuery,
+      sourceSchema,
+      query.grouping ? schema : metricSourceCatalogue,
+      v3MetricExecution,
+      groupingNow ?? (opts.evaluationNow ?? Date.now)(),
+      signal
+    );
   }, [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.");
-    const request = toQueryRequestV32(
+    if (!transport?.queryCapabilities.groupedRows || !draft.grouping) throw Error("The server group preview is unavailable.");
+    const request = toQueryRequestV33(
       { ...draft, aggregations: [] },
       sourceSchema,
       transport.queryCapabilities,
       opts.computedExecution,
       { now: groupingNow ?? (opts.evaluationNow ?? Date.now)() }
     );
-    if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
     const result = await transport.fetchQueryV3(request, signal);
-    validateQueryResultV32(result, request, groupingModel.resultSchema(draft.grouping.keys, draft.grouping.summaries));
+    validateQueryResultV33(result, request, groupingModel.resultSchema(draft.grouping.keys, draft.grouping.summaries));
     return { rows: result.rows, total: result.total, sourceTotal: result.sourceTotal };
   }, [transport, sourceSchema, opts.computedExecution, groupingModel, groupingNow, opts.evaluationNow, active, storageReady, restoration.loading, restoration.error]);
   const aggState = useAggregations(
@@ -3135,7 +2982,7 @@ function useQueryTable(opts) {
     nonce,
     validateExecution,
     {
-      ...metricTransport?.fetchQueryV3 && metricTransport.queryCapabilities?.version === 3 && (query.grouping || query.aggregations?.some((metric) => metric.dateGrouping) || query.where.some((term) => predicatesOf6(term).some((predicate) => isComputedField4(predicate.field)))) ? { executeV3: executeV3Metrics, queryContextKey: groupKey } : {},
+      ...metricTransport ? { executeV3: executeV3Metrics2, queryContextKey: groupKey } : {},
       ...groupingNow !== void 0 ? { now: groupingNow, strictLocalMetrics: true } : {},
       shownRows: rows,
       rowsReady: metricRowsReady,
@@ -3279,9 +3126,24 @@ function useQueryTable(opts) {
     () => setQuery((q) => ({ ...q, offset: Math.max(0, q.offset - q.limit) })),
     [setQuery]
   );
+  const auxiliaryRef = useRef9({ evaluationNow: opts.evaluationNow, execution: opts.computedExecution });
+  auxiliaryRef.current = { evaluationNow: opts.evaluationNow, execution: opts.computedExecution };
+  const auxiliaryOptions = useCallback12(() => {
+    const { evaluationNow, execution: execution2 } = auxiliaryRef.current;
+    return { now: (evaluationNow ?? Date.now)(), ...execution2 ? { execution: execution2 } : {} };
+  }, []);
+  const remoteDistinct = useCallback12(async (field, search, signal) => {
+    const definition = sourceCatalogue.fields.find((f) => f.name === field);
+    if (!metadataTransport || !definition || !isPushdownFilter(definition)) return { values: [], hasMore: false };
+    return fetchDistinctValuesV3(metadataTransport, sourceCatalogue, field, search.slice(0, 2e3), { ...auxiliaryOptions(), limit: AUTOCOMPLETE_LIMIT }, signal);
+  }, [metadataTransport, sourceCatalogue, auxiliaryOptions]);
+  const remoteFieldStats = useCallback12(
+    async (fields, signal) => metadataTransport && opts.remoteFieldStats ? fetchFieldStatsV3(metadataTransport, sourceCatalogue, fields, auxiliaryOptions(), signal) : {},
+    [metadataTransport, sourceCatalogue, auxiliaryOptions, opts.remoteFieldStats]
+  );
   const filterValues = useCallback12(
-    async (field, search) => {
-      if (!metadataTransport?.fetchDistinctValues || query.grouping && !query.grouping.keys.includes(field)) {
+    async (field, search, signal) => {
+      if (!metadataTransport || query.grouping && !query.grouping.keys.includes(field)) {
         const f = byName.get(field);
         if (!f || !clientRows) return { values: [], hasMore: false };
         const fieldHasNull = fieldHasNullInRows(f, clientRows);
@@ -3292,35 +3154,39 @@ function useQueryTable(opts) {
           hasNull: fieldHasNull
         };
       }
-      return metadataTransport.fetchDistinctValues({ field, search });
+      return remoteDistinct(field, search, signal);
     },
-    [metadataTransport, byName, clientRows, groupKey]
+    [metadataTransport, remoteDistinct, byName, clientRows, groupKey]
   );
   const fieldStats = useCallback12(
     async (fields, signal) => {
       const requested = [...new Set(fields)];
-      if (metadataTransport?.fetchFieldStats && !query.grouping) {
-        const backendFields = requested.filter(
-          (name) => byName.get(name)?.source.kind === "backend"
-        );
-        return backendFields.length ? metadataTransport.fetchFieldStats(backendFields, signal) : {};
-      }
+      if (metadataTransport && !query.grouping)
+        return remoteFieldStats(requested.filter((name) => byName.get(name)?.source.kind === "backend"), signal);
       if (!clientRows) return {};
-      const result = {};
+      const result = [];
       for (const name of requested) {
         if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
         const field = byName.get(name);
         if (!field) continue;
         const distinct = /* @__PURE__ */ new Set();
         for (const row of clientRows) {
-          const value = readFieldValue4(field, row);
+          const value = readFieldValue3(field, row);
           if (value !== null) distinct.add(JSON.stringify(value));
         }
-        result[name] = { distinct: distinct.size };
+        result.push([name, { distinct: distinct.size }]);
       }
-      return result;
+      return Object.fromEntries(result);
     },
-    [metadataTransport, byName, clientRows, groupKey]
+    [metadataTransport, remoteFieldStats, byName, clientRows, groupKey]
+  );
+  const identityLookup = useMemo9(() => {
+    const identity = sourceCatalogue.fields.find((field) => field.name === sourceCatalogue.idField);
+    return !identity || isPushdownFilter(identity) && opsForField2(identity).includes("=");
+  }, [sourceCatalogue]);
+  const fetchRow = useCallback12(
+    async (id, signal, select2) => fetchRowV3(metadataTransport, sourceCatalogue, id, { ...auxiliaryOptions(), ...select2?.length ? { select: select2 } : {} }, signal),
+    [metadataTransport, sourceCatalogue, auxiliaryOptions]
   );
   const refresh = useCallback12(() => {
     setNonce((n) => n + 1);
@@ -3385,17 +3251,17 @@ function useQueryTable(opts) {
   );
   const refreshRow = useCallback12(
     async (id) => {
-      if (opts.computedExecution && transport?.fetchRowsV2) {
+      if (!transport) return;
+      if (!identityLookup || query.grouping || committedFields.some(isComputedField3) || query.orderBy.some((term) => isComputedField3(term.field))) {
         refresh();
         return;
       }
-      if (!transport?.fetchRow) return;
-      const updated = await transport.fetchRow(id);
+      const updated = await fetchRow(id, void 0, committedFields);
       setRows(
         (prev) => prev.map((r) => rowId(r) === id ? updated ?? r : r)
       );
     },
-    [transport, rowId, opts.computedExecution, refresh]
+    [transport, fetchRow, rowId, groupKey, committedFields, query.orderBy, refresh, identityLookup]
   );
   const visibleFields = useMemo9(
     () => selectedFields2(columnSchema, query),
@@ -3494,9 +3360,23 @@ function useQueryTable(opts) {
   }, []);
   const sourceRowId = useCallback12((row) => {
     const field = sourceSchema.fields.find((f) => f.name === sourceSchema.idField);
-    const value = field ? readFieldValue4(field, row) : row[sourceSchema.idField];
+    const value = field ? readFieldValue3(field, row) : row[sourceSchema.idField];
     return typeof value === "string" || typeof value === "number" && Number.isFinite(value) ? value : null;
   }, [sourceSchema]);
+  const detailCatalogue = typeof opts.itemDetails === "object" ? opts.itemDetails.schema : void 0;
+  const lookupCatalogue = useMemo9(
+    () => !detailCatalogue ? sourceCatalogue : {
+      ...sourceCatalogue,
+      fields: [...sourceCatalogue.fields, ...detailCatalogue.fields.filter((field) => !sourceCatalogue.fields.some((f) => f.name === field.name))]
+    },
+    [sourceCatalogue, detailCatalogue]
+  );
+  const lookupCatalogueRef = useRef9(lookupCatalogue);
+  lookupCatalogueRef.current = lookupCatalogue;
+  const fetchItem = useCallback12(
+    async (id, signal) => fetchRowV3(metadataTransport, lookupCatalogueRef.current, id, auxiliaryOptions(), signal),
+    [metadataTransport, auxiliaryOptions]
+  );
   const itemDetails = useItemDetails({
     schema: query.grouping ? sourceSchema : displaySchema,
     query: sourceQuery,
@@ -3504,8 +3384,9 @@ function useQueryTable(opts) {
     options: opts.itemDetails,
     rows: query.grouping ? sourceRows ?? [] : rows,
     clientRows: sourceRows,
+    // Without an identity lookup, item details read the rows on the page.
     rowId: sourceRowId,
-    transport: metadataTransport,
+    fetchRow: metadataTransport && identityLookup ? fetchItem : void 0,
     refreshKey: nonce,
     links,
     queryParameter: parameter,
@@ -3546,7 +3427,7 @@ function useQueryTable(opts) {
     rows,
     clientRows: void 0,
     rowId,
-    transport: void 0,
+    fetchRow: void 0,
     refreshKey: nonce,
     links,
     queryParameter: parameter,
@@ -3618,25 +3499,20 @@ function useQueryTable(opts) {
     visibleFields,
     rowId
   };
-  const sourceFilterValues = useCallback12(async (name, search) => {
-    if (metadataTransport?.fetchDistinctValues) return metadataTransport.fetchDistinctValues({ field: name, search });
+  const sourceFilterValues = useCallback12(async (name, search, signal) => {
+    if (metadataTransport) return remoteDistinct(name, search, signal);
     const field = groupingModel.sourceField(name);
     return field && sourceRows ? { ...distinctValuesFromRows(field, sourceRows, search), hasNull: fieldHasNullInRows(field, sourceRows) } : { values: [], hasMore: false };
-  }, [metadataTransport, groupingModel, sourceRows]);
+  }, [metadataTransport, remoteDistinct, groupingModel, sourceRows]);
   const sourceFieldStats = useCallback12(async (names, signal) => {
     if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
     const requested = [...new Set(names)];
-    if (metadataTransport?.fetchFieldStats) {
-      const backendFields = requested.filter(
-        (name) => sourceCatalogue.fields.find((field) => field.name === name)?.source.kind === "backend"
-      );
-      return backendFields.length ? metadataTransport.fetchFieldStats(backendFields, signal) : {};
-    }
+    if (metadataTransport) return remoteFieldStats(requested, signal);
     return Object.fromEntries(requested.flatMap((name) => {
       const field = groupingModel.sourceField(name);
-      return field && sourceRows ? [[name, { distinct: new Set(sourceRows.map((row) => JSON.stringify(readFieldValue4(field, row)))).size }]] : [];
+      return field && sourceRows ? [[name, { distinct: new Set(sourceRows.map((row) => JSON.stringify(readFieldValue3(field, row)))).size }]] : [];
     }));
-  }, [metadataTransport, groupingModel, sourceRows, sourceCatalogue]);
+  }, [metadataTransport, remoteFieldStats, groupingModel, sourceRows]);
   const sourceApi = {
     ...sourceFilters,
     loading,