ggaction 0.0.10 → 0.0.12

package/src/grammar/aggregate.js

@@ -1,4 +1,12 @@
 import { isPlainObject } from "../core/immutable.js";
+import {
+  interpolateNumber,
+  numericExtent,
+  requireFiniteResult,
+  stableFiniteDeviation,
+  stableFiniteMean,
+  stableFiniteSum
+} from "./numeric.js";
 
 export const SCALAR_AGGREGATE_OPERATIONS = Object.freeze([
   "count", "sum", "mean", "median", "min", "max",
@@ -8,8 +16,8 @@ export const SCALAR_AGGREGATE_OPERATIONS = Object.freeze([
 ]);
 
 const SCALAR_OPERATIONS = new Set(SCALAR_AGGREGATE_OPERATIONS);
-const NOMINAL_OPERATIONS = new Set(["count", "distinct", "valid", "missing"]);
-const PARAMETERIZED_OPERATIONS = new Set(["quantile", "first", "last"]);
+const NOMINAL_OPERATIONS = ["count", "distinct", "valid", "missing"];
+const PARAMETERIZED_OPERATIONS = ["quantile", "first", "last"];
 
 function nonEmptyString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -22,7 +30,7 @@ export function isScalarAggregate(value) {
 }
 
 export function isParameterizedAggregate(value) {
-  return isPlainObject(value) && PARAMETERIZED_OPERATIONS.has(value.op);
+  return isPlainObject(value) && PARAMETERIZED_OPERATIONS.includes(value.op);
 }
 
 export function isAggregate(value) {
@@ -95,7 +103,7 @@ export function validateScalarAggregateFieldType(operation, fieldType) {
     throw new Error("Scalar aggregate calculation requires a scalar operation.");
   }
   if (fieldType === "quantitative") return fieldType;
-  if (fieldType === "nominal" && NOMINAL_OPERATIONS.has(operation)) {
+  if (fieldType === "nominal" && NOMINAL_OPERATIONS.includes(operation)) {
     return fieldType;
   }
   throw new Error(
@@ -139,8 +147,11 @@ function quantile(values, probability) {
   const position = (ordered.length - 1) * probability;
   const lower = Math.floor(position);
   const upper = Math.ceil(position);
-  return ordered[lower] +
-    (ordered[upper] - ordered[lower]) * (position - lower);
+  return interpolateNumber(
+    ordered[lower],
+    ordered[upper],
+    position - lower
+  );
 }
 
 function comparableOrderKey(value) {
@@ -179,15 +190,6 @@ function aggregateOrderedRows(rows, field, aggregate) {
     : candidates.at(-1).value;
 }
 
-function moments(values) {
-  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
-  const squared = values.reduce(
-    (sum, value) => sum + (value - mean) ** 2,
-    0
-  );
-  return { mean, squared };
-}
-
 export function aggregateScalarValues(values, operation) {
   if (!Array.isArray(values)) {
     throw new TypeError("Aggregate values must be an array.");
@@ -206,27 +208,45 @@ export function aggregateScalarValues(values, operation) {
   const finite = finiteValues(values);
   if (finite.length === 0) return undefined;
   if (operation === "sum") {
-    return finite.reduce((sum, value) => sum + value, 0);
+    return stableFiniteSum(finite, "Aggregate sum");
   }
-  if (operation === "min") return Math.min(...finite);
-  if (operation === "max") return Math.max(...finite);
+  if (operation === "min") return numericExtent(finite)[0];
+  if (operation === "max") return numericExtent(finite)[1];
   if (operation === "median") return quantile(finite, 0.5);
   if (operation === "q1") return quantile(finite, 0.25);
   if (operation === "q3") return quantile(finite, 0.75);
 
-  const { mean, squared } = moments(finite);
+  const mean = stableFiniteMean(finite, "Aggregate mean");
   if (operation === "mean") return mean;
-  if (operation === "varianceP") return squared / finite.length;
-  if (operation === "stdevP") return Math.sqrt(squared / finite.length);
+  if (["variance", "varianceP", "stdev", "stdevP"].includes(operation)) {
+    const population = operation.endsWith("P");
+    if (!population && finite.length < 2) return undefined;
+    const kind = population ? "population" : "sample";
+    const deviation = stableFiniteDeviation(finite, {
+      sample: !population,
+      label: `Aggregate ${kind} deviation`
+    });
+    if (operation.startsWith("stdev")) return deviation.deviation;
+    return deviation.squared === undefined
+      ? requireFiniteResult(
+          deviation.deviation ** 2,
+          `Aggregate ${kind} variance`
+        )
+      : deviation.squared / (finite.length - (population ? 0 : 1));
+  }
   if (finite.length < 2) return undefined;
-
-  const variance = squared / (finite.length - 1);
-  if (operation === "variance") return variance;
-  if (operation === "stdev") return Math.sqrt(variance);
-  const stderr = Math.sqrt(variance) / Math.sqrt(finite.length);
+  const stderr = stableFiniteDeviation(finite, {
+    sample: true,
+    divisor: Math.sqrt(finite.length),
+    label: "Aggregate standard error"
+  }).deviation;
   if (operation === "stderr") return stderr;
-  if (operation === "ciLower") return mean - 1.96 * stderr;
-  if (operation === "ciUpper") return mean + 1.96 * stderr;
+  if (operation === "ciLower") {
+    return requireFiniteResult(mean - 1.96 * stderr, "Aggregate lower CI");
+  }
+  if (operation === "ciUpper") {
+    return requireFiniteResult(mean + 1.96 * stderr, "Aggregate upper CI");
+  }
   throw new Error(`Unsupported scalar aggregate "${operation}".`);
 }
 

package/src/grammar/arcs.js

@@ -5,23 +5,50 @@ import {
   readNominalField,
   readQuantitativeField
 } from "./scales/index.js";
+import {
+  interpolateNumber,
+  normalizedFiniteSum,
+  requireFiniteResult,
+  stableFiniteSum
+} from "./numeric.js";
 
 function requireArcLayer(layer) {
   if (layer?.mark?.type !== "arc") {
     throw new Error("Arc derivation requires a semantic arc mark.");
   }
   const theta = layer.encoding?.theta;
-  if (theta === undefined || !["nominal", "ordinal"].includes(theta.fieldType)) {
-    throw new Error(`Arc mark "${layer.id}" requires categorical theta.`);
+  if (
+    theta === undefined ||
+    !["quantitative", "nominal", "ordinal"].includes(theta.fieldType)
+  ) {
+    throw new Error(
+      `Arc mark "${layer.id}" requires quantitative or categorical theta.`
+    );
   }
   return theta;
 }
 
+function requireContinuousThetaScale(scale, label) {
+  if (
+    scale?.type !== "linear" ||
+    !Array.isArray(scale.range) ||
+    scale.range.length !== 2 ||
+    !scale.range.every(Number.isFinite) ||
+    scale.range[0] === scale.range[1]
+  ) {
+    throw new Error(`${label} requires a resolved linear scale.`);
+  }
+  return scale;
+}
+
 function requireBandScale(scale, label) {
   if (
     scale?.type !== "band" ||
     !Array.isArray(scale.domain) ||
     !Array.isArray(scale.range) ||
+    scale.range.length !== 2 ||
+    !scale.range.every(Number.isFinite) ||
+    scale.range[0] === scale.range[1] ||
     !Number.isFinite(scale.bandwidth) ||
     scale.bandwidth <= 0
   ) {
@@ -36,24 +63,90 @@ function colorValues(rows, encoding) {
     : readNominalField(rows, encoding.field);
 }
 
-export function readArcThetaWeights(rows, field, layerId = "arc") {
-  if (!Array.isArray(rows)) throw new TypeError("Arc theta weights require rows.");
+function readNonNegativeArcThetaValues(rows, field, layerId, role) {
+  if (!Array.isArray(rows)) throw new TypeError(`Arc theta ${role}s require rows.`);
   if (typeof field !== "string" || field.length === 0) {
-    throw new TypeError("Arc theta weight must be a non-empty string.");
+    throw new TypeError(`Arc theta ${role} must be a non-empty string.`);
   }
-  const weights = rows.map((row, index) => {
+  const values = rows.map((row, index) => {
     const value = row?.[field];
     if (!Number.isFinite(value) || value < 0) {
       throw new TypeError(
-        `Arc theta weight field "${field}" must contain non-negative finite numbers at row ${index}.`
+        `Arc theta ${role} field "${field}" must contain non-negative finite numbers at row ${index}.`
       );
     }
     return value;
   });
-  if (weights.every(value => value === 0)) {
-    throw new Error(`Arc mark "${layerId}" theta weights must have a positive total.`);
+  if (values.every(value => value === 0)) {
+    throw new Error(`Arc mark "${layerId}" theta ${role}s must have a positive total.`);
   }
-  return cloneAndFreeze(weights);
+  return cloneAndFreeze(values);
+}
+
+export function readArcThetaWeights(rows, field, layerId = "arc") {
+  return readNonNegativeArcThetaValues(rows, field, layerId, "weight");
+}
+
+export function readArcThetaValues(rows, field, layerId = "arc") {
+  return readNonNegativeArcThetaValues(rows, field, layerId, "value");
+}
+
+function resolveProportionalRanges(values, range, labelAt) {
+  const total = values.reduce((sum, value) => sum + value, 0);
+  const normalizedTotal = Number.isFinite(total)
+    ? undefined
+    : normalizedFiniteSum(values, "Arc theta values");
+  if (total === 0 || normalizedTotal?.total <= 0) {
+    throw new Error("Arc theta values must have a positive total.");
+  }
+  const span = range[1] - range[0];
+  let cursor = range[0];
+  let cumulative = 0;
+  let cumulativeCorrection = 0;
+  return values.map((value, index) => {
+    const normalizedValue = normalizedTotal === undefined
+      ? value
+      : value / normalizedTotal.scale;
+    const next = cumulative + normalizedValue;
+    if (normalizedTotal !== undefined) {
+      cumulativeCorrection += Math.abs(cumulative) >= Math.abs(normalizedValue)
+        ? cumulative - next + normalizedValue
+        : normalizedValue - next + cumulative;
+    }
+    cumulative = next;
+    const directEnd = cursor + value / total * span;
+    const endTheta = index === values.length - 1
+      ? range[1]
+      : normalizedTotal === undefined && Number.isFinite(directEnd)
+        ? directEnd
+        : interpolateNumber(
+            range[0],
+            range[1],
+            (cumulative + cumulativeCorrection) /
+              (normalizedTotal?.total ?? total)
+          );
+    if (!Number.isFinite(endTheta) || endTheta === cursor) {
+      throw new RangeError(
+        `Arc theta ${labelAt(index)} cannot resolve a distinct finite sector.`
+      );
+    }
+    const result = { startTheta: cursor, endTheta };
+    cursor = endTheta;
+    return result;
+  });
+}
+
+function resolveProportionalRadii(layer, frame, innerRadiusRatio) {
+  if (!Number.isFinite(frame?.availableRadius) || frame.availableRadius < 0) {
+    throw new RangeError(`Arc mark "${layer.id}" requires a finite available radius.`);
+  }
+  return {
+    innerRadius: requireFiniteResult(
+      frame.availableRadius * innerRadiusRatio,
+      `Arc mark "${layer.id}" inner radius`
+    ),
+    outerRadius: frame.availableRadius
+  };
 }
 
 function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
@@ -73,31 +166,29 @@ function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
       throw new Error(`Arc theta value "${values[index]}" is outside the scale domain.`);
     }
     group.push({
-      row: rows[index],
       color: colors[index],
       sourceIndex: index,
       weight: weights[index]
     });
   }
-  const total = [...groups.values()].reduce(
-    (sum, group) => sum + group.reduce((groupSum, item) => groupSum + item.weight, 0),
-    0
-  );
-  if (total === 0) throw new Error(`Arc mark "${layer.id}" has no positive theta weight.`);
-  const start = thetaScale.range[0];
-  const span = thetaScale.range[1] - thetaScale.range[0];
-  const innerRadius = frame.availableRadius * innerRadiusRatio;
-  let cursor = start;
+  const radii = resolveProportionalRadii(layer, frame, innerRadiusRatio);
   const sectors = [];
   const positiveValues = thetaScale.domain.filter(value =>
     groups.get(value).some(item => item.weight > 0)
   );
+  const aggregateValues = positiveValues.map(value => stableFiniteSum(
+    groups.get(value).map(item => item.weight),
+    `Arc theta group "${String(value)}" aggregate`
+  ));
+  const ranges = resolveProportionalRanges(
+    aggregateValues,
+    thetaScale.range,
+    index => `group "${String(positiveValues[index])}"`
+  );
   for (const [positiveIndex, value] of positiveValues.entries()) {
     const group = groups.get(value);
-    const aggregateValue = group.reduce((sum, item) => sum + item.weight, 0);
-    const endTheta = positiveIndex === positiveValues.length - 1
-      ? thetaScale.range[1]
-      : cursor + aggregateValue / total * span;
+    const aggregateValue = aggregateValues[positiveIndex];
+    const { startTheta, endTheta } = ranges[positiveIndex];
     const distinctColors = [...new Set(group.map(item => item.color))];
     if (distinctColors.length > 1) {
       throw new Error(
@@ -110,17 +201,46 @@ function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
       count: group.length,
       aggregateValue,
       color: distinctColors[0],
-      startTheta: cursor,
+      startTheta,
       endTheta,
-      innerRadius,
-      outerRadius: frame.availableRadius,
+      ...radii,
       sourceIndices: group.map(item => item.sourceIndex)
     });
-    cursor = endTheta;
   }
   return sectors;
 }
 
+function quantitativeSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
+  const theta = layer.encoding.theta;
+  if (layer.encoding?.radius !== undefined) {
+    throw new Error(
+      `Arc mark "${layer.id}" cannot combine quantitative theta with radius.`
+    );
+  }
+  const values = readArcThetaValues(rows, theta.field, layer.id);
+  const colors = colorValues(rows, layer.encoding?.color);
+  const positiveIndices = values
+    .map((value, index) => value > 0 ? index : undefined)
+    .filter(index => index !== undefined);
+  const positiveValues = positiveIndices.map(index => values[index]);
+  const ranges = resolveProportionalRanges(
+    positiveValues,
+    thetaScale.range,
+    index => `row ${positiveIndices[index]}`
+  );
+  const radii = resolveProportionalRadii(layer, frame, innerRadiusRatio);
+  return positiveIndices.map((sourceIndex, index) => ({
+    key: `${String(values[sourceIndex])}:${sourceIndex}`,
+    theta: values[sourceIndex],
+    count: 1,
+    aggregateValue: values[sourceIndex],
+    color: colors[sourceIndex],
+    ...ranges[index],
+    ...radii,
+    sourceIndices: [sourceIndex]
+  }));
+}
+
 function radialSectors(rows, layer, thetaScale, radiusScale) {
   const theta = layer.encoding.theta;
   const radius = layer.encoding?.radius;
@@ -176,7 +296,6 @@ export function deriveArcSectors(rows, layer, {
 } = {}) {
   if (!Array.isArray(rows)) throw new TypeError("Arc derivation requires rows.");
   const theta = requireArcLayer(layer);
-  requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`);
   if (
     !Number.isFinite(innerRadiusRatio) ||
     innerRadiusRatio < 0 ||
@@ -184,8 +303,27 @@ export function deriveArcSectors(rows, layer, {
   ) {
     throw new RangeError("Arc innerRadius must be from 0 (inclusive) to 1 (exclusive).");
   }
-  const sectors = ["count", "sum"].includes(theta.aggregate)
-    ? proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio)
-    : radialSectors(rows, layer, thetaScale, radiusScale);
+  const sectors = theta.fieldType === "quantitative"
+    ? quantitativeSectors(
+        rows,
+        layer,
+        requireContinuousThetaScale(thetaScale, `Arc mark "${layer.id}" theta`),
+        frame,
+        innerRadiusRatio
+      )
+    : ["count", "sum"].includes(theta.aggregate)
+      ? proportionalSectors(
+          rows,
+          layer,
+          requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`),
+          frame,
+          innerRadiusRatio
+        )
+      : radialSectors(
+          rows,
+          layer,
+          requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`),
+          radiusScale
+        );
   return cloneAndFreeze({ sectors });
 }

package/src/grammar/areaSeries.js

@@ -11,6 +11,12 @@ import {
 import { stableOrderPathValues } from "./pathOrder.js";
 import { deriveCategoricalDensitySeries } from "./categoricalDensity.js";
 
+function indexSegments(segments) {
+  const indexed = [];
+  for (const segment of segments) indexed[segment.index] = segment;
+  return indexed;
+}
+
 export function deriveAreaSeries(rows, layer) {
   if (layer?.mark?.type !== "area") {
     throw new Error("Area series derivation requires a semantic area mark.");
@@ -187,15 +193,11 @@ export function deriveCenteredAreaSeries(rows, layer) {
   const valuesBySeries = groupOrder.map(() => []);
   for (const position of orderedPositions) {
     const partition = groupOrder.map(key => byGroup.get(key).get(position));
-    const segments = new Map(
-      layoutSeriesPartition(partition, "center").map(segment => [
-        segment.index,
-        segment
-      ])
-    );
-    let endpoint = -partition.reduce((sum, value) => sum + value, 0) / 2;
+    const resolvedSegments = layoutSeriesPartition(partition, "center");
+    const segments = indexSegments(resolvedSegments);
+    let endpoint = resolvedSegments[0]?.start ?? 0;
     for (let index = 0; index < groupOrder.length; index += 1) {
-      const segment = segments.get(index);
+      const segment = segments[index];
       valuesBySeries[index].push({
         x: position,
         y: partition[index],
@@ -331,17 +333,13 @@ export function layoutDensityAreaSeries(derived, layout = "overlay") {
       }
       return series.values[sample].y;
     });
-    const segments = new Map(
-      layoutSeriesPartition(densities, layout).map(segment => [
-        segment.index,
-        segment
-      ])
-    );
+    const resolvedSegments = layoutSeriesPartition(densities, layout);
+    const segments = indexSegments(resolvedSegments);
     let zeroThicknessEndpoint = layout === "center"
-      ? -densities.reduce((sum, value) => sum + value, 0) / 2
+      ? resolvedSegments[0]?.start ?? 0
       : 0;
     for (let index = 0; index < derived.series.length; index += 1) {
-      const segment = segments.get(index);
+      const segment = segments[index];
       valuesBySeries[index].push({
         x,
         lower: segment?.start ?? zeroThicknessEndpoint,

package/src/grammar/bin2d.js

@@ -2,25 +2,22 @@ import {
   cloneAndFreeze,
   isPlainObject
 } from "../core/immutable.js";
+import { validateNonEmptyString as requireField } from "../core/validation.js";
+import { interpolateNumber, numericExtent } from "./numeric.js";
+
+const MAX_AXIS_BINS = 10_000;
+const MAX_CELLS = 1_000_000;
 
 const TRANSFORM_KEYS = Object.freeze([
   "type", "x", "y", "bins", "extent", "includeEmpty", "members", "as",
   "resolved"
 ]);
-const BIN_KEYS = Object.freeze(["x", "y"]);
-const EXTENT_KEYS = Object.freeze(["x", "y"]);
+const AXIS_KEYS = Object.freeze(["x", "y"]);
 const FIELD_KEYS = Object.freeze(["x0", "x1", "y0", "y1", "count", "members"]);
 const RESOLVED_KEYS = Object.freeze([
   "extent", "edges", "eligibleCount", "occupiedCount"
 ]);
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
 function rejectUnknownKeys(value, supported, label) {
   const unknown = Object.keys(value).find(key => !supported.includes(key));
   if (unknown !== undefined) {
@@ -43,7 +40,7 @@ function normalizeBins(value) {
       "2D bin bins must be a positive integer or an object with x and y."
     );
   }
-  rejectUnknownKeys(value, BIN_KEYS, "2D bin bins");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin bins");
   return { x: value.x, y: value.y };
 }
 
@@ -51,9 +48,15 @@ function validateBins(value) {
   if (!isPlainObject(value)) {
     throw new TypeError("2D bin bins must be an object.");
   }
-  rejectUnknownKeys(value, BIN_KEYS, "2D bin bins");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin bins");
   requirePositiveInteger(value.x, "2D bin x bins");
   requirePositiveInteger(value.y, "2D bin y bins");
+  if (value.x > MAX_AXIS_BINS || value.y > MAX_AXIS_BINS) {
+    throw new RangeError(`2D bin axes support at most ${MAX_AXIS_BINS} bins.`);
+  }
+  if (value.x * value.y > MAX_CELLS) {
+    throw new RangeError(`2D bin grids support at most ${MAX_CELLS} cells.`);
+  }
 }
 
 function normalizeRequestedExtent(value) {
@@ -61,7 +64,7 @@ function normalizeRequestedExtent(value) {
   if (!isPlainObject(value)) {
     throw new TypeError("2D bin extent must be an object.");
   }
-  rejectUnknownKeys(value, EXTENT_KEYS, "2D bin extent");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin extent");
   return {
     x: value.x ?? "auto",
     y: value.y ?? "auto"
@@ -84,7 +87,7 @@ function validateRequestedExtent(value) {
   if (!isPlainObject(value)) {
     throw new TypeError("2D bin extent must be an object.");
   }
-  rejectUnknownKeys(value, EXTENT_KEYS, "2D bin extent");
+  rejectUnknownKeys(value, AXIS_KEYS, "2D bin extent");
   validateExtentValue(value.x, "2D bin x extent");
   validateExtentValue(value.y, "2D bin y extent");
 }
@@ -152,9 +155,9 @@ function validateResolved(value, bins) {
   if (!isPlainObject(value.extent) || !isPlainObject(value.edges)) {
     throw new TypeError("Resolved 2D bin extent and edges must be objects.");
   }
-  rejectUnknownKeys(value.extent, EXTENT_KEYS, "resolved 2D bin extent");
-  rejectUnknownKeys(value.edges, EXTENT_KEYS, "resolved 2D bin edges");
-  for (const axis of ["x", "y"]) {
+  rejectUnknownKeys(value.extent, AXIS_KEYS, "resolved 2D bin extent");
+  rejectUnknownKeys(value.edges, AXIS_KEYS, "resolved 2D bin edges");
+  for (const axis of AXIS_KEYS) {
     validateExtentValue(
       value.extent[axis],
       `Resolved 2D bin ${axis} extent`,
@@ -223,8 +226,7 @@ export function normalizeBin2DTransform({
 }
 
 function resolveExtent(values, requested, axis) {
-  const minimum = Math.min(...values);
-  const maximum = Math.max(...values);
+  const [minimum, maximum] = numericExtent(values);
   const extent = requested === "auto" ? [minimum, maximum] : requested;
   if (extent[0] > minimum || extent[1] < maximum) {
     throw new RangeError(
@@ -237,12 +239,24 @@ function resolveExtent(values, requested, axis) {
   return [...extent];
 }
 
-function createEdges(extent, count) {
+function createEdges(extent, count, axis) {
   const [minimum, maximum] = extent;
   const step = (maximum - minimum) / count;
-  return Array.from({ length: count + 1 }, (_, index) =>
-    index === count ? maximum : minimum + step * index
+  const edges = Array.from({ length: count + 1 }, (_, index) =>
+    index === count
+      ? maximum
+      : Number.isFinite(step)
+        ? minimum + step * index
+        : interpolateNumber(minimum, maximum, index / count)
   );
+  if (edges.some((edge, index) =>
+    !Number.isFinite(edge) || index > 0 && edge <= edges[index - 1]
+  )) {
+    throw new RangeError(
+      `2D bin ${axis} extent cannot represent ${count} distinct bins.`
+    );
+  }
+  return edges;
 }
 
 function findBinIndex(value, edges) {
@@ -287,8 +301,8 @@ export function deriveBin2DRows(rows, transform) {
     )
   };
   const edges = {
-    x: createEdges(extent.x, transform.bins.x),
-    y: createEdges(extent.y, transform.bins.y)
+    x: createEdges(extent.x, transform.bins.x, "x"),
+    y: createEdges(extent.y, transform.bins.y, "y")
   };
   const buckets = Array.from(
     { length: transform.bins.x * transform.bins.y },

package/src/grammar/boxPlot.js

@@ -1,4 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { interpolateNumber, stableDecimal } from "./numeric.js";
 
 export const BOX_FIELDS = Object.freeze({
   q1: "__boxPlot_q1", median: "__boxPlot_median", q3: "__boxPlot_q3",
@@ -7,10 +8,10 @@ export const BOX_FIELDS = Object.freeze({
   count: "__boxPlot_count"
 });
 
-const TRANSFORM_KEYS = Object.freeze([
+const TRANSFORM_KEYS = [
   "type", "category", "field", "method", "whisker", "factor", "as"
-]);
-const OUTPUT_KEYS = Object.freeze(Object.keys(BOX_FIELDS));
+];
+const OUTPUT_KEYS = Object.keys(BOX_FIELDS);
 
 function field(value, label) {
   if (typeof value !== "string" || value.length === 0) throw new TypeError(`${label} must be a non-empty string.`);
@@ -82,11 +83,7 @@ function quantile(sorted, p) {
   const position = (sorted.length - 1) * p;
   const lower = Math.floor(position);
   const upper = Math.ceil(position);
-  return sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
-}
-
-function stableNumber(value) {
-  return Number(value.toFixed(12));
+  return interpolateNumber(sorted[lower], sorted[upper], position - lower);
 }
 
 export function deriveBoxData(rows, transform) {
@@ -113,15 +110,19 @@ export function deriveBoxData(rows, transform) {
   const outlierSet = new Set();
   for (const group of groups) {
     const sorted = group.rows.map(row => row[measure]).sort((a, b) => a - b);
-    const q1 = stableNumber(quantile(sorted, 0.25));
-    const median = stableNumber(quantile(sorted, 0.5));
-    const q3 = stableNumber(quantile(sorted, 0.75));
+    const [q1, median, q3] = [0.25, 0.5, 0.75].map(probability =>
+      stableDecimal(quantile(sorted, probability))
+    );
+    const spread = q3 - q1;
     const lowerFence = whisker === "minmax"
       ? sorted[0]
-      : stableNumber(q1 - factor * (q3 - q1));
+      : stableDecimal(q1 - factor * spread);
     const upperFence = whisker === "minmax"
       ? sorted.at(-1)
-      : stableNumber(q3 + factor * (q3 - q1));
+      : stableDecimal(q3 + factor * spread);
+    if (![lowerFence, upperFence].every(Number.isFinite)) {
+      throw new RangeError("Box Tukey fences are outside the finite numeric range.");
+    }
     const inliers = sorted.filter(value => value >= lowerFence && value <= upperFence);
     const lowerWhisker = inliers[0];
     const upperWhisker = inliers.at(-1);