ggaction 0.0.17 → 0.0.19

package/src/grammar/parallelCoordinates.js

@@ -1,3 +1,4 @@
+import { requireStringValue as nonEmptyString } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { validateUserId } from "../core/identifiers.js";
 import { validateOptionObject } from "../core/validation.js";
@@ -18,12 +19,6 @@ const DIMENSION_SCALE_OPTIONS = Object.freeze([
   "padding", "align", "unknown"
 ]);
 
-function nonEmptyString(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function validateParallelKeyField(value) {
   return nonEmptyString(value, "Parallel key field");

package/src/grammar/parseTime.js

@@ -0,0 +1,41 @@
+import { normalizeTemporalValue } from "./scales/fields.js";
+
+export const PARSE_TIME_FORMATS = Object.freeze([
+  "auto", "%Y-%m-%d", "%d/%m/%Y", "%m/%d/%Y"
+]);
+
+export function validateParseTimeFormat(format = "auto") {
+  if (!PARSE_TIME_FORMATS.includes(format)) {
+    throw new Error(`Unsupported parseTime format "${format}".`);
+  }
+  return format;
+}
+
+// Explicit calendar formats are UTC and reject rollover, rather than guessing
+// the day/month order. Invalid or nullish values remain missing data as null.
+export function parseTimeValue(value, format = "auto") {
+  validateParseTimeFormat(format);
+  if (value === null || value === undefined) return null;
+  if (format === "auto") {
+    try { return normalizeTemporalValue(value); }
+    catch (error) {
+      if (error instanceof TypeError || error instanceof RangeError) return null;
+      throw error;
+    }
+  }
+  if (typeof value !== "string") return null;
+  const match = (format === "%Y-%m-%d"
+    ? /^(\d{4})-(\d{1,2})-(\d{1,2})$/
+    : /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/).exec(value.trim());
+  if (!match) return null;
+  const numbers = match.slice(1).map(Number);
+  const [year, month, day] = format === "%Y-%m-%d" ? numbers
+    : format === "%d/%m/%Y" ? [numbers[2], numbers[1], numbers[0]]
+      : [numbers[2], numbers[0], numbers[1]];
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1
+    && date.getUTCDate() === day && Number.isFinite(date.getTime())
+    ? date.getTime() : null;
+}

package/src/grammar/pathCommands.js

@@ -1,6 +1,12 @@
 import { freezeOwned, isPlainObject } from "../core/immutable.js";
 import { validateGeneratedItemLimit } from "../core/validation.js";
 
+export const MAX_PATH_COMMANDS = 20_000;
+
+export function validatePathCommandCount(count, label) {
+  return validateGeneratedItemLimit(count, label, MAX_PATH_COMMANDS);
+}
+
 const COMMAND_KEYS = Object.freeze({
   M: Object.freeze(["op", "x", "y"]),
   L: Object.freeze(["op", "x", "y"]),
@@ -35,14 +41,15 @@ function validateCommand(command, index) {
 }
 
 export function validatePathCommands(commands) {
-  if (!Array.isArray(commands) || commands.length < 2) {
-    throw new TypeError("path.commands must contain at least two commands.");
+  if (!Array.isArray(commands) || commands.length < 1) {
+    throw new TypeError("path.commands must contain at least one command.");
   }
-  validateGeneratedItemLimit(commands.length, "path.commands length");
+  validatePathCommandCount(commands.length, "path.commands length");
   commands.forEach(validateCommand);
   if (commands[0].op !== "M") {
     throw new Error("path.commands must start with M.");
   }
+  if (commands.length === 1) return commands;
   if (commands.slice(1).some(command => command.op === "M")) {
     throw new Error("path.commands supports one subpath and only one initial M.");
   }
@@ -79,7 +86,7 @@ export function buildLinearPathCommands(points, { close = false } = {}) {
   if (typeof close !== "boolean") {
     throw new TypeError("Linear path close must be a boolean.");
   }
-  validateGeneratedItemLimit(
+  validatePathCommandCount(
     points.length + Number(close),
     "Linear path command count"
   );

package/src/grammar/pointShapes.js

@@ -14,7 +14,9 @@ export const POINT_SHAPES = cloneAndFreeze([
   "cross",
   "star",
   "hexagon",
-  "wye"
+  "wye",
+  "wedge",
+  "arrow"
 ]);
 
 const SHAPE_SET = new Set(POINT_SHAPES);
@@ -98,7 +100,19 @@ function shapePolygon(shape) {
     cross: rotate(plus, Math.PI / 4),
     star: alternatingPolygon(5, 0.45),
     hexagon: regularPolygon(6),
-    wye: alternatingPolygon(3, 0.28)
+    wye: alternatingPolygon(3, 0.28),
+    wedge: [
+      { x: 0, y: -2 / Math.sqrt(3) },
+      { x: -1 / 4, y: 1 / Math.sqrt(3) },
+      { x: 1 / 4, y: 1 / Math.sqrt(3) }
+    ],
+    // The directional arrow is anchored at its bounding-box center, not its centroid.
+    arrow: [
+      { x: -1 / 7, y: 1 }, { x: 1 / 7, y: 1 },
+      { x: 1 / 7, y: -1 / 8 }, { x: 2 / 5, y: -1 / 8 },
+      { x: 0, y: -1 }, { x: -2 / 5, y: -1 / 8 },
+      { x: -1 / 7, y: -1 / 8 }
+    ]
   }[shape];
 }
 

package/src/grammar/polar.js

@@ -1,184 +1 @@
-import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { validateOptionObject } from "../core/validation.js";
-import { validatePair } from "./scales/validation.js";
-
-const POLAR_FRAME_OPTIONS = Object.freeze(["center", "radius"]);
-const POLAR_CENTER_OPTIONS = Object.freeze(["x", "y"]);
-const POLAR_RADIUS_OPTIONS = Object.freeze(["unit", "value"]);
-const POLAR_RADIUS_UNITS = new Set(["fraction", "px"]);
-
-function validateBounds(bounds) {
-  if (
-    !isPlainObject(bounds) ||
-    ![bounds.x, bounds.y, bounds.width, bounds.height].every(Number.isFinite) ||
-    bounds.width < 0 ||
-    bounds.height < 0
-  ) {
-    throw new TypeError(
-      "Polar geometry requires finite, non-negative graphical bounds."
-    );
-  }
-  return bounds;
-}
-
-function finiteUnitInterval(value, label) {
-  if (!Number.isFinite(value) || value < 0 || value > 1) {
-    throw new RangeError(`${label} must be a finite number from 0 through 1.`);
-  }
-  return value;
-}
-
-export function normalizePolarFrameOptions(value) {
-  if (value === "auto") return value;
-  if (!isPlainObject(value)) {
-    throw new TypeError('Polar frame must be "auto" or a plain object.');
-  }
-  validateOptionObject(value, POLAR_FRAME_OPTIONS, "polar frame");
-  const center = value.center ?? {};
-  if (!isPlainObject(center)) {
-    throw new TypeError("Polar frame center must be a plain object.");
-  }
-  validateOptionObject(center, POLAR_CENTER_OPTIONS, "polar frame center");
-  const radius = value.radius ?? { unit: "fraction", value: 1 };
-  if (!isPlainObject(radius)) {
-    throw new TypeError("Polar frame radius must be a plain object.");
-  }
-  validateOptionObject(radius, POLAR_RADIUS_OPTIONS, "polar frame radius", {
-    allowEmpty: false,
-    emptyError: TypeError
-  });
-  if (!POLAR_RADIUS_UNITS.has(radius.unit)) {
-    throw new Error(`Unknown Polar frame radius unit "${radius.unit}".`);
-  }
-  if (!Number.isFinite(radius.value) || radius.value <= 0) {
-    throw new RangeError("Polar frame radius must be a positive finite number.");
-  }
-  if (radius.unit === "fraction" && radius.value > 1) {
-    throw new RangeError("Polar frame radius fraction must not exceed 1.");
-  }
-  return cloneAndFreeze({
-    center: {
-      x: finiteUnitInterval(center.x ?? 0.5, "Polar frame center x"),
-      y: finiteUnitInterval(center.y ?? 0.5, "Polar frame center y")
-    },
-    radius: {
-      unit: radius.unit,
-      value: radius.value
-    }
-  });
-}
-
-export function resolvePolarFrame(bounds, requestedFrame = "auto") {
-  validateBounds(bounds);
-  if (requestedFrame === undefined || requestedFrame === "auto") {
-    return cloneAndFreeze({
-      centerX: bounds.x + bounds.width / 2,
-      centerY: bounds.y + bounds.height / 2,
-      availableRadius: Math.min(bounds.width, bounds.height) / 2
-    });
-  }
-  const requested = normalizePolarFrameOptions(requestedFrame);
-  const centerX = bounds.x + bounds.width * requested.center.x;
-  const centerY = bounds.y + bounds.height * requested.center.y;
-  const maximumRadius = Math.min(
-    centerX - bounds.x,
-    bounds.x + bounds.width - centerX,
-    centerY - bounds.y,
-    bounds.y + bounds.height - centerY
-  );
-  if (!Number.isFinite(maximumRadius) || maximumRadius <= 0) {
-    throw new RangeError(
-      "Polar frame center must leave a positive radius inside its bounds."
-    );
-  }
-  const availableRadius = requested.radius.unit === "fraction"
-    ? maximumRadius * requested.radius.value
-    : requested.radius.value;
-  if (availableRadius > maximumRadius) {
-    throw new RangeError(
-      `Polar frame radius ${availableRadius} exceeds the maximum radius ${maximumRadius}.`
-    );
-  }
-  return cloneAndFreeze({
-    centerX,
-    centerY,
-    availableRadius
-  });
-}
-
-export function validateThetaRange(range) {
-  if (range === "auto") return range;
-  const validated = validatePair(range, "Theta scale range");
-  if (Math.abs(validated[1] - validated[0]) > 360) {
-    throw new RangeError("Theta scale range span must not exceed 360 degrees.");
-  }
-  return validated;
-}
-
-export function validateRadialRange(range, availableRadius) {
-  if (range === "auto") return range;
-  const validated = validatePair(range, "Radius scale range");
-  if (validated.some(value => value < 0)) {
-    throw new RangeError("Radius scale range values must be non-negative.");
-  }
-  if (
-    availableRadius !== undefined &&
-    validated.some(value => value > availableRadius)
-  ) {
-    throw new RangeError(
-      `Radius scale range must fit within the available radius ${availableRadius}.`
-    );
-  }
-  return validated;
-}
-
-export function resolvePolarScaleRange(range, channel, bounds, frame) {
-  if (channel === "theta") {
-    return range === "auto"
-      ? cloneAndFreeze([0, 360])
-      : validateThetaRange(range);
-  }
-  if (channel !== "radius") {
-    throw new Error(`Unknown Polar position channel "${channel}".`);
-  }
-  const resolvedFrame = frame ?? resolvePolarFrame(bounds);
-  return range === "auto"
-    ? cloneAndFreeze([0, resolvedFrame.availableRadius])
-    : validateRadialRange(range, resolvedFrame.availableRadius);
-}
-
-export function polarDirection(theta) {
-  if (!Number.isFinite(theta)) {
-    throw new TypeError("Polar theta must be a finite number of degrees.");
-  }
-  const angle = theta * Math.PI / 180;
-  return cloneAndFreeze({
-    x: Math.sin(angle),
-    y: -Math.cos(angle)
-  });
-}
-
-export function polarToCartesian({ theta, radius, frame }) {
-  const direction = polarDirection(theta);
-  if (!Number.isFinite(radius) || radius < 0) {
-    throw new TypeError("Polar radius must be a non-negative finite number.");
-  }
-  const resolvedFrame = frame?.availableRadius === undefined
-    ? resolvePolarFrame(frame)
-    : frame;
-  if (
-    ![resolvedFrame.centerX, resolvedFrame.centerY,
-      resolvedFrame.availableRadius].every(Number.isFinite)
-  ) {
-    throw new TypeError("Polar frame must contain finite geometry.");
-  }
-  if (radius > resolvedFrame.availableRadius) {
-    throw new RangeError(
-      `Polar radius ${radius} exceeds the available radius ${resolvedFrame.availableRadius}.`
-    );
-  }
-  return cloneAndFreeze({
-    x: resolvedFrame.centerX + radius * direction.x,
-    y: resolvedFrame.centerY + radius * direction.y
-  });
-}
+import{cloneAndFreeze as n,isPlainObject as l}from"../core/immutable.js";import{validateOptionObject as u}from"../core/validation.js";import{validatePair as c}from"./scales/validation.js";const w=Object.freeze(["center","radius","overflow"]),h=Object.freeze(["x","y"]),d=Object.freeze(["unit","value"]),p=new Set(["fraction","px"]);function v(e){if(!l(e)||![e.x,e.y,e.width,e.height].every(Number.isFinite)||e.width<0||e.height<0)throw new TypeError("Polar geometry requires finite, non-negative graphical bounds.");return e}function s(e,r){if(!Number.isFinite(e)||e<0||e>1)throw new RangeError(`${r} must be a finite number from 0 through 1.`);return e}function R(e){if(e==="auto")return e;if(!l(e))throw new TypeError('Polar frame must be "auto" or a plain object.');if(u(e,w,"polar frame"),e.overflow!==void 0&&!["error","allow"].includes(e.overflow))throw new Error("Polar frame overflow must be error or allow.");const r=e.center??{};if(!l(r))throw new TypeError("Polar frame center must be a plain object.");u(r,h,"polar frame center");const t=e.radius??{unit:"fraction",value:1};if(!l(t))throw new TypeError("Polar frame radius must be a plain object.");if(u(t,d,"polar frame radius",{allowEmpty:!1,emptyError:TypeError}),!p.has(t.unit))throw new Error(`Unknown Polar frame radius unit "${t.unit}".`);if(!Number.isFinite(t.value)||t.value<=0)throw new RangeError("Polar frame radius must be a positive finite number.");if(t.unit==="fraction"&&t.value>1)throw new RangeError("Polar frame radius fraction must not exceed 1.");return n({center:{x:s(r.x??.5,"Polar frame center x"),y:s(r.y??.5,"Polar frame center y")},radius:{unit:t.unit,value:t.value},...e.overflow==="allow"?{overflow:"allow"}:{}})}function m(e,r="auto"){if(v(e),r===void 0||r==="auto")return n({centerX:e.x+e.width/2,centerY:e.y+e.height/2,availableRadius:Math.min(e.width,e.height)/2});const t=R(r),a=e.x+e.width*t.center.x,i=e.y+e.height*t.center.y,o=Math.min(a-e.x,e.x+e.width-a,i-e.y,e.y+e.height-i);if(!Number.isFinite(o)||o<=0)throw new RangeError("Polar frame center must leave a positive radius inside its bounds.");const f=t.radius.unit==="fraction"?o*t.radius.value:t.radius.value;if(f>o&&t.overflow!=="allow")throw new RangeError(`Polar frame radius ${f} exceeds the maximum radius ${o}.`);return n({centerX:a,centerY:i,availableRadius:f})}function P(e){if(e==="auto")return e;const r=c(e,"Theta scale range");if(Math.abs(r[1]-r[0])>360)throw new RangeError("Theta scale range span must not exceed 360 degrees.");return r}function x(e,r){if(e==="auto")return e;const t=c(e,"Radius scale range");if(t.some(a=>a<0))throw new RangeError("Radius scale range values must be non-negative.");if(r!==void 0&&t.some(a=>a>r))throw new RangeError(`Radius scale range must fit within the available radius ${r}.`);return t}function T(e,r,t,a){if(r==="theta")return e==="auto"?n([0,360]):P(e);if(r!=="radius")throw new Error(`Unknown Polar position channel "${r}".`);const i=a??m(t);return e==="auto"?n([0,i.availableRadius]):x(e,i.availableRadius)}function y(e){if(!Number.isFinite(e))throw new TypeError("Polar theta must be a finite number of degrees.");const r=e*Math.PI/180;return n({x:Math.sin(r),y:-Math.cos(r)})}function b({theta:e,radius:r,frame:t}){const a=y(e);if(!Number.isFinite(r)||r<0)throw new TypeError("Polar radius must be a non-negative finite number.");const i=t?.availableRadius===void 0?m(t):t;if(![i.centerX,i.centerY,i.availableRadius].every(Number.isFinite))throw new TypeError("Polar frame must contain finite geometry.");if(r>i.availableRadius)throw new RangeError(`Polar radius ${r} exceeds the available radius ${i.availableRadius}.`);return n({x:i.centerX+r*a.x,y:i.centerY+r*a.y})}export{R as normalizePolarFrameOptions,y as polarDirection,b as polarToCartesian,m as resolvePolarFrame,T as resolvePolarScaleRange,x as validateRadialRange,P as validateThetaRange};

package/src/grammar/positionCompatibility.js

@@ -6,14 +6,14 @@ export const POSITION_FIELD_COMPATIBILITY = Object.freeze({
     radius: Object.freeze(["quantitative"])
   }),
   line: Object.freeze({
-    x: Object.freeze(["quantitative", "temporal"]),
+    x: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
     y: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
     theta: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
     radius: Object.freeze(["quantitative"])
   }),
   area: Object.freeze({
-    x: Object.freeze(["quantitative", "temporal"]),
-    y: Object.freeze(["quantitative", "temporal"])
+    x: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"]),
+    y: Object.freeze(["quantitative", "temporal", "ordinal", "nominal"])
   }),
   arc: Object.freeze({
     theta: Object.freeze(["quantitative", "ordinal", "nominal"]),

package/src/grammar/regression/derive.js

@@ -3,7 +3,7 @@ import {
   readNominalField,
   readQuantitativeField
 } from "../scales/index.js";
-import { fitRegressionGroup, predictRegressionAt } from "./models.js";
+import { fitRegressionGroup, predictRegressionAt, linearRegressionStatistics } from "./models.js";
 import { requireFiniteResult } from "../numeric.js";
 import {
   validateGeneratedItemLimit,
@@ -24,6 +24,7 @@ export function deriveRegression(values, {
   method,
   degree,
   span,
+  robustIterations,
   confidenceMethod,
   level,
   confidence,
@@ -43,6 +44,7 @@ export function deriveRegression(values, {
     method,
     degree,
     span,
+    robustIterations,
     confidenceMethod,
     level,
     confidence,
@@ -79,6 +81,7 @@ export function deriveRegression(values, {
   }
   const groups = [...groupedRows.keys()];
   const models = [];
+  const statistics = [];
   const rows = [];
   let work = 0;
 
@@ -102,7 +105,11 @@ export function deriveRegression(values, {
       const size = parameters.degree + 1;
       work += groupRows.length * size ** 2 + size ** 3;
     } else if (parameters.method === "loess") {
-      work += groupRows.length * xValues.length *
+      const observedSet = new Set(observedX);
+      const newPredictions = predict === undefined ? 0 :
+        xValues.filter(value => !observedSet.has(value)).length;
+      work += groupRows.length *
+        (observedX.length * (1 + (parameters.robustIterations ?? 0)) + newPredictions) *
         Math.ceil(Math.log2(groupRows.length + 1));
     }
     validateWorkLimit(work, "Regression computation");
@@ -113,6 +120,10 @@ export function deriveRegression(values, {
       parameters
     });
     models.push({ ...(groupBy === undefined ? {} : { group }), ...model, xValues });
+    if (parameters.method === "linear") statistics.push({
+      ...(groupBy === undefined ? {} : { group }),
+      ...linearRegressionStatistics(groupRows, model, { x, y })
+    });
 
     for (const xValue of xValues) {
       const prediction = predictRegressionAt(model, xValue, parameters);
@@ -157,6 +168,9 @@ export function deriveRegression(values, {
     parameters,
     groups,
     models,
+    ...(parameters.method === "linear" ? {
+      fitStatistics: { version: 1, method: "linear", groups: statistics }
+    } : {}),
     values: rows,
     ...(missing === undefined ? {} : {
       report: {

package/src/grammar/regression/models.js

@@ -376,7 +376,56 @@ function weightedPrediction(items, x, y, xValue, xScale = 1, yScale = 1) {
   return meanY - (variance === 0 ? 0 : covariance / variance) * meanDifference;
 }
 
-function fitLoessGroup(rows, { x, y, group, span }) {
+function applyResidualWeights(neighbors, residualWeights) {
+  if (!neighbors.some(item => item.weight > 0)) {
+    neighbors = neighbors.map(item => ({ ...item, weight: 1 }));
+  }
+  if (residualWeights === undefined) return neighbors;
+  const weighted = neighbors.map(item => ({
+    ...item, weight: item.weight * residualWeights[item.index]
+  }));
+  return weighted.some(item => item.weight > 0) ? weighted : neighbors;
+}
+
+function loessPrediction(rows, {
+  x, y, xValue, xScale, yScale, neighborCount, residualWeights, scaled = false
+}, label) {
+  const rawDistances = rows.map(row => Math.abs(row[x] - xValue));
+  const scaledDistances = scaled || rawDistances.some(value => !Number.isFinite(value));
+  const neighbors = rows
+    .map((row, index) => ({
+      row,
+      index,
+      distance: scaledDistances
+        ? Math.abs(row[x] / xScale - xValue / xScale)
+        : rawDistances[index]
+    }))
+    .sort((left, right) =>
+      left.distance - right.distance || left.index - right.index
+    )
+    .slice(0, neighborCount);
+  const radius = neighbors.at(-1).distance;
+  let weighted = neighbors.map(neighbor => ({
+    ...neighbor,
+    weight: radius === 0
+      ? 1
+      : (1 - (neighbor.distance / radius) ** 3) ** 3
+  }));
+  weighted = applyResidualWeights(weighted, residualWeights);
+  const ordinary = weightedPrediction(weighted, x, y, xValue);
+  return {
+    prediction: Number.isFinite(ordinary)
+      ? ordinary
+      : restoreFiniteScale(
+          weightedPrediction(weighted, x, y, xValue, xScale, yScale),
+          yScale,
+          label
+        ),
+    neighborIndices: weighted.map(item => item.index)
+  };
+}
+
+function fitLoessGroup(rows, { x, y, group, span, robustIterations = 0 }) {
   const groupLabel = group === undefined ? "all" : String(group);
   const label = `LOESS regression group "${groupLabel}"`;
   if (rows.length < 2 || new Set(rows.map(row => row[x])).size < 2) {
@@ -390,67 +439,100 @@ function fitLoessGroup(rows, { x, y, group, span }) {
     .sort((left, right) => left - right);
   const xScale = maximumMagnitude(rows.map(row => row[x])) || 1;
   const yScale = maximumMagnitude(rows.map(row => row[y])) || 1;
-  const fits = xValues.map(xValue => {
-    const rawDistances = rows.map(row => Math.abs(row[x] - xValue));
-    const scaledDistances = rawDistances.some(value => !Number.isFinite(value));
-    const neighbors = rows
-      .map((row, index) => ({
-        row,
-        index,
-        distance: scaledDistances
-          ? Math.abs(row[x] / xScale - xValue / xScale)
-          : rawDistances[index]
-      }))
-      .sort((left, right) =>
-        left.distance - right.distance || left.index - right.index
-      )
-      .slice(0, 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, x, y, xValue);
-    return {
-      x: xValue,
-      prediction: Number.isFinite(ordinary)
-        ? ordinary
-        : restoreFiniteScale(
-            weightedPrediction(weighted, x, y, xValue, xScale, yScale),
-            yScale,
-            `${label} prediction`
-          ),
-      neighborIndices: weighted.map(item => item.index)
-    };
-  });
-  return { count: rows.length, span, neighborCount, fits, rows, x, y, xScale, yScale };
+  const fitAtObserved = residualWeights => xValues.map(xValue => ({
+    x: xValue,
+    ...loessPrediction(rows, {
+      x, y, xValue, xScale, yScale, neighborCount, residualWeights
+    }, `${label} prediction`)
+  }));
+  let fits = fitAtObserved();
+  let residualWeights;
+  for (let iteration = 0; iteration < robustIterations; iteration += 1) {
+    const predictions = new Map(fits.map(fit => [fit.x, fit.prediction]));
+    const residuals = rows.map(row => Math.abs(row[y] / yScale - predictions.get(row[x]) / yScale));
+    const sorted = [...residuals].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 === 0
+      ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+    const tolerance = 64 * Number.EPSILON;
+    const cutoff = 6 * median;
+    const nextWeights = residuals.map(residual => {
+      if (cutoff <= tolerance) return residual <= tolerance ? 1 : 0;
+      const ratio = residual / cutoff;
+      return ratio >= 1 ? 0 : (1 - ratio * ratio) ** 2;
+    });
+    if (nextWeights.every((weight, index) => weight === (residualWeights?.[index] ?? 1))) break;
+    residualWeights = nextWeights;
+    fits = fitAtObserved(residualWeights);
+  }
+  return { count: rows.length, span, neighborCount, fits, rows, x, y, xScale, yScale,
+    ...(robustIterations === 0 ? {} : { robustIterations, residualWeights: residualWeights ?? rows.map(() => 1) }) };
 }
 
 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"
+  return loessPrediction(model.rows, {
+    ...model, xValue, scaled: true
+  }, "LOESS regression prediction").prediction;
+}
+
+function fitExponentialGroup(rows, { x, y, group }) {
+  const label = `Regression group "${group === undefined ? "all" : String(group)}"`;
+  if (rows.length < 2) throw new Error(`${label} requires at least two rows.`);
+  if (rows.some(row => !(row[y] > 0))) {
+    throw new RangeError("Exponential regression y values must be strictly positive.");
+  }
+  const xValues = rows.map(row => row[x]);
+  if (new Set(xValues).size < 2) throw new Error(`${label} requires varying x values.`);
+  const responseScale = maximumMagnitude(rows.map(row => row[y]));
+  const xMagnitude = maximumMagnitude(xValues) || 1;
+  const weights = rows.map(row => row[y] / responseScale);
+  const weightSum = weights.reduce((sum, value) => sum + value, 0);
+  const logs = rows.map(row => Math.log(row[y]));
+  const meanX = restoreFiniteScale(rows.reduce((sum, row, index) =>
+    sum + weights[index] * (row[x] / xMagnitude), 0) / weightSum,
+  xMagnitude, `${label} weighted x mean`);
+  const meanLogY = logs.reduce((sum, value, index) => sum + weights[index] * value, 0) / weightSum;
+  const [centeredX, xScale] = normalizedCoordinates(xValues, meanX);
+  const variance = centeredX.reduce((sum, value, index) => sum + weights[index] * value ** 2, 0);
+  if (variance === 0) throw new Error(`${label} requires varying x values.`);
+  const covariance = centeredX.reduce((sum, value, index) =>
+    sum + weights[index] * value * (logs[index] - meanLogY), 0);
+  const rate = restoreFiniteRatio(covariance / variance, 1, xScale, `${label} exponential rate`);
+  const logAmplitude = requireFiniteResult(meanLogY - rate * meanX, `${label} exponential log amplitude`);
+  const amplitude = requireFiniteResult(Math.exp(logAmplitude), `${label} exponential amplitude`);
+  if (amplitude === 0) throw new RangeError("Exponential regression amplitude must be positive and representable.");
+  return { count: rows.length, amplitude, rate, logAmplitude };
+}
+
+export function linearRegressionStatistics(rows, model, { x, y }) {
+  const responseScale = maximumMagnitude(rows.map(row => row[y])) || 1;
+  const [coordinates, xScale] = normalizedCoordinates(rows.map(row => row[x]), model.meanX);
+  const normalizedSlope = model.normalizedResponseSlope ?? (
+    Number.isFinite(model.slope * xScale) && (model.slope * xScale !== 0 || model.slope === 0)
+      ? model.slope * xScale / responseScale
+      : restoreFiniteRatio(model.slope, xScale, responseScale, "Linear regression normalized slope")
   );
+  let residualSquares = 0;
+  let totalSquares = 0;
+  rows.forEach((row, index) => {
+    const difference = row[y] - model.meanY;
+    const centered = Number.isFinite(difference)
+      ? difference / responseScale
+      : row[y] / responseScale - model.meanY / responseScale;
+    const residual = centered - normalizedSlope * coordinates[index];
+    totalSquares += centered ** 2;
+    residualSquares += residual ** 2;
+  });
+  return {
+    count: rows.length, intercept: model.intercept, slope: model.slope,
+    rSquared: totalSquares === 0 ? null : 1 - residualSquares / totalSquares
+  };
 }
 
 export function fitRegressionGroup(rows, { x, y, group, parameters }) {
+  if (parameters.method === "exp") return fitExponentialGroup(rows, { x, y, group });
   if (parameters.method === "linear") {
     return fitLinearGroup(rows, {
       x,
@@ -472,7 +554,8 @@ export function fitRegressionGroup(rows, { x, y, group, parameters }) {
       interval: parameters.interval
     });
   }
-  return fitLoessGroup(rows, { x, y, group, span: parameters.span });
+  return fitLoessGroup(rows, { x, y, group, span: parameters.span,
+    robustIterations: parameters.robustIterations });
 }
 
 export function predictRegressionAt(model, xValue, parameters) {
@@ -481,9 +564,14 @@ export function predictRegressionAt(model, xValue, parameters) {
     : undefined;
   const prediction = parameters.method === "linear"
     ? linearPrediction(model, xValue)
+    : parameters.method === "exp"
+      ? requireFiniteResult(Math.exp(model.logAmplitude + model.rate * xValue), "Exponential regression prediction")
     : parameters.method === "polynomial"
       ? polynomial.prediction
       : predictLoessAt(model, xValue);
+  if (parameters.method === "exp" && prediction === 0) {
+    throw new RangeError("Exponential regression prediction must be positive and representable.");
+  }
   if (parameters.method === "loess" || parameters.interval === false) return { prediction };
   const leverage = parameters.method === "linear"
     ? model.normalizedSxx !== undefined