ggaction 0.0.16 → 0.0.17

package/src/grammar/regression/models.js

@@ -58,14 +58,14 @@ function linearPrediction(model, xValue) {
 }
 
 function fitLinearGroup(rows, {
-  x, y, group, confidenceMethod, level
+  x, y, group, confidenceMethod, level, interval
 }) {
   const count = rows.length;
   const groupLabel = group === undefined ? "all" : String(group);
   const label = `Regression group "${groupLabel}"`;
-  if (count < 3) {
+  if (count < (interval === false ? 2 : 3)) {
     throw new Error(
-      `${label} requires at least three rows.`
+      `${label} requires at least ${interval === false ? "two" : "three"} rows.`
     );
   }
   const xValues = rows.map(row => row[x]);
@@ -148,6 +148,7 @@ function fitLinearGroup(rows, {
     normalizedSxx
   });
   if (!normalizedXByDifference) model.normalizedXByDifference = false;
+  if (interval === false) return model;
   const residualSumSquares = stableFiniteSquareSum(
     rows.map(row => row[y] - linearPrediction(model, row[x])),
     `${label} residual sum of squares`
@@ -238,19 +239,19 @@ function polynomialResponse(design, values, size, scale = 1) {
 }
 
 function fitPolynomialGroup(rows, {
-  x, y, group, confidenceMethod, level, degree
+  x, y, group, confidenceMethod, level, degree, interval
 }) {
   const count = rows.length;
   const parameterCount = degree + 1;
   const groupLabel = group === undefined ? "all" : String(group);
   const label = `Polynomial regression group "${groupLabel}"`;
   if (
-    count < degree + 2 ||
+    count < (interval === false ? parameterCount : degree + 2) ||
     new Set(rows.map(row => row[x])).size < parameterCount
   ) {
     throw new Error(
       `${label} requires at least ` +
-      `${degree + 2} rows and ${parameterCount} distinct x values.`
+      `${interval === false ? parameterCount : degree + 2} rows and ${parameterCount} distinct x values.`
     );
   }
   const xValues = rows.map(row => row[x]);
@@ -289,7 +290,7 @@ function fitPolynomialGroup(rows, {
         `${label} coefficient ${index}`
       ))
     : scaledCoefficients;
-  const inverse = invertSymmetricMatrix(normal);
+  const inverse = interval === false ? undefined : invertSymmetricMatrix(normal);
   const fitted = design.map(basis => stableResponse
     ? restoreFiniteScale(
         dot(basis, scaledCoefficients),
@@ -298,12 +299,12 @@ function fitPolynomialGroup(rows, {
       )
     : dot(basis, normalizedCoefficients)
   );
-  const residualSumSquares = stableFiniteSquareSum(
+  const residualSumSquares = interval === false ? undefined : stableFiniteSquareSum(
     fitted.map((value, index) => rows[index][y] - value),
     `${label} residual sum of squares`
   );
   const degreesOfFreedom = count - parameterCount;
-  const residualVariance = residualSumSquares / degreesOfFreedom;
+  const residualVariance = interval === false ? undefined : residualSumSquares / degreesOfFreedom;
   const model = {
     count,
     degreesOfFreedom,
@@ -316,13 +317,15 @@ function fitPolynomialGroup(rows, {
     normalizedCoefficients,
     center,
     scale,
-    inverse,
-    residualSumSquares,
-    residualStandardError: Math.sqrt(residualVariance),
-    critical: confidenceCriticalValue({
-      method: confidenceMethod,
-      level,
-      degreesOfFreedom
+    ...(inverse === undefined ? {} : { inverse }),
+    ...(interval === false ? {} : {
+      residualSumSquares,
+      residualStandardError: Math.sqrt(residualVariance),
+      critical: confidenceCriticalValue({
+        method: confidenceMethod,
+        level,
+        degreesOfFreedom
+      })
     })
   };
   if (!normalizedXByDifference) model.normalizedXByDifference = false;
@@ -345,7 +348,9 @@ function evaluatePolynomial(model, xValue) {
           model.responseScale,
           "Polynomial regression prediction"
         ),
-    leverage: dot(basis, model.inverse.map(row => dot(row, basis)))
+    ...(model.inverse === undefined ? {} : {
+      leverage: dot(basis, model.inverse.map(row => dot(row, basis)))
+    })
   };
 }
 
@@ -420,7 +425,29 @@ function fitLoessGroup(rows, { x, y, group, span }) {
       neighborIndices: weighted.map(item => item.index)
     };
   });
-  return { count: rows.length, span, neighborCount, fits };
+  return { count: rows.length, span, neighborCount, fits, rows, x, y, xScale, yScale };
+}
+
+function predictLoessAt(model, xValue) {
+  const found = model.fits.find(fit => fit.x === xValue);
+  if (found !== undefined) return found.prediction;
+  const neighbors = model.rows.map((row, index) => ({
+    row,
+    index,
+    distance: Math.abs(row[model.x] / model.xScale - xValue / model.xScale)
+  })).sort((left, right) => left.distance - right.distance || left.index - right.index)
+    .slice(0, model.neighborCount);
+  const radius = neighbors.at(-1).distance;
+  const weighted = neighbors.map(neighbor => ({
+    ...neighbor,
+    weight: radius === 0 ? 1 : (1 - (neighbor.distance / radius) ** 3) ** 3
+  }));
+  const ordinary = weightedPrediction(weighted, model.x, model.y, xValue);
+  return Number.isFinite(ordinary) ? ordinary : restoreFiniteScale(
+    weightedPrediction(weighted, model.x, model.y, xValue, model.xScale, model.yScale),
+    model.yScale,
+    "LOESS regression prediction"
+  );
 }
 
 export function fitRegressionGroup(rows, { x, y, group, parameters }) {
@@ -430,7 +457,8 @@ export function fitRegressionGroup(rows, { x, y, group, parameters }) {
       y,
       group,
       confidenceMethod: parameters.confidenceMethod,
-      level: parameters.level
+      level: parameters.level,
+      interval: parameters.interval
     });
   }
   if (parameters.method === "polynomial") {
@@ -440,7 +468,8 @@ export function fitRegressionGroup(rows, { x, y, group, parameters }) {
       group,
       confidenceMethod: parameters.confidenceMethod,
       level: parameters.level,
-      degree: parameters.degree
+      degree: parameters.degree,
+      interval: parameters.interval
     });
   }
   return fitLoessGroup(rows, { x, y, group, span: parameters.span });
@@ -454,8 +483,8 @@ export function predictRegressionAt(model, xValue, parameters) {
     ? linearPrediction(model, xValue)
     : parameters.method === "polynomial"
       ? polynomial.prediction
-      : model.fits.find(fit => fit.x === xValue).prediction;
-  if (parameters.method === "loess") return { prediction };
+      : predictLoessAt(model, xValue);
+  if (parameters.method === "loess" || parameters.interval === false) return { prediction };
   const leverage = parameters.method === "linear"
     ? model.normalizedSxx !== undefined
       ? 1 / model.count + (

package/src/grammar/regression/parameters.js

@@ -1,10 +1,39 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
+import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
 import { validateGeneratedItemLimit } from "../../core/validation.js";
 import { normalizeConfidenceInterval } from
   "../statistics/confidenceInterval.js";
 
 const MAX_POLYNOMIAL_DEGREE = 32;
 
+export function normalizeRegressionPredict(predict) {
+  if (predict === undefined) return undefined;
+  if (predict === false) throw new TypeError("Regression predict false is only valid in edits.");
+  if (!isPlainObject(predict)) {
+    throw new TypeError("Regression predict must be a plain object.");
+  }
+  const unknown = Object.keys(predict).find(key => !["values", "domain", "steps"].includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown regression predict property "${unknown}".`);
+  const usesValues = Object.hasOwn(predict, "values");
+  const usesDomain = Object.hasOwn(predict, "domain") || Object.hasOwn(predict, "steps");
+  if (usesValues === usesDomain) throw new Error("Regression predict requires values or domain with steps.");
+  if (usesValues) {
+    const values = predict.values;
+    if (!Array.isArray(values) || values.length === 0 || values.some((value, index) =>
+      !Number.isFinite(value) || (index > 0 && !(value > values[index - 1]))
+    )) throw new TypeError("Regression predict values must be finite, unique, and strictly ascending.");
+    return cloneAndFreeze({ values: [...values] });
+  }
+  if (!Array.isArray(predict.domain) || predict.domain.length !== 2 ||
+      !predict.domain.every(Number.isFinite) || !(predict.domain[0] < predict.domain[1])) {
+    throw new TypeError("Regression predict domain must be two increasing finite numbers.");
+  }
+  if (!Number.isInteger(predict.steps) || predict.steps < 2) {
+    throw new RangeError("Regression predict steps must be an integer of at least two.");
+  }
+  validateGeneratedItemLimit(predict.steps, "Regression predict steps");
+  return cloneAndFreeze({ domain: [...predict.domain], steps: predict.steps });
+}
+
 export function requireRegressionField(field, label) {
   if (typeof field !== "string" || field.length === 0) {
     throw new TypeError(`${label} must be a non-empty string.`);
@@ -45,6 +74,21 @@ export function normalizeRegressionParameters({
   if (span !== undefined) {
     throw new Error("Regression span requires the loess method.");
   }
+  if (interval === false) {
+    if (confidenceMethod !== undefined || level !== undefined || confidence !== undefined) {
+      throw new Error("Regression interval false cannot include confidence options.");
+    }
+    if (method === "polynomial") {
+      const resolvedDegree = degree ?? 2;
+      if (!Number.isInteger(resolvedDegree) || resolvedDegree < 1) {
+        throw new RangeError("Regression polynomial degree must be a positive integer.");
+      }
+      validateGeneratedItemLimit(resolvedDegree, "Regression polynomial degree", MAX_POLYNOMIAL_DEGREE);
+      return cloneAndFreeze({ method, degree: resolvedDegree, interval: false });
+    }
+    if (degree !== undefined) throw new Error("Regression degree requires the polynomial method.");
+    return cloneAndFreeze({ method, interval: false });
+  }
   if (level !== undefined && confidence !== undefined && level !== confidence) {
     throw new Error(
       "Regression level and confidence alias must match when both are provided."
@@ -96,7 +140,7 @@ export function validateRegressionTransform(transform) {
   const supported = [
     "type", "method", "x", "y", "groupBy", "confidenceMethod", "level",
     "confidence", "interval",
-    "degree", "span"
+    "degree", "span", "predict", "missing"
   ];
   const unknown = Object.keys(transform).find(key => !supported.includes(key));
   if (unknown !== undefined) {
@@ -127,9 +171,14 @@ export function validateRegressionTransform(transform) {
     confidence: transform.confidence,
     interval: transform.interval
   });
+  normalizeRegressionPredict(transform.predict);
+  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
+    throw new Error('Regression missing must be "error" or "drop".');
+  }
   if (normalized.method === "loess") return transform;
   if (
     transform.confidence === undefined &&
+    transform.interval !== false &&
     (transform.confidenceMethod === undefined || transform.level === undefined)
   ) {
     throw new Error("Regression confidence provenance requires method and level.");
@@ -142,6 +191,7 @@ export function validateRegressionTransform(transform) {
 
 export function normalizeRegressionTransform(args = {}) {
   const parameters = normalizeRegressionParameters(args);
+  const predict = normalizeRegressionPredict(args.predict);
   const transform = {
     type: "regression",
     method: parameters.method,
@@ -153,11 +203,13 @@ export function normalizeRegressionTransform(args = {}) {
       : {}),
     ...(parameters.method === "loess"
       ? { span: parameters.span }
-      : {
+      : parameters.interval === false ? { interval: false } : {
           confidenceMethod: parameters.confidenceMethod,
           level: parameters.level,
           interval: parameters.interval
-        })
+        }),
+    ...(predict === undefined ? {} : { predict }),
+    ...(args.missing === undefined ? {} : { missing: args.missing })
   };
   validateRegressionTransform(transform);
   return cloneAndFreeze(transform);

package/src/grammar/scales/definition.js

@@ -108,6 +108,13 @@ export function normalizeScaleDefinition({
     domain: validateDomain(type, rawDomain),
     range: validateRange(type, rawRange)
   };
+  const emptyDomain = retainedValue(previous, patch, defaults, "emptyDomain", typeChanged);
+  if (emptyDomain !== undefined) {
+    if (!["preserve", "require-explicit"].includes(emptyDomain)) {
+      throw new Error('Scale emptyDomain must be "preserve" or "require-explicit".');
+    }
+    definition.emptyDomain = emptyDomain;
+  }
 
   for (const property of BOOLEAN_PROPERTIES) {
     let value = retainedValue(previous, patch, defaults, property, typeChanged);

package/src/grammar/schemas/semanticPath.js

@@ -49,7 +49,7 @@ const ENCODING_PATHS = Object.freeze([
 const ENTITY_PATHS = Object.freeze({
   dataset: {
     collection: "datasets",
-    properties: new Set(["source", "transform", "values"])
+    properties: new Set(["source", "transform", "schema", "values"])
   },
   layer: {
     collection: "layers",
@@ -64,6 +64,7 @@ const ENTITY_PATHS = Object.freeze({
       "transform",
       "mark.type",
       "mark.missing",
+      "derivedBindings.regression",
       "layout.mode",
       ...ENCODING_PATHS
     ])
@@ -71,7 +72,7 @@ const ENTITY_PATHS = Object.freeze({
   scale: {
     collection: "scales",
     properties: new Set([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "unknown", "base", "exponent", "constant", "interpolate", "radialMapping", "midpoint",
       "paddingInner", "paddingOuter", "padding", "align"
     ])

package/src/grammar/sort.js

@@ -0,0 +1,88 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { normalizeTemporalValue } from "./scales/fields.js";
+
+const ORDERS = new Set(["ascending", "descending"]);
+const NULLS = new Set(["first", "last"]);
+const TEMPORAL_UNITS = new Set(["year", "timestamp"]);
+
+export function normalizeSortTransform({ sortBy }) {
+  if (!Array.isArray(sortBy) || sortBy.length === 0 ||
+      Array.from({ length: sortBy.length }, (_, index) => index).some(index => !Object.hasOwn(sortBy, index))) {
+    throw new TypeError("Sorted data sortBy must be a non-empty dense array.");
+  }
+  const keys = sortBy.map((key, index) => {
+    if (!isPlainObject(key)) throw new TypeError(`Sort key ${index} must be a plain object.`);
+    const unknown = Object.keys(key).find(name => !["field", "order", "nulls", "temporalUnit"].includes(name));
+    if (unknown !== undefined) throw new Error(`Unknown sort key property "${unknown}".`);
+    if (typeof key.field !== "string" || key.field.length === 0) {
+      throw new TypeError(`Sort key ${index} field must be a non-empty string.`);
+    }
+    const order = key.order ?? "ascending";
+    const nulls = key.nulls ?? "last";
+    if (!ORDERS.has(order)) throw new Error(`Unsupported sort order "${order}".`);
+    if (!NULLS.has(nulls)) throw new Error(`Unsupported sort null placement "${nulls}".`);
+    if (key.temporalUnit !== undefined && !TEMPORAL_UNITS.has(key.temporalUnit)) {
+      throw new Error(`Unsupported sort temporalUnit "${key.temporalUnit}".`);
+    }
+    return { field: key.field, order, nulls, ...(key.temporalUnit === undefined ? {} : { temporalUnit: key.temporalUnit }) };
+  });
+  if (new Set(keys.map(key => key.field)).size !== keys.length) {
+    throw new Error("Sorted data sortBy fields must be unique.");
+  }
+  return cloneAndFreeze({ type: "sort", sortBy: keys });
+}
+
+export function validateSortTransform(transform) {
+  if (!isPlainObject(transform)) throw new TypeError("Sort transform must be a plain object.");
+  const unknown = Object.keys(transform).find(key => !["type", "sortBy"].includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown sort transform property "${unknown}".`);
+  if (transform.type !== "sort") throw new Error('Sort transform type must be "sort".');
+  normalizeSortTransform(transform);
+}
+
+function compareValues(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function normalizedKey(value, key, rowIndex) {
+  if (value === null || value === undefined) return { missing: true };
+  if (key.temporalUnit !== undefined) {
+    return { missing: false, value: normalizeTemporalValue(value, key.field, rowIndex, key.temporalUnit) };
+  }
+  if (!["number", "string", "boolean"].includes(typeof value) ||
+      (typeof value === "number" && !Number.isFinite(value))) {
+    throw new TypeError(`Sort field "${key.field}" requires finite number, string, boolean, or missing values at row ${rowIndex}.`);
+  }
+  return { missing: false, value, type: typeof value };
+}
+
+export function deriveSortedRows(values, transform) {
+  if (!Array.isArray(values)) throw new TypeError("Sort source values must be an array.");
+  validateSortTransform(transform);
+  const decorated = values.map((row, index) => ({
+    row,
+    index,
+    keys: transform.sortBy.map(key => normalizedKey(row[key.field], key, index))
+  }));
+  for (let keyIndex = 0; keyIndex < transform.sortBy.length; keyIndex += 1) {
+    const key = transform.sortBy[keyIndex];
+    const types = new Set(decorated.map(entry => entry.keys[keyIndex]).filter(value => !value.missing).map(value => value.type ?? "number"));
+    if (types.size > 1) throw new TypeError(`Sort field "${key.field}" contains mixed non-missing types.`);
+  }
+  decorated.sort((left, right) => {
+    for (let index = 0; index < transform.sortBy.length; index += 1) {
+      const key = transform.sortBy[index];
+      const a = left.keys[index];
+      const b = right.keys[index];
+      if (a.missing || b.missing) {
+        if (a.missing !== b.missing) return a.missing === (key.nulls === "first") ? -1 : 1;
+        continue;
+      }
+      const compared = compareValues(a.value, b.value);
+      if (compared !== 0) return key.order === "ascending" ? compared : -compared;
+    }
+    return left.index - right.index;
+  });
+  return decorated.map(entry => entry.row);
+}

package/src/grammar/summary.js

@@ -16,7 +16,7 @@ import {
 } from "./weightedStatistics.js";
 
 const TRANSFORM_KEYS = Object.freeze([
-  "type", "groupBy", "aggregates", "members", "weight"
+  "type", "groupBy", "aggregates", "members", "weight", "missing", "empty"
 ]);
 const AGGREGATE_KEYS = Object.freeze(["op", "field", "as"]);
 const NOMINAL_OPERATIONS = new Set(["distinct", "valid", "missing"]);
@@ -51,7 +51,7 @@ function normalizeAggregate(value) {
   };
 }
 
-export function normalizeSummaryTransform({ groupBy, aggregates, members, weight } = {}) {
+export function normalizeSummaryTransform({ groupBy, aggregates, members, weight, missing, empty } = {}) {
   const transform = {
     type: "summary",
     groupBy: normalizeGroupBy(groupBy),
@@ -61,7 +61,9 @@ export function normalizeSummaryTransform({ groupBy, aggregates, members, weight
     ...(members === undefined ? {} : { members }),
     ...(weight === undefined
       ? {}
-      : { weight: normalizeStatisticalWeight(weight, "Summary weight") })
+      : { weight: normalizeStatisticalWeight(weight, "Summary weight") }),
+    ...(missing === undefined ? {} : { missing }),
+    ...(empty === undefined ? {} : { empty })
   };
   validateSummaryTransform(transform);
   return cloneAndFreeze(transform);
@@ -120,6 +122,12 @@ export function validateSummaryTransform(transform) {
   if (transform.weight !== undefined) {
     normalizeStatisticalWeight(transform.weight, "Summary weight");
   }
+  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
+    throw new Error('Summary missing must be "error" or "drop".');
+  }
+  if (transform.empty !== undefined && !["null", "identity"].includes(transform.empty)) {
+    throw new Error('Summary empty must be "null" or "identity".');
+  }
   return transform;
 }
 
@@ -169,12 +177,13 @@ function validateAggregateValues(rows, aggregate) {
 export function deriveSummaryRows(rows, transform) {
   validateSummaryTransform(transform);
   requireSourceFields(rows, transform);
+  const explicitWeighted = transform.weight !== undefined && transform.missing !== undefined;
   let weightEntries;
   if (transform.weight === undefined) {
     for (const aggregate of transform.aggregates) {
       validateAggregateValues(rows, aggregate);
     }
-  } else {
+  } else if (!explicitWeighted) {
     weightEntries = readStatisticalWeights(rows, transform.weight, "Summary").entries;
     validateWeightedNumericFields(
       weightEntries,
@@ -183,6 +192,37 @@ export function deriveSummaryRows(rows, transform) {
       ))],
       "Summary"
     );
+  } else {
+    // Explicit missing policy is evaluated per measure. Validate every
+    // nonmissing value now, while leaving nullish value/weight pairs for the
+    // reason-priority accounting below.
+    readStatisticalWeights(
+      rows.filter(row => row[transform.weight.field] !== null && row[transform.weight.field] !== undefined),
+      transform.weight,
+      "Summary"
+    );
+    for (const aggregate of transform.aggregates) {
+      if (aggregate.field === undefined) continue;
+      validateAggregateValues(
+        rows.filter(row => row[aggregate.field] !== null && row[aggregate.field] !== undefined),
+        aggregate
+      );
+    }
+  }
+  if (transform.missing === "error") {
+    if (transform.weight !== undefined) {
+      const weightIndex = rows.findIndex(row =>
+        row[transform.weight.field] === null || row[transform.weight.field] === undefined
+      );
+      if (weightIndex !== -1) {
+        throw new TypeError(`Summary weight "${transform.weight.field}" is missing at row ${weightIndex}.`);
+      }
+    }
+    for (const aggregate of transform.aggregates) {
+      if (aggregate.field === undefined) continue;
+      const index = rows.findIndex(row => row[aggregate.field] === null || row[aggregate.field] === undefined);
+      if (index !== -1) throw new TypeError(`Summary field "${aggregate.field}" is missing at row ${index}.`);
+    }
   }
 
   const groups = new Map();
@@ -212,34 +252,92 @@ export function deriveSummaryRows(rows, transform) {
     throw new RangeError(`Summary output cannot exceed ${MAX_OUTPUT_ROWS} groups.`);
   }
 
-  return [...groups.values()].map(group => {
-    const weightSummary = transform.weight === undefined
+  const units = [];
+  const values = [...groups.values()].map(group => {
+    const sharedWeightSummary = transform.weight === undefined || explicitWeighted
       ? undefined
       : summarizeStatisticalWeights(
           group.entries,
           transform.weight.kind,
           "Summary group"
         );
+    const aggregated = Object.fromEntries(transform.aggregates.map(aggregate => {
+      let missingValue = 0;
+      let missingWeight = 0;
+      let zeroWeightRows = 0;
+      let measureWeightSummary = sharedWeightSummary;
+      if (explicitWeighted) {
+        const eligible = group.rows.filter(row => {
+          if (aggregate.field !== undefined &&
+              (row[aggregate.field] === null || row[aggregate.field] === undefined)) {
+            missingValue += 1;
+            return false;
+          }
+          if (row[transform.weight.field] === null || row[transform.weight.field] === undefined) {
+            missingWeight += 1;
+            return false;
+          }
+          return true;
+        });
+        const entries = readStatisticalWeights(eligible, transform.weight, "Summary").entries;
+        zeroWeightRows = entries.filter(entry => entry.weight === 0).length;
+        measureWeightSummary = summarizeStatisticalWeights(
+          entries,
+          transform.weight.kind,
+          "Summary group"
+        );
+      }
+      let value = measureWeightSummary === undefined
+        ? aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
+        : calculateWeightedAggregate(
+            measureWeightSummary,
+            aggregate.field,
+            aggregate.op,
+            `Summary aggregate "${aggregate.as}"`
+          );
+      if (value === undefined && transform.empty !== undefined) {
+        const op = typeof aggregate.op === "string" ? aggregate.op : aggregate.op.op;
+        value = transform.empty === "identity" && op === "sum" ? 0 : null;
+      }
+      if (transform.missing !== undefined || transform.empty !== undefined) {
+        const missing = explicitWeighted
+          ? missingValue + missingWeight
+          : aggregate.field === undefined ? 0 : group.rows.filter(row => row[aggregate.field] === null || row[aggregate.field] === undefined).length;
+        units.push({
+          role: aggregate.as,
+          group: group.values,
+          inputRows: group.rows.length,
+          usedRows: group.rows.length - missing,
+          excludedRows: missing,
+          excludedByReason: missing === 0 ? {} : {
+            ...(missingValue === 0 && explicitWeighted ? {} : { "missing-value": explicitWeighted ? missingValue : missing }),
+            ...(missingWeight === 0 ? {} : { "missing-weight": missingWeight })
+          },
+          ...(explicitWeighted ? { zeroWeightRows } : {})
+        });
+      }
+      return [aggregate.as, value];
+    }));
     return {
       ...group.values,
-      ...Object.fromEntries(transform.aggregates.map(aggregate => [
-        aggregate.as,
-        weightSummary === undefined
-          ? aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
-          : calculateWeightedAggregate(
-              weightSummary,
-              aggregate.field,
-              aggregate.op,
-              `Summary aggregate "${aggregate.as}"`
-            )
-      ])),
+      ...aggregated,
       ...(transform.members === undefined
         ? {}
         : {
-            [transform.members]: weightSummary === undefined
+            [transform.members]: sharedWeightSummary === undefined
               ? group.rows
-              : weightedRows(weightSummary)
+              : weightedRows(sharedWeightSummary)
           })
     };
   });
+  if (transform.missing === undefined && transform.empty === undefined) return values;
+  return {
+    values,
+    report: cloneAndFreeze({
+      version: 1,
+      owner: { kind: "data", id: "pending" },
+      inputs: [],
+      units
+    })
+  };
 }

package/src/grammar/transformTopology.js

@@ -16,6 +16,7 @@ const TRANSFORM_TOPOLOGY = Object.freeze({
   markFilter: Object.freeze({ provenanceTransparent: true }),
   normalize: Object.freeze({ facetTopology: "statistical" }),
   regression: Object.freeze({ facetTopology: "statistical" }),
+  sort: Object.freeze({ facetTopology: "statistical" }),
   summary: Object.freeze({ facetTopology: "statistical" }),
   stack: Object.freeze({ facetTopology: "statistical" }),
   statisticalReference: Object.freeze({ facetTopology: "statistical" }),