ggaction 0.0.16 → 0.0.18

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

@@ -24,10 +24,13 @@ export function deriveRegression(values, {
   method,
   degree,
   span,
+  robustIterations,
   confidenceMethod,
   level,
   confidence,
-  interval
+  interval,
+  predict,
+  missing
 } = {}) {
   if (!Array.isArray(values)) {
     throw new TypeError("Regression values must be an array.");
@@ -41,20 +44,35 @@ export function deriveRegression(values, {
     method,
     degree,
     span,
+    robustIterations,
     confidenceMethod,
     level,
     confidence,
     interval
   });
-  readQuantitativeField(values, x);
-  readQuantitativeField(values, y);
-  if (groupBy !== undefined) readNominalField(values, groupBy);
+  let missingRows = 0;
+  const eligibleValues = missing === undefined ? values : values.filter((row, index) => {
+    const xValue = row?.[x];
+    const yValue = row?.[y];
+    if (xValue === null || xValue === undefined || yValue === null || yValue === undefined) {
+      if (missing === "error") throw new TypeError(`Regression x/y pair is missing at row ${index}.`);
+      missingRows += 1;
+      return false;
+    }
+    if (!Number.isFinite(xValue) || !Number.isFinite(yValue)) {
+      throw new TypeError(`Regression x/y fields must contain finite numbers at row ${index}.`);
+    }
+    return true;
+  });
+  readQuantitativeField(eligibleValues, x);
+  readQuantitativeField(eligibleValues, y);
+  if (groupBy !== undefined) readNominalField(eligibleValues, groupBy);
 
   const groupedRows = new Map();
   if (groupBy === undefined) {
-    groupedRows.set(undefined, values);
+    groupedRows.set(undefined, eligibleValues);
   } else {
-    for (const row of values) {
+    for (const row of eligibleValues) {
       const group = row[groupBy];
       const rows = groupedRows.get(group) ?? [];
       rows.push(row);
@@ -68,13 +86,29 @@ export function deriveRegression(values, {
 
   for (const group of groups) {
     const groupRows = groupedRows.get(group);
-    const xCount = new Set(groupRows.map(row => row[x])).size;
-    validateGeneratedItemLimit(rows.length + xCount, "Regression generated row count");
+    const observedX = [...new Set(groupRows.map(row => row[x]))]
+      .sort((left, right) => left - right);
+    const xValues = predict?.values ?? (predict?.domain === undefined
+      ? observedX
+      : Array.from({ length: predict.steps }, (_, index) => {
+          if (index === 0) return predict.domain[0];
+          if (index === predict.steps - 1) return predict.domain[1];
+          const ratio = index / (predict.steps - 1);
+          return requireFiniteResult(
+            predict.domain[0] * (1 - ratio) + predict.domain[1] * ratio,
+            "Regression prediction grid"
+          );
+        }));
+    validateGeneratedItemLimit(rows.length + xValues.length, "Regression generated row count");
     if (parameters.method === "polynomial") {
       const size = parameters.degree + 1;
       work += groupRows.length * size ** 2 + size ** 3;
     } else if (parameters.method === "loess") {
-      work += groupRows.length * xCount *
+      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");
@@ -84,8 +118,6 @@ export function deriveRegression(values, {
       group,
       parameters
     });
-    const xValues = [...new Set(groupRows.map(row => row[x]))]
-      .sort((left, right) => left - right);
     models.push({ ...(groupBy === undefined ? {} : { group }), ...model, xValues });
 
     for (const xValue of xValues) {
@@ -94,13 +126,13 @@ export function deriveRegression(values, {
         prediction.prediction,
         `Regression group "${group === undefined ? "all" : String(group)}" prediction`
       );
-      const lower = parameters.method === "loess"
+      const lower = parameters.method === "loess" || parameters.interval === false
         ? undefined
         : requireFiniteResult(
             fitted - prediction.margin,
             `Regression group "${group === undefined ? "all" : String(group)}" lower interval`
           );
-      const upper = parameters.method === "loess"
+      const upper = parameters.method === "loess" || parameters.interval === false
         ? undefined
         : requireFiniteResult(
             fitted + prediction.margin,
@@ -110,7 +142,7 @@ export function deriveRegression(values, {
         ...(groupBy === undefined ? {} : { [groupBy]: group }),
         [x]: xValue,
         [y]: fitted,
-        ...(parameters.method === "loess" ? {} : {
+        ...(parameters.method === "loess" || parameters.interval === false ? {} : {
           [REGRESSION_LOWER_FIELD]: lower,
           [REGRESSION_UPPER_FIELD]: upper
         })
@@ -123,7 +155,7 @@ export function deriveRegression(values, {
       x,
       y,
       ...(groupBy === undefined ? {} : { group: groupBy }),
-      ...(parameters.method === "loess" ? {} : {
+      ...(parameters.method === "loess" || parameters.interval === false ? {} : {
         lower: REGRESSION_LOWER_FIELD,
         upper: REGRESSION_UPPER_FIELD
       })
@@ -131,7 +163,22 @@ export function deriveRegression(values, {
     parameters,
     groups,
     models,
-    values: rows
+    values: rows,
+    ...(missing === undefined ? {} : {
+      report: {
+        version: 1,
+        owner: { kind: "data", id: "pending" },
+        inputs: [],
+        units: [{
+          role: "fit",
+          group: {},
+          inputRows: values.length,
+          usedRows: eligibleValues.length,
+          excludedRows: missingRows,
+          excludedByReason: missingRows === 0 ? {} : { "missing-value": missingRows }
+        }]
+      }
+    })
   });
 }
 

package/src/grammar/regression/index.js

@@ -9,6 +9,7 @@ export {
 } from "./derive.js";
 export {
   normalizeRegressionParameters,
+  normalizeRegressionPredict,
   normalizeRegressionTransform,
   validateRegressionTransform
 } from "./parameters.js";

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)))
+    })
   };
 }
 
@@ -371,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) {
@@ -385,42 +439,42 @@ 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 };
+  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;
+  return loessPrediction(model.rows, {
+    ...model, xValue, scaled: true
+  }, "LOESS regression prediction").prediction;
 }
 
 export function fitRegressionGroup(rows, { x, y, group, parameters }) {
@@ -430,7 +484,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,10 +495,12 @@ 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 });
+  return fitLoessGroup(rows, { x, y, group, span: parameters.span,
+    robustIterations: parameters.robustIterations });
 }
 
 export function predictRegressionAt(model, xValue, parameters) {
@@ -454,8 +511,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 + (