ggaction 0.0.16 → 0.0.18

package/src/actions/marks/rule/actions.js

@@ -39,13 +39,15 @@ import {
   requestedStrokeDetails,
   STROKE_STYLE_PROPERTIES
 } from "../../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 
 const APPEARANCE_OPTIONS = Object.freeze([
   "stroke", "strokeWidth", "strokeDash", "opacity",
   ...STROKE_STYLE_PROPERTIES
 ]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", ...APPEARANCE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...APPEARANCE_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...APPEARANCE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...APPEARANCE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 const SPAN_OPTIONS = Object.freeze(["id", "orientation", "size"]);
 const DEFAULT_RULE_CONFIG = Object.freeze({
@@ -66,10 +68,11 @@ function requireRule(program, id) {
   if (layer?.mark?.type !== "rule") {
     throw new Error(`Unknown rule mark "${id}".`);
   }
-  const dataset = findDataset(program, layer.data);
-  if (dataset === undefined) {
+  const sourceDataset = findDataset(program, layer.data);
+  if (sourceDataset === undefined) {
     throw new Error(`Rule mark "${id}" requires an existing dataset.`);
   }
+  const dataset = applyItemMissingPolicy(layer, sourceDataset);
   const graphic = program.graphicSpec.objects[id];
   if (graphic?.type !== "line" || graphic.items === undefined) {
     throw new Error(`Rule mark "${id}" requires line collection graphics.`);
@@ -118,6 +121,12 @@ const createRuleMark = /* @__PURE__ */ action(
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "rule" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      created = created.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Rule missing")
+      });
+    }
     created = applyLayeredMarkInheritance(created, id, inherited);
     created = created
       .createGraphics({
@@ -154,11 +163,18 @@ const editRuleMark = /* @__PURE__ */ action(
       label: "rule mark"
     });
     const appearance = planRuleAppearance(args, layer);
-    if (appearance.length === 0 && Object.keys(strokeDetails).length === 0) {
-      throw new Error("editRuleMark requires an appearance change.");
+    if (appearance.length === 0 && Object.keys(strokeDetails).length === 0 &&
+        !Object.hasOwn(args, "missing")) {
+      throw new Error("editRuleMark requires missing or an appearance change.");
     }
-    const configured = this._withMarkConfig(layer.id, {
-      ...this.markConfigs[layer.id],
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Rule missing")
+        })
+      : this;
+    const configured = semantic._withMarkConfig(layer.id, {
+      ...semantic.markConfigs[layer.id],
       ...strokeDetails
     });
     const materialized = appearance.length === 0
@@ -282,13 +298,16 @@ const rematerializeRuleMark = /* @__PURE__ */ action(
           properties: item?.properties
         });
         if (box === undefined) throw new Error(`Rule mark "${id}" requires box span owner "${boxSpan}".`);
+        const pixels = resolved.markConfigs[boxSpan]?.boxPlot?.median?.width?.pixels;
         if (layer.encoding?.x?.fieldType === "quantitative") {
           startX = endX = mapped.x[index];
-          startY = box.y;
-          endY = box.y + box.height;
+          const height = pixels ?? box.height;
+          startY = box.y + (box.height - height) / 2;
+          endY = startY + height;
         } else {
-          startX = box.x;
-          endX = box.x + box.width;
+          const width = pixels ?? box.width;
+          startX = box.x + (box.width - width) / 2;
+          endX = startX + width;
           startY = endY = mapped.y[index];
         }
       } else if (mode === "fixed-span") {

package/src/actions/marks/text/actions.js

@@ -3,6 +3,7 @@ import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import {
   DEFAULT_TEXT_MARK,
+  TEXT_MARK_STYLE_OPTIONS as STYLE_OPTIONS,
   isSourceOwnedText,
   normalizeTextMarkConfig
 } from "../../../grammar/text.js";
@@ -39,13 +40,10 @@ import {
 } from "../../charts/shared.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
-const STYLE_OPTIONS = Object.freeze([
-  "fill", "opacity", "fontSize", "fontFamily", "fontWeight",
-  "align", "baseline", "rotation", "dx", "dy"
-]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", ...STYLE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...STYLE_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", "missing", ...STYLE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
 
 function sourceMatchesData(program, layer, requestedData) {
@@ -139,6 +137,9 @@ const createTextMark = /* @__PURE__ */ action(
       operation: "createTextMark"
     });
     const inherited = resolveTextInheritance(this, args);
+    if (Object.hasOwn(args, "missing") && inherited?.source !== undefined) {
+      throw new Error("Text missing policy requires a row-backed text mark, not source-owned labels.");
+    }
     const { data } = resolveMarkData(this, {
       ...args,
       ...(args.data === undefined && inherited?.data !== undefined
@@ -150,6 +151,12 @@ const createTextMark = /* @__PURE__ */ action(
     let next = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "text" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      next = next.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Text missing")
+      });
+    }
     if (inherited?.source !== undefined) {
       next = next.editSemantic({
         property: `layer[${id}].source`,
@@ -185,7 +192,7 @@ const LABEL_OPTIONS = Object.freeze([
 ]);
 
 const ANNOTATION_OPTIONS = Object.freeze([
-  "id", "text", "format", "x", "y", "space", "source", "data", "coordinate", "layout",
+  "id", "text", "format", "anchor", "x", "y", "space", "source", "data", "coordinate", "layout",
   ...STYLE_OPTIONS
 ]);
 
@@ -261,6 +268,15 @@ const createAnnotation = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, ANNOTATION_OPTIONS, "createAnnotation");
+    if (Object.hasOwn(args, "anchor")) {
+      if (args.anchor !== "plot-center") {
+        throw new Error('createAnnotation anchor must be "plot-center".');
+      }
+      if (["x", "y", "space", "source", "align", "baseline"].some(key => Object.hasOwn(args, key))) {
+        throw new Error("createAnnotation plot-center owns x, y, space, align, and baseline and does not accept source.");
+      }
+      args = { ...args, space: "plot", x: 0.5, y: 0.5, align: "center", baseline: "middle" };
+    }
     if (!Object.hasOwn(args, "text")) {
       throw new Error("createAnnotation requires text.");
     }
@@ -465,20 +481,35 @@ const editTextMark = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTextMark");
-    if (!STYLE_OPTIONS.some(option => Object.hasOwn(args, option))) {
+    if (!["missing", ...STYLE_OPTIONS].some(option => Object.hasOwn(args, option))) {
       throw new Error("editTextMark requires at least one editable property.");
     }
     const layer = requireTextLayer(this, args.target, "editTextMark");
-    const next = this._withMarkConfig(
+    if (Object.hasOwn(args, "missing") && layer.source !== undefined) {
+      throw new Error("Text missing policy requires a row-backed text mark, not source-owned labels.");
+    }
+    if (args.inheritColor && layer.source === undefined) {
+      throw new Error("Text inheritColor requires a source-owned label.");
+    }
+    if (Object.hasOwn(args, "fill") && layer.encoding?.color !== undefined) {
+      throw new Error("Text fill conflicts with its color encoding.");
+    }
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Text missing")
+        })
+      : this;
+    const next = semantic._withMarkConfig(
       layer.id,
       {
         ...normalizeTextMarkConfig(
           args,
-          this.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
+          semantic.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
         ),
         fillExplicit: Object.hasOwn(args, "fill")
           ? true
-          : this.markConfigs[layer.id]?.fillExplicit ?? false
+          : semantic.markConfigs[layer.id]?.fillExplicit ?? false
       }
     );
     return canMaterializeText(next, layer)

package/src/actions/marks/text/layout.js

@@ -144,6 +144,9 @@ function layoutInputs(program, layer) {
     sourceX: entry.anchor.x,
     sourceY: entry.anchor.y,
     text: entry.graphic.properties.text,
+    lines: entry.graphic.properties.lines,
+    fontFamily: entry.graphic.properties.fontFamily,
+    fontWeight: entry.graphic.properties.fontWeight,
     fontSize: entry.graphic.properties.fontSize,
     textAlign: entry.graphic.properties.textAlign,
     textBaseline: entry.graphic.properties.textBaseline,

package/src/actions/marks/tick/actions.js

@@ -21,6 +21,8 @@ import {
   requestedStrokeDetails,
   STROKE_STYLE_PROPERTIES
 } from "../../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import {
@@ -37,8 +39,8 @@ import {
 const APPEARANCE_OPTIONS = Object.freeze([
   "length", "stroke", "strokeWidth", "opacity", ...STROKE_STYLE_PROPERTIES
 ]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", ...APPEARANCE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...APPEARANCE_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...APPEARANCE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...APPEARANCE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
 export const DEFAULT_TICK_CONFIG = Object.freeze({
@@ -114,6 +116,12 @@ export const createTickMark = /* @__PURE__ */ action(
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "tick" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      created = created.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Tick missing")
+      });
+    }
     created = applyLayeredMarkInheritance(created, id, inherited)
       .createGraphics({
         id,
@@ -141,9 +149,9 @@ export const editTickMark = /* @__PURE__ */ action(
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTickMark");
     requestedStrokeDetails(args, "editTickMark");
-    if (!APPEARANCE_OPTIONS.some(property => Object.hasOwn(args, property))) {
+    if (!["missing", ...APPEARANCE_OPTIONS].some(property => Object.hasOwn(args, property))) {
       throw new Error(
-        "editTickMark requires length, stroke, strokeWidth, or opacity."
+        "editTickMark requires length, stroke, strokeWidth, opacity, or missing."
       );
     }
     const layer = resolveTick(this, args.target, "editTickMark");
@@ -152,11 +160,17 @@ export const editTickMark = /* @__PURE__ */ action(
         "editTickMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
       );
     }
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Tick missing")
+        })
+      : this;
     const config = validateTickConfig(args, {
       ...DEFAULT_TICK_CONFIG,
-      ...this.markConfigs[layer.id]
+      ...semantic.markConfigs[layer.id]
     });
-    const materialized = this
+    const materialized = semantic
       ._withMarkConfig(layer.id, config)
       .rematerializeTickMark({ id: layer.id });
     return rematerializeExistingLegend(materialized);
@@ -190,10 +204,11 @@ export const rematerializeTickMark = /* @__PURE__ */ action(
     if (graphic?.type !== "line" || !Array.isArray(graphic.items)) {
       throw new Error(`Tick mark "${id}" requires line collection graphics.`);
     }
-    const dataset = findDataset(this, layer.data);
-    if (dataset === undefined) {
+    const sourceDataset = findDataset(this, layer.data);
+    if (sourceDataset === undefined) {
       throw new Error(`Tick mark "${id}" requires an existing dataset.`);
     }
+    const dataset = applyItemMissingPolicy(layer, sourceDataset);
     if (
       layer.encoding?.x?.scale === undefined ||
       layer.encoding?.y?.scale === undefined

package/src/actions/primitives/semanticAction.js

@@ -7,6 +7,7 @@ import {
   removeOwnedPath
 } from "../../core/immutable.js";
 import { parseSemanticPath } from "../../grammar/schemas/semanticPath.js";
+import { deriveTransformSchema, inferDatasetSchema, validateRowsAgainstSchema } from "../../grammar/datasetSchema.js";
 
 
 const CONTEXT_KEYS = Object.freeze({
@@ -44,7 +45,39 @@ function updateEntity(spec, parsed, value) {
   }
 
   const current = index === -1 ? { id: parsed.id } : collection[index];
-  const updated = setNestedProperty(current, parsed.path, value);
+  let updated = setNestedProperty(current, parsed.path, value);
+  if (
+    parsed.kind === "dataset" && parsed.path.length === 1 &&
+    parsed.path[0] === "transform" && current.schema === undefined &&
+    current.source !== undefined && value.length === 1
+  ) {
+    const source = collection.find(dataset => dataset.id === current.source);
+    if (source?.schema !== undefined) {
+      updated = setNestedProperty(updated, ["schema"], deriveTransformSchema(
+        source.schema,
+        value[0],
+        undefined,
+        { sourceId: source.id, ownerId: parsed.id }
+      ));
+    }
+  }
+  if (
+    parsed.kind === "dataset" && parsed.path.length === 1 &&
+    parsed.path[0] === "values" &&
+    (current.schema === undefined || current.schema.origin === "derived")
+  ) {
+    const source = current.source === undefined
+      ? undefined
+      : collection.find(dataset => dataset.id === current.source);
+    const schema = source?.schema !== undefined && current.transform?.length === 1
+      ? deriveTransformSchema(source.schema, current.transform[0], value, {
+          sourceId: source.id,
+          ownerId: parsed.id
+        })
+      : inferDatasetSchema(value);
+    validateRowsAgainstSchema(value, schema, `Dataset "${parsed.id}"`);
+    updated = setNestedProperty(updated, ["schema"], schema);
+  }
   const nextCollection = [...collection];
 
   if (index === -1) {
@@ -155,13 +188,14 @@ export function withRematerializedDerivedDataset(program, {
   id,
   source,
   transform,
-  values
+  values,
+  schema
 }) {
   const semanticSpec = {
     ...program.semanticSpec,
     datasets: program.semanticSpec.datasets.map(dataset =>
       dataset.id === id
-        ? { ...dataset, source, transform: [transform], values }
+        ? { ...dataset, source, transform: [transform], values, ...(schema === undefined ? {} : { schema }) }
         : dataset
     )
   };

package/src/actions/primitives/semanticValidation/dataset.js

@@ -1,6 +1,10 @@
 import { validateUserId } from "../../../core/identifiers.js";
 import { validateDataRows } from "../../../core/validation.js";
-import { hasDataset } from "../../../selectors/datasets.js";
+import { findDataset, hasDataset } from "../../../selectors/datasets.js";
+import {
+  validateDatasetSchema,
+  validateRowsAgainstSchema
+} from "../../../grammar/datasetSchema.js";
 
 export function validateDatasetSemanticValue(
   program,
@@ -11,6 +15,14 @@ export function validateDatasetSemanticValue(
   const property = parsed.path[0];
   if (property === "values") {
     validateDataRows(value, `Dataset "${parsed.id}"`);
+    const schema = findDataset(program, parsed.id)?.schema;
+    if (schema !== undefined && schema.origin !== "derived") {
+      validateRowsAgainstSchema(value, schema, `Dataset "${parsed.id}"`);
+    }
+    return;
+  }
+  if (property === "schema") {
+    validateDatasetSchema(value);
     return;
   }
   if (property === "source") {

package/src/actions/primitives/semanticValidation/layer.js

@@ -19,6 +19,8 @@ import { findLayer } from "../../../selectors/layers.js";
 import { validateNonEmptySemanticString } from "./shared.js";
 import { normalizeStatisticalWeight } from
   "../../../grammar/weightedStatistics.js";
+import { ITEM_MISSING_MARK_TYPES, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 
 function validateLayerSource(program, parsed, value, sourceMarkTypes) {
   validateUserId(value, "Layer source id");
@@ -52,8 +54,30 @@ export function validateLayerSemanticValue(
   if (property === "mark.type" && !MARK_TYPES.includes(value)) {
     throw new Error(`Unknown mark type "${value}".`);
   }
-  if (property === "mark.missing" && !["error", "break"].includes(value)) {
-    throw new Error(`Unsupported area missing policy "${value}".`);
+  if (property === "mark.missing") {
+    const markType = findLayer(program, parsed.id)?.mark?.type;
+    if (markType === "area") {
+      if (!["error", "break"].includes(value)) {
+        throw new Error(`Unsupported area missing policy "${value}".`);
+      }
+    } else if (ITEM_MISSING_MARK_TYPES.includes(markType)) {
+      validateItemMissing(value, `${markType} missing`);
+    } else {
+      throw new Error(`Mark type "${markType}" does not support a missing policy.`);
+    }
+  }
+  if (property === "mark.orientation" && (findLayer(program, parsed.id)?.mark?.type !== "bar" ||
+      !["vertical", "horizontal"].includes(value))) {
+    throw new Error("Bar orientation must be vertical or horizontal.");
+  }
+  if (property === "derivedBindings.regression") {
+    if (!value || typeof value !== "object" || Array.isArray(value) ||
+        Object.keys(value).length !== 2 || value.mode !== "follow" ||
+        !Array.isArray(value.roles) || value.roles.length !== 3 ||
+        value.roles.join(",") !== "data,x,y") {
+      throw new Error("Regression derived binding must follow data, x, and y roles.");
+    }
+    return;
   }
   if (property === "layout.mode" && !COLOR_LAYOUTS.includes(value)) {
     throw new Error(`Unsupported series layout "${value}".`);

package/src/actions/primitives/semanticValidation/scale.js

@@ -55,6 +55,12 @@ export function validateScaleSemanticValue(program, parsed, value) {
     return;
   }
   if (property === "domain") return validateSemanticScaleDomain(value);
+  if (property === "emptyDomain") {
+    if (!["preserve", "require-explicit"].includes(value)) {
+      throw new Error('Scale emptyDomain must be "preserve" or "require-explicit".');
+    }
+    return;
+  }
   if (property === "range") return validateSemanticScaleRange(value);
   if (["nice", "zero", "clamp", "reverse"].includes(property)) {
     if (typeof value !== "boolean") {

package/src/actions/regression/create.js

@@ -1,6 +1,6 @@
 import { closedAction } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { normalizeRegressionParameters, normalizeRegressionPredict } from "../../grammar/regression/index.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   findRegressionPoint,
@@ -10,8 +10,9 @@ import {
 } from "./resolve.js";
 
 const REGRESSION_OPTIONS = Object.freeze([
-  "target", "x", "y", "groupBy", "method", "degree", "span",
+  "target", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
+  , "predict", "sourceBinding", "missing"
 ]);
 
 export const createRegression = /* @__PURE__ */ closedAction(
@@ -20,6 +21,10 @@ export const createRegression = /* @__PURE__ */ closedAction(
     description: "Fit and layer regression lines with optional interval bands."
   }, REGRESSION_OPTIONS,
   function (args = {}) {
+    const sourceBinding = args.sourceBinding ?? "fixed";
+    if (!["fixed", "follow"].includes(sourceBinding)) {
+      throw new Error('Regression sourceBinding must be "fixed" or "follow".');
+    }
     const point = findRegressionPoint(this, args.target);
     const x = args.x === undefined
       ? point.encoding.x.field
@@ -37,11 +42,21 @@ export const createRegression = /* @__PURE__ */ closedAction(
       );
     }
     const parameters = normalizeRegressionParameters(args);
+    const predict = normalizeRegressionPredict(args.predict);
+    const regressionDefinition = {
+      ...parameters,
+      ...(predict === undefined ? {} : { predict }),
+      ...(args.missing === undefined ? {} : { missing: args.missing })
+    };
     let band = false;
     if (parameters.method === "loess") {
       if (args.band !== undefined && args.band !== false) {
         throw new Error("LOESS regression does not support a band object.");
       }
+    } else if (parameters.interval === false) {
+      if (args.band !== undefined && args.band !== false) {
+        throw new Error("Regression interval false cannot include a band object.");
+      }
     } else if (args.band !== false) {
       band = requireRegressionObject(args.band ?? {}, "Regression band");
     }
@@ -78,7 +93,7 @@ export const createRegression = /* @__PURE__ */ closedAction(
         x,
         y,
         ...(groupBy === undefined ? {} : { groupBy }),
-        ...parameters
+        ...regressionDefinition
       });
     if (band !== false) {
       next = next.createRegressionBand({
@@ -105,7 +120,7 @@ export const createRegression = /* @__PURE__ */ closedAction(
       yScale,
       ...line
     });
-    return next._withMarkConfig(point.id, {
+    next = next._withMarkConfig(point.id, {
       ...next.markConfigs[point.id],
       regression: {
         source: point.data,
@@ -119,8 +134,14 @@ export const createRegression = /* @__PURE__ */ closedAction(
         dataId,
         bandId: band === false ? undefined : bandId,
         lineId,
-        parameters
+        parameters: regressionDefinition
       }
     });
+    return sourceBinding === "follow"
+      ? next.editSemantic({
+          property: `layer[${point.id}].derivedBindings.regression`,
+          value: { mode: "follow", roles: ["data", "x", "y"] }
+        })
+      : next;
   }
 );

package/src/actions/regression/edit.js

@@ -7,7 +7,7 @@ import {
   validateNonNegativeFinite,
   validateUnitInterval
 } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { normalizeRegressionParameters, normalizeRegressionPredict } from "../../grammar/regression/index.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import {
   requestedStrokeDetails,
@@ -21,8 +21,9 @@ import { removeOwnedColorLegends } from "../guides/legends/remove.js";
 import { requireRegressionField } from "./resolve.js";
 
 const OPTIONS = Object.freeze([
-  "target", "data", "x", "y", "groupBy", "method", "degree", "span",
+  "target", "data", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
+  , "predict", "sourceBinding", "missing"
 ]);
 const BAND_OPTIONS = Object.freeze([
   "color", "opacity", "stroke", "strokeWidth", "curve",
@@ -110,14 +111,14 @@ function resolveParameters(previous, args) {
   const method = args.method ?? previous.method;
   const raw = { method };
   for (const key of [
-    "degree", "span", "confidenceMethod", "level", "confidence", "interval"
+    "degree", "span", "robustIterations", "confidenceMethod", "level", "confidence", "interval"
   ]) {
     if (Object.hasOwn(args, key)) raw[key] = args[key];
   }
   const inheritsLevel = !Object.hasOwn(raw, "confidence");
-  if (method === previous.method) {
+  if (method === previous.method && args.interval !== false) {
     for (const key of [
-      "degree", "span", "confidenceMethod", "level", "interval"
+      "degree", "span", "robustIterations", "confidenceMethod", "level", "interval"
     ]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -127,7 +128,7 @@ function resolveParameters(previous, args) {
         raw[key] = previous[key];
       }
     }
-  } else if (method !== "loess" && previous.method !== "loess") {
+  } else if (method !== "loess" && previous.method !== "loess" && args.interval !== false) {
     for (const key of ["confidenceMethod", "level", "interval"]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -138,7 +139,19 @@ function resolveParameters(previous, args) {
       }
     }
   }
-  return normalizeRegressionParameters(raw);
+  const parameters = normalizeRegressionParameters(raw);
+  const predict = Object.hasOwn(args, "predict")
+    ? args.predict === false ? undefined : normalizeRegressionPredict(args.predict)
+    : previous.predict;
+  const missing = Object.hasOwn(args, "missing") ? args.missing : previous.missing;
+  if (missing !== undefined && !["error", "drop"].includes(missing)) {
+    throw new Error('Regression missing must be "error" or "drop".');
+  }
+  return {
+    ...parameters,
+    ...(predict === undefined ? {} : { predict }),
+    ...(missing === undefined ? {} : { missing })
+  };
 }
 
 function regressionColorScale(owner, current, groupBy) {
@@ -245,15 +258,31 @@ export const editRegression = /* @__PURE__ */ closedAction(
     }
     const owner = resolveRegressionOwner(this, args.target);
     const current = this.markConfigs[owner.id].regression;
-    const source = Object.hasOwn(args, "data")
+    const currentBinding = owner.derivedBindings?.regression?.mode === "follow" ? "follow" : "fixed";
+    const sourceBinding = args.sourceBinding ?? currentBinding;
+    if (!["fixed", "follow"].includes(sourceBinding)) throw new Error('Regression sourceBinding must be "fixed" or "follow".');
+    const followed = sourceBinding === "follow" ? {
+      data: owner.data,
+      x: owner.encoding?.x?.fieldType === "quantitative" ? owner.encoding.x.field : undefined,
+      y: owner.encoding?.y?.fieldType === "quantitative" ? owner.encoding.y.field : undefined
+    } : undefined;
+    if (sourceBinding === "follow" && (!followed.data || !followed.x || !followed.y)) {
+      throw new Error(`Following regression source "${owner.id}" requires quantitative x/y fields and data.`);
+    }
+    for (const key of ["data", "x", "y"]) {
+      if (followed !== undefined && Object.hasOwn(args, key) && args[key] !== followed[key]) {
+        throw new Error(`Following regression ${key} must match source mark "${owner.id}".`);
+      }
+    }
+    const source = followed?.data ?? (Object.hasOwn(args, "data")
       ? validateUserId(args.data, "Regression data id")
-      : current.source;
-    const x = Object.hasOwn(args, "x")
+      : current.source);
+    const x = followed?.x ?? (Object.hasOwn(args, "x")
       ? requireRegressionField(args.x, "Regression x")
-      : current.x;
-    const y = Object.hasOwn(args, "y")
+      : current.x);
+    const y = followed?.y ?? (Object.hasOwn(args, "y")
       ? requireRegressionField(args.y, "Regression y")
-      : current.y;
+      : current.y);
     const groupBy = Object.hasOwn(args, "groupBy")
       ? args.groupBy === false
         ? undefined
@@ -272,12 +301,12 @@ export const editRegression = /* @__PURE__ */ closedAction(
     const linePatch = Object.hasOwn(args, "line")
       ? validateLinePatch(args.line)
       : undefined;
-    if (parameters.method === "loess" && bandPatch !== undefined && bandPatch !== false) {
+    if ((parameters.method === "loess" || parameters.interval === false) && bandPatch !== undefined && bandPatch !== false) {
       throw new Error("LOESS regression does not support a band object.");
     }
 
     const hadBand = current.bandId !== undefined;
-    const wantsBand = parameters.method !== "loess" &&
+    const wantsBand = parameters.method !== "loess" && parameters.interval !== false &&
       (bandPatch === false
         ? false
         : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
@@ -385,6 +414,12 @@ export const editRegression = /* @__PURE__ */ closedAction(
       if (changesStatistics) {
         next = next.releaseDerivedData(revision.release);
       }
+      const binding = findLayer(next, owner.id)?.derivedBindings?.regression;
+      if (sourceBinding === "follow" && binding?.mode !== "follow") {
+        next = next.editSemantic({ property: `layer[${owner.id}].derivedBindings.regression`, value: { mode: "follow", roles: ["data", "x", "y"] } });
+      } else if (sourceBinding === "fixed" && binding !== undefined) {
+        next = next.editSemantic({ property: `layer[${owner.id}].derivedBindings.regression`, remove: true });
+      }
       return next;
     };
     return applyEdit(this);