ggaction 0.0.17 → 0.0.19

package/src/grammar/boxPlot.js

@@ -1,5 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { interpolateNumber, stableDecimal } from "./numeric.js";
+import { quantileSorted, stableDecimal } from "./numeric.js";
 
 export const BOX_FIELDS = Object.freeze({
   q1: "__boxPlot_q1", median: "__boxPlot_median", q3: "__boxPlot_q3",
@@ -9,7 +9,7 @@ export const BOX_FIELDS = Object.freeze({
 });
 
 const TRANSFORM_KEYS = [
-  "type", "category", "field", "method", "whisker", "factor", "as"
+  "type", "category", "field", "method", "whisker", "factor", "as", "summary"
 ];
 const OUTPUT_KEYS = Object.keys(BOX_FIELDS);
 
@@ -18,6 +18,36 @@ function field(value, label) {
   return value;
 }
 
+const SUMMARY_KEYS = Object.freeze(["min", "q1", "median", "q3", "max"]);
+
+export function normalizeBoxSummary(value) {
+  if (value === undefined) return undefined;
+  if (!isPlainObject(value) || Object.keys(value).length !== SUMMARY_KEYS.length ||
+      !SUMMARY_KEYS.every(key => Object.hasOwn(value, key))) {
+    throw new TypeError("Box summary requires min, q1, median, q3 and max field names.");
+  }
+  return cloneAndFreeze(Object.fromEntries(SUMMARY_KEYS.map(key => [key, field(value[key], `Box summary.${key}`)])));
+}
+
+function derivePrecomputedBoxData(rows, transform) {
+  const { category, summary, as } = transform;
+  const summaries = [];
+  for (const row of rows) {
+    const key = row[category];
+    if (key === undefined || key === null || key === "") continue;
+    const values = SUMMARY_KEYS.map(role => row[summary[role]]);
+    if (!values.every(Number.isFinite)) throw new TypeError("Precomputed box summaries require finite values for all five fields.");
+    if (values.some((value, index) => index > 0 && value < values[index - 1])) {
+      throw new RangeError("Box summary must satisfy min <= q1 <= median <= q3 <= max.");
+    }
+    const [min, q1, median, q3, max] = values;
+    summaries.push({ [category]: key, [as.q1]: q1, [as.median]: median, [as.q3]: q3,
+      [as.lowerWhisker]: min, [as.upperWhisker]: max });
+  }
+  if (summaries.length === 0) throw new Error("Box transform requires at least one valid row.");
+  return cloneAndFreeze({ summaries, outliers: [] });
+}
+
 function validateOutputs(as, occupied) {
   if (!isPlainObject(as)) throw new TypeError("Box as must be a plain object.");
   const keys = Object.keys(as);
@@ -40,6 +70,18 @@ export function validateBoxTransform(value) {
   }
   field(value.category, "Box category field");
   field(value.field, "Box measure field");
+  if (value.method === "precomputed") {
+    const summary = normalizeBoxSummary(value.summary);
+    if (summary === undefined || value.type !== "boxSummary" || value.field !== summary.median) {
+      throw new Error("Precomputed box summaries require a summary mapping and its median measure field.");
+    }
+    if (value.whisker !== undefined || value.factor !== undefined) {
+      throw new Error("Precomputed box summaries do not compute whiskers or factors.");
+    }
+    validateOutputs(value.as, new Set([value.category, ...Object.values(summary)]));
+    return value;
+  }
+  if (value.summary !== undefined) throw new Error("Box summary fields require the precomputed method.");
   if (value.method !== "linear") throw new Error(`Unsupported box quantile method "${value.method}".`);
   const whisker = value.whisker ?? "tukey";
   if (!["tukey", "minmax"].includes(whisker)) {
@@ -56,6 +98,16 @@ export function validateBoxTransform(value) {
 }
 
 export function normalizeBoxTransform(options = {}) {
+  if (options.summary !== undefined) {
+    const summary = normalizeBoxSummary(options.summary);
+    const normalized = { type: options.type ?? "boxSummary", category: options.category,
+      field: options.field ?? summary.median, method: "precomputed", summary, as: options.as ?? BOX_FIELDS };
+    if (options.factor !== undefined || (options.whisker !== undefined && options.whisker !== "minmax")) {
+      throw new Error("Precomputed box summaries require minmax whiskers without a factor.");
+    }
+    validateBoxTransform(normalized);
+    return cloneAndFreeze(normalized);
+  }
   const {
     type = "boxSummary",
     category,
@@ -79,16 +131,11 @@ export function normalizeBoxTransform(options = {}) {
   return cloneAndFreeze(normalized);
 }
 
-function quantile(sorted, p) {
-  const position = (sorted.length - 1) * p;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  return interpolateNumber(sorted[lower], sorted[upper], position - lower);
-}
 
 export function deriveBoxData(rows, transform) {
   if (!Array.isArray(rows)) throw new TypeError("Box rows must be an array.");
   validateBoxTransform(transform);
+  if (transform.method === "precomputed") return derivePrecomputedBoxData(rows, transform);
   const { category, field: measure, factor, as } = transform;
   const whisker = transform.whisker ?? "tukey";
   const groups = [];
@@ -111,7 +158,7 @@ export function deriveBoxData(rows, transform) {
   for (const group of groups) {
     const sorted = group.rows.map(row => row[measure]).sort((a, b) => a - b);
     const [q1, median, q3] = [0.25, 0.5, 0.75].map(probability =>
-      stableDecimal(quantile(sorted, probability))
+      stableDecimal(quantileSorted(sorted, probability))
     );
     const spread = q3 - q1;
     const lowerFence = whisker === "minmax"

package/src/grammar/categoryOrder.js

@@ -1,3 +1,4 @@
+import { requireStringValue as nonEmptyField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { isNominalValue, readNominalField } from "./scales/fields.js";
 import { aggregateScalarValues } from "./aggregate.js";
@@ -7,12 +8,6 @@ export const CATEGORY_ORDER_CHANNELS = Object.freeze(["x", "y", "theta"]);
 const DIRECTIONS = ["ascending", "descending"];
 const AGGREGATES = ["sum", "mean", "min", "max"];
 
-function nonEmptyField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 const sameValue = Object.is;
 

package/src/grammar/colorSizeLegend.js

@@ -0,0 +1,39 @@
+import {sameOrderedValues,validateOptionObject,validateUnitInterval,validateNonNegativeFinite,validateNonEmptyString} from '../core/validation.js';
+import {isContinuousColorScaleType} from './scales/types.js';
+import {isContinuousSizeScaleType} from './scales/size.js';
+
+export function isColorSizeChannels(channels) {
+ return Array.isArray(channels)&&channels.length===2&&channels.includes('color')&&channels.includes('size');
+}
+
+export function resolveColorSizeMapping({layer,scales,pointConfig,coordinate}) {
+ const color=layer?.encoding?.color,size=layer?.encoding?.size;
+ const colorScale=scales[color?.scale],sizeScale=scales[size?.scale];
+ if(layer?.mark?.type!=='point'||coordinate?.type!=='cartesian'||
+   pointConfig?.shape!=='circle'||layer.encoding.shape!==undefined||
+   color?.fieldType!=='quantitative'||size?.fieldType!=='quantitative'||
+   typeof color.field!=='string'||color.field!==size.field||
+   color.aggregate!==size.aggregate||color.data!==size.data||
+   !isContinuousColorScaleType(colorScale?.type)||!isContinuousSizeScaleType(sizeScale?.type)) {
+  throw new Error('Color-size combination requires one Cartesian circle point owner with the same quantitative field and grain.');
+ }
+ const ends=scale=>[scale.domain?.[0],scale.domain?.at(-1)];
+ const domain=ends(colorScale),sizeDomain=ends(sizeScale);
+ if(!domain.every(Number.isFinite)||!sizeDomain.every(Number.isFinite)||
+   !sameOrderedValues(domain,sizeDomain)||domain[0]===domain[1]) {
+  throw new Error('Color-size combination requires identical finite numeric domain endpoints.');
+ }
+ return {target:layer.id,field:color.field,fieldType:'quantitative',colorScale:color.scale,sizeScale:size.scale,domain};
+}
+
+export function normalizeColorSizeSymbol(value,previous) {
+ if(value===undefined)return {...(previous??{type:'point',strokeWidth:0,opacity:1})};
+ if(value==='auto')return {type:'point',strokeWidth:0,opacity:1};
+ validateOptionObject(value,['type','stroke','strokeWidth','opacity'],'Color-size symbol');
+ if(value.type!==undefined&&value.type!=='point')throw new Error('Color-size symbols require type point.');
+ const symbol={type:'point',strokeWidth:0,opacity:1,...previous,...value};
+ if(symbol.stroke!==undefined)validateNonEmptyString(symbol.stroke,'Color-size symbol stroke');
+ validateNonNegativeFinite(symbol.strokeWidth,'Color-size symbol strokeWidth');
+ validateUnitInterval(symbol.opacity,'Color-size symbol opacity');
+ return symbol;
+}

package/src/grammar/complete.js

@@ -1,3 +1,5 @@
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 
 const TRANSFORM_KEYS = Object.freeze([
@@ -6,17 +8,7 @@ const TRANSFORM_KEYS = Object.freeze([
 const SEQUENCE_KEYS = Object.freeze(["start", "end", "step"]);
 const MAX_OUTPUT_ROWS = 10_000;
 
-function rejectUnknownKeys(value, supported, label) {
-  const unknown = Object.keys(value).find(key => !supported.includes(key));
-  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
-}
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function scalarType(value, label) {
   if (value === null) return "null";
@@ -258,20 +250,24 @@ export function deriveCompleteRows(rows, transform) {
       if (!allowed.has(identity)) {
         throw new Error(`Complete observed key is outside the requested domain at row ${entry.index}.`);
       }
-      if (lookup.has(identity)) {
-        throw new Error("Complete source contains a duplicate group and key combination.");
-      }
-      lookup.set(identity, entry);
+      if (!lookup.has(identity)) lookup.set(identity, []);
+      lookup.get(identity).push(entry);
+    }
+    const groupSize = group.values.length + domain.length - lookup.size;
+    if (output.length + groupSize > MAX_OUTPUT_ROWS) {
+      throw new RangeError(`Complete output cannot exceed ${MAX_OUTPUT_ROWS} rows.`);
     }
     for (const keyValue of domain) {
       const identity = scalarKey(keyValue, "Complete domain value");
-      const entry = lookup.get(identity);
-      if (entry === undefined) {
+      const entries = lookup.get(identity);
+      if (entries === undefined) {
         output.push(syntheticRow(fields, group, keyValue, transform));
       } else {
-        const row = { ...entry.row };
-        if (transform.members !== undefined) define(row, transform.members, [entry.index]);
-        output.push(row);
+        for (const entry of entries) {
+          const row = { ...entry.row };
+          if (transform.members !== undefined) define(row, transform.members, [entry.index]);
+          output.push(row);
+        }
       }
     }
   }

package/src/grammar/computed.js

@@ -1,29 +1,22 @@
+import {parseTimeValue,validateParseTimeFormat} from "./parseTime.js";
+import { calendarParts, validateTimeZone } from "./timeUnit.js";
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 
 const TRANSFORM_KEYS = Object.freeze(["type", "as", "expression"]);
 const ARITHMETIC_BINARY = new Set(["add", "subtract", "multiply", "divide"]);
 const COMPARISONS = new Set(["eq", "neq", "lt", "lte", "gt", "gte"]);
-const NUMERIC_UNARY = new Set(["negate", "absolute", "log", "sqrt"]);
+const NUMERIC_UNARY = new Set(["negate", "absolute", "log", "sqrt", "floor"]);
 const BOOLEAN_UNARY = new Set(["not", "isNull"]);
 const LOGICAL = new Set(["and", "or"]);
 const VARIADIC = new Set(["coalesce", "concat"]);
+const RESERVED_PATH_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 const MAX_DEPTH = 16;
 const MAX_NODES = 128;
 const MAX_WORK = 10_000_000;
 
-function rejectUnknownKeys(value, supported, label) {
-  const unknown = Object.keys(value).find(key => !supported.includes(key));
-  if (unknown !== undefined) {
-    throw new Error(`Unknown ${label} property "${unknown}".`);
-  }
-}
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function validateConstant(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return;
@@ -50,7 +43,7 @@ function validateOperands(expression, minimum) {
   }
 }
 
-function inspectExpression(expression, depth, state) {
+function inspectExpression(expression, depth, state, optionalPathRoot = false) {
   if (!isPlainObject(expression)) {
     throw new TypeError("Computed expression nodes must be plain objects.");
   }
@@ -72,7 +65,9 @@ function inspectExpression(expression, depth, state) {
     }
     if (kinds[0] === "field") {
       rejectUnknownKeys(expression, ["field"], "computed field expression");
-      state.fields.add(requireField(expression.field, "Computed expression field"));
+      const field = requireField(expression.field, "Computed expression field");
+      state.fields.add(field);
+      if (!optionalPathRoot) state.requiredFields.add(field);
       return;
     }
     if (kinds[0] === "constant") {
@@ -88,7 +83,47 @@ function inspectExpression(expression, depth, state) {
       inspectExpression(expression.right, depth + 1, state);
       return;
     }
-    if (NUMERIC_UNARY.has(expression.op) || BOOLEAN_UNARY.has(expression.op)) {
+    if (expression.op === "getPath") {
+      rejectUnknownKeys(expression, ["op", "operand", "path"], "computed path expression");
+      if (!isPlainObject(expression.operand) ||
+          Object.keys(expression.operand).length !== 1 ||
+          !Object.hasOwn(expression.operand, "field")) {
+        throw new TypeError("Computed getPath operand must be a literal field reference.");
+      }
+      if (!Array.isArray(expression.path) || expression.path.length < 1 ||
+          expression.path.length > 8 || !Array.from(expression.path).every(key =>
+            typeof key === "string" && key.length > 0 && !RESERVED_PATH_KEYS.has(key))) {
+        throw new TypeError("Computed getPath path must contain 1 to 8 nonempty, nonreserved string keys.");
+      }
+      inspectExpression(expression.operand, depth + 1, state, true);
+      return;
+    }
+    if (expression.op === "replaceLiteral") {
+      rejectUnknownKeys(expression, ["op", "operand", "search", "replacement"], "computed literal replacement");
+      requireNode(expression, "operand", expression.op);
+      if (typeof expression.search !== "string" || expression.search.length === 0 ||
+          typeof expression.replacement !== "string") {
+        throw new TypeError("Computed replaceLiteral requires a nonempty string search and string replacement.");
+      }
+      inspectExpression(expression.operand, depth + 1, state);
+      return;
+    }
+    if (expression.op === "datePart") {
+      rejectUnknownKeys(expression, ["op", "part", "operand", "timeZone"], "computed calendar expression");
+      requireNode(expression, "operand", expression.op);
+      if (expression.part !== "year") throw new Error("Computed datePart supports part year only.");
+      if (Object.hasOwn(expression, "timeZone")) validateTimeZone(expression.timeZone);
+      inspectExpression(expression.operand, depth + 1, state);
+      return;
+    }
+    if (expression.op === "parseTime") {
+      rejectUnknownKeys(expression, ["op", "operand", "format"], "computed time expression");
+      requireNode(expression, "operand", expression.op);
+      validateParseTimeFormat(expression.format);
+      inspectExpression(expression.operand, depth + 1, state);
+      return;
+    }
+    if (NUMERIC_UNARY.has(expression.op) || BOOLEAN_UNARY.has(expression.op) || expression.op === "toNumber") {
       rejectUnknownKeys(expression, ["op", "operand"], "computed unary expression");
       requireNode(expression, "operand", expression.op);
       inspectExpression(expression.operand, depth + 1, state);
@@ -131,7 +166,7 @@ function inspectComputedTransform(transform) {
     throw new Error(`Unsupported computed transform "${transform.type}".`);
   }
   requireField(transform.as, "Computed output field");
-  const state = { nodes: 0, fields: new Set(), ancestors: new WeakSet() };
+  const state = { nodes: 0, fields: new Set(), requiredFields: new Set(), ancestors: new WeakSet() };
   inspectExpression(transform.expression, 1, state);
   return state;
 }
@@ -233,6 +268,27 @@ function compare(left, right, operation, rowIndex) {
         : order >= 0;
 }
 
+function ownDataProperty(record, key, rowIndex) {
+  const descriptor = Object.getOwnPropertyDescriptor(record, key);
+  if (descriptor === undefined) return undefined;
+  if (!Object.hasOwn(descriptor, "value")) {
+    throw new TypeError(`Computed getPath cannot read an accessor at row ${rowIndex}.`);
+  }
+  return descriptor.value;
+}
+
+function nestedScalar(expression, row, rowIndex) {
+  let value = ownDataProperty(row, expression.operand.field, rowIndex);
+  for (const key of expression.path) {
+    if (value === undefined || value === null) return null;
+    if (!isPlainObject(value)) {
+      throw new TypeError(`Computed getPath requires plain records at row ${rowIndex}.`);
+    }
+    value = ownDataProperty(value, key, rowIndex);
+  }
+  return scalar(value, "Computed getPath result", rowIndex);
+}
+
 function evaluate(expression, row, rowIndex) {
   if (Object.hasOwn(expression, "field")) {
     return scalar(
@@ -243,6 +299,16 @@ function evaluate(expression, row, rowIndex) {
   }
   if (Object.hasOwn(expression, "constant")) return expression.constant;
   const operation = expression.op;
+  if (operation === "getPath") return nestedScalar(expression, row, rowIndex);
+  if (operation === "replaceLiteral") {
+    const value = evaluate(expression.operand, row, rowIndex);
+    if (typeof value !== "string") {
+      throw new TypeError(`Computed replaceLiteral requires a string at row ${rowIndex}.`);
+    }
+    const index = value.indexOf(expression.search);
+    return index < 0 ? value
+      : value.slice(0, index) + expression.replacement + value.slice(index + expression.search.length);
+  }
   if (operation === "if") {
     return boolean(evaluate(expression.condition, row, rowIndex), operation, rowIndex)
       ? evaluate(expression.then, row, rowIndex)
@@ -282,6 +348,29 @@ function evaluate(expression, row, rowIndex) {
       ? value === null
       : !boolean(value, operation, rowIndex);
   }
+  if (operation === "datePart") {
+    const value = evaluate(expression.operand, row, rowIndex);
+    if (value === null) return null;
+    number(value, operation, rowIndex);
+    if (Math.abs(value) > 8_640_000_000_000_000) {
+      throw new RangeError(`Computed datePart timestamp is outside the supported Date range at row ${rowIndex}.`);
+    }
+    const timestamp = new Date(value).getTime();
+    return (expression.timeZone ?? "UTC") === "UTC"
+      ? new Date(timestamp).getUTCFullYear()
+      : calendarParts(timestamp, expression.timeZone).year;
+  }
+  if (operation === "parseTime") {
+    return parseTimeValue(evaluate(expression.operand, row, rowIndex), expression.format);
+  }
+  if (operation === "toNumber") {
+    const value = evaluate(expression.operand, row, rowIndex);
+    if (typeof value === "number") return number(value, operation, rowIndex);
+    if (typeof value !== "string" || !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value.trim())) {
+      throw new TypeError(`Computed toNumber requires a finite number or decimal string at row ${rowIndex}.`);
+    }
+    return number(Number(value.trim()), operation, rowIndex);
+  }
   if (NUMERIC_UNARY.has(operation)) {
     const value = number(evaluate(expression.operand, row, rowIndex), operation, rowIndex);
     if (operation === "log" && value <= 0) {
@@ -292,6 +381,7 @@ function evaluate(expression, row, rowIndex) {
     }
     const result = operation === "negate" ? -value
       : operation === "absolute" ? Math.abs(value)
+        : operation === "floor" ? Math.floor(value)
         : operation === "log" ? Math.log(value)
           : Math.sqrt(value);
     if (!Number.isFinite(result)) {
@@ -318,7 +408,7 @@ function evaluate(expression, row, rowIndex) {
 }
 
 export function deriveComputedRows(rows, transform) {
-  const { nodes, fields } = inspectComputedTransform(transform);
+  const { nodes, fields, requiredFields } = inspectComputedTransform(transform);
   if (rows.length * nodes > MAX_WORK) {
     throw new RangeError(`Computed work cannot exceed ${MAX_WORK} row-nodes.`);
   }
@@ -326,15 +416,14 @@ export function deriveComputedRows(rows, transform) {
     throw new Error(`Computed output field "${transform.as}" already exists.`);
   }
   if (rows.length > 0) {
-    rows.forEach((row, index) => {
-      for (const field of fields) {
-        if (!Object.hasOwn(row, field)) {
-          throw new Error(
-            `Computed source does not contain field "${field}" at row ${index}.`
-          );
+    for (const field of fields) {
+      const knownOptional = !requiredFields.has(field) && rows.some(row => Object.hasOwn(row, field));
+      rows.forEach((row, index) => {
+        if (!knownOptional && !Object.hasOwn(row, field)) {
+          throw new Error(`Computed source does not contain field "${field}" at row ${index}.`);
         }
-      }
-    });
+      });
+    }
   }
   let outputType;
   return rows.map((row, index) => {

package/src/grammar/curveCommands.js

@@ -1,6 +1,5 @@
 import { freezeOwned, isPlainObject } from "../core/immutable.js";
-import { validateGeneratedItemLimit } from "../core/validation.js";
-import { buildLinearPathCommands } from "./pathCommands.js";
+import { buildLinearPathCommands, validatePathCommandCount } from "./pathCommands.js";
 
 export const CURVE_INTERPOLATIONS = Object.freeze([
   "linear",
@@ -42,6 +41,15 @@ function validatePoints(points) {
   return points;
 }
 
+export function validateCardinalTension(tension, curve) {
+  if (tension === undefined) return 0;
+  if (curve !== "cardinal") throw new Error("Line tension requires cardinal interpolation.");
+  if (!Number.isFinite(tension) || tension < 0 || tension > 1) {
+    throw new RangeError("Cardinal tension must be between 0 and 1.");
+  }
+  return tension;
+}
+
 export function validateCurveInterpolation(curve) {
   if (!CURVE_INTERPOLATIONS.includes(curve)) {
     throw new Error(`Unsupported curve interpolation "${curve}".`);
@@ -134,7 +142,7 @@ function buildBasisCommands(points) {
   return ownCommands(commands);
 }
 
-function buildCardinalCommands(points) {
+function buildCardinalCommands(points, tension = 0) {
   const commands = [{ op: "M", x: points[0].x, y: points[0].y }];
   for (let index = 0; index < points.length - 1; index += 1) {
     const before = points[index - 1] ?? points[index];
@@ -143,10 +151,10 @@ function buildCardinalCommands(points) {
     const after = points[index + 2] ?? next;
     commands.push({
       op: "C",
-      x1: current.x + (next.x - before.x) / 6,
-      y1: current.y + (next.y - before.y) / 6,
-      x2: next.x - (after.x - current.x) / 6,
-      y2: next.y - (after.y - current.y) / 6,
+      x1: current.x + (next.x - before.x) / 6 * (1 - tension),
+      y1: current.y + (next.y - before.y) / 6 * (1 - tension),
+      x2: next.x - (after.x - current.x) / 6 * (1 - tension),
+      y2: next.y - (after.y - current.y) / 6 * (1 - tension),
       x: next.x,
       y: next.y
     });
@@ -265,7 +273,7 @@ function buildNaturalCommands(points) {
   return ownCommands(commands);
 }
 
-function buildValidatedCurvePathCommands(points, curve) {
+function buildValidatedCurvePathCommands(points, curve, tension) {
   if (curve === "linear" ||
       (SMOOTH_CURVES.has(curve) &&
         curve !== "monotone" &&
@@ -277,7 +285,7 @@ function buildValidatedCurvePathCommands(points, curve) {
   }
   if (curve === "basis") return buildBasisCommands(points);
   if (curve === "cardinal") {
-    return buildCardinalCommands(points);
+    return buildCardinalCommands(points, tension);
   }
   if (curve === "monotone") {
     return buildMonotoneCommands(points);
@@ -301,17 +309,19 @@ function curveCommandCount(pointCount, curve) {
     : pointCount;
 }
 
-export function buildCurvePathCommands(points, curve = "linear") {
+export function buildCurvePathCommands(points, curve = "linear", tension) {
+  validateCardinalTension(tension, curve);
   const validatedPoints = validatePoints(points);
   const validatedCurve = validateCurveInterpolation(curve);
-  validateGeneratedItemLimit(
+  validatePathCommandCount(
     curveCommandCount(validatedPoints.length, validatedCurve),
     "Curve path command count"
   );
   const direct = buildValidatedCurvePathCommands(
     validatedPoints,
-    validatedCurve
+    validatedCurve, tension
   );
+  validatePathCommandCount(direct.length, "Curve path command count");
   if (finiteCommands(direct)) return direct;
 
   let xScale = 0;
@@ -327,7 +337,7 @@ export function buildCurvePathCommands(points, curve = "linear") {
       x: point.x / xScale,
       y: point.y / yScale
     })),
-    validatedCurve
+    validatedCurve, tension
   );
   const restored = normalized.map(command => {
     const copy = {};
@@ -341,6 +351,7 @@ export function buildCurvePathCommands(points, curve = "linear") {
   if (!finiteCommands(restored)) {
     throw new RangeError("Curve interpolation exceeds the finite numeric range.");
   }
+  validatePathCommandCount(restored.length, "Curve path command count");
   return ownCommands(restored);
 }
 
@@ -403,7 +414,7 @@ export function buildAreaCurvePathCommands(
   const validatedCurve = validateCurveInterpolation(curve);
   const validatedLower = validatePoints(lowerPoints);
   const validatedUpper = validatePoints(upperPoints);
-  validateGeneratedItemLimit(
+  validatePathCommandCount(
     curveCommandCount(validatedLower.length, validatedCurve) +
       curveCommandCount(validatedUpper.length, validatedCurve) + 1,
     "Area path command count"
@@ -416,10 +427,12 @@ export function buildAreaCurvePathCommands(
   const upper = reverseOpenPathCommands(
     buildOrientedCurvePathCommands(validatedUpper, validatedCurve, independentAxis)
   );
-  return ownCommands([
+  const commands = [
     ...lower,
     { op: "L", x: upper[0].x, y: upper[0].y },
     ...upper.slice(1),
     { op: "Z" }
-  ]);
+  ];
+  validatePathCommandCount(commands.length, "Area path command count");
+  return ownCommands(commands);
 }

package/src/grammar/datasetSchema.js

@@ -1,5 +1,7 @@
+import { requireStringValue as requireName } from "../core/validation.js";
 import { annotateError } from "../core/diagnostics.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { requireRegressionStatisticsSource, REGRESSION_STATISTIC_FIELDS } from "./regression/statistics.js";
 
 const STORAGE_TYPES = new Set([
   "number", "string", "boolean", "array", "object", "unknown", "mixed"
@@ -19,12 +21,6 @@ function rejectUnknownKeys(value, keys, label) {
   if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
 }
 
-function requireName(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function valueStorageType(value) {
   if (typeof value === "number") return "number";
@@ -61,7 +57,8 @@ function normalizeField(value, index, { declared = false } = {}) {
     declared ? SOURCE_FIELD_KEYS : FIELD_KEYS,
     `dataset schema field ${index}`
   );
-  const name = requireName(value.name, `Dataset schema field ${index} name`);
+  // Stored row keys are lossless; action field references still require non-empty names.
+  const name = value.name === "" ? "" : requireName(value.name, `Dataset schema field ${index} name`);
   const allowed = declared ? DECLARED_STORAGE_TYPES : STORAGE_TYPES;
   if (!allowed.has(value.storageType)) {
     throw new Error(`Unsupported dataset schema storageType "${value.storageType}".`);
@@ -271,7 +268,7 @@ function generatedField(name, storageType, transform, role, inputs = []) {
   };
 }
 
-export function deriveTransformSchema(inputSchema, transform, values, { sourceId, ownerId } = {}) {
+export function deriveTransformSchema(inputSchema, transform, values, { sourceId, ownerId, sourceTransform } = {}) {
   const input = validateDatasetSchema(inputSchema);
   const definition = { ...transform, __sourceId: sourceId, __ownerId: ownerId };
   const retain = ["filter", "markFilter", "sort", "computed", "timeUnit", "window", "normalize", "stack", "impute", "complete"];
@@ -304,6 +301,12 @@ export function deriveTransformSchema(inputSchema, transform, values, { sourceId
       generatedField(transform.as.count, "number", definition, "count", [transform.x, transform.y])
     ];
     if (transform.as.members !== undefined) push(generatedField(transform.as.members, "array", definition, "members"));
+  } else if (transform.type === "regressionStatistics") {
+    const fit = requireRegressionStatisticsSource({ transform: sourceTransform === undefined ? [] : [sourceTransform] });
+    fields = [
+      ...(fit.groupBy === undefined ? [] : [inheritedField(input, fit.groupBy)]),
+      ...REGRESSION_STATISTIC_FIELDS.map(name => generatedField(name, "number", definition, name))
+    ].filter(Boolean);
   } else if (transform.type === "regression") {
     fields = [inheritedField(input, transform.x), inheritedField(input, transform.y)].filter(Boolean);
     if (transform.groupBy !== undefined) fields.unshift(inheritedField(input, transform.groupBy));
@@ -371,7 +374,8 @@ export function deriveTransformSchema(inputSchema, transform, values, { sourceId
       if (planned.lineage === undefined && !["complete", "impute"].includes(transform.type)) {
         return planned;
       }
-      return { ...planned, storageType: field.storageType, nullable: field.nullable, optional: field.optional };
+      return { ...planned, storageType: transform.type === "regressionStatistics" && planned.storageType === "number"
+        ? "number" : field.storageType, nullable: field.nullable, optional: field.optional };
     });
     for (const field of inferred.fields) {
       if (!fields.some(planned => planned.name === field.name)) fields.push(field);