ggaction 0.0.16 → 0.0.17

package/src/actions/marks/point/edit.js

@@ -13,9 +13,10 @@ import {
 import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { validateMarkOptions } from "../shared.js";
+import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze([
-  "target", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  "target", "missing", "shape", "fill", "opacity", "stroke", "strokeWidth",
   ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -28,12 +29,12 @@ export const editPointMark = /* @__PURE__ */ action(
     validateMarkOptions(args, OPTIONS, "editPointMark");
     const strokeDetails = requestedStrokeDetails(args, "editPointMark");
     const editable = [
-      "shape", "fill", "opacity", "stroke", "strokeWidth",
+      "missing", "shape", "fill", "opacity", "stroke", "strokeWidth",
       ...STROKE_STYLE_PROPERTIES
     ];
     if (!editable.some(property => Object.hasOwn(args, property))) {
       throw new Error(
-        "editPointMark requires shape, fill, opacity, stroke, or strokeWidth."
+        "editPointMark requires shape, fill, opacity, stroke, strokeWidth, or missing."
       );
     }
     if (args.target !== undefined) validateUserId(args.target, "Point mark id");
@@ -61,7 +62,13 @@ export const editPointMark = /* @__PURE__ */ action(
     if (Object.hasOwn(args, "opacity") && layer.encoding?.opacity?.field !== undefined) {
       throw new Error("editPointMark opacity conflicts with a field encoding; use encodeOpacity with value to replace it.");
     }
-    const config = { ...this.markConfigs[id] };
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Point missing")
+        })
+      : this;
+    const config = { ...semantic.markConfigs[id] };
     Object.assign(config, strokeDetails);
     if (Object.hasOwn(args, "shape")) {
       config.shape = validatePointShape(args.shape);
@@ -97,7 +104,7 @@ export const editPointMark = /* @__PURE__ */ action(
         "Point strokeWidth"
       );
     }
-    const next = this
+    const next = semantic
       ._withMarkConfig(id, config)
       .rematerializePointMark({ id });
     return rematerializeExistingLegend(next);

package/src/actions/marks/point/materialize.js

@@ -40,6 +40,7 @@ import { offsetCategoryPositions } from
   "../../../materialization/categorySlotOffset.js";
 import { requestedStrokeDetails } from
   "../../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy } from "../../../grammar/itemMissing.js";
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 const DEFAULT_POINT_FILL = DEFAULT_COLORS.mark;
@@ -337,10 +338,11 @@ export const rematerializePointMark = /* @__PURE__ */ action(
     if (!["circle", "rect", "path", "collection"].includes(graphic?.type)) {
       throw new Error(`Point mark "${id}" requires point graphics.`);
     }
-    const dataset = findDataset(resolved, layer.data);
-    if (dataset === undefined) {
+    const sourceDataset = findDataset(resolved, layer.data);
+    if (sourceDataset === undefined) {
       throw new Error(`Point mark "${id}" requires an existing dataset.`);
     }
+    const dataset = applyItemMissingPolicy(layer, sourceDataset);
 
     if (graphic.items.length === 0 && !canMaterializePoint(resolved, layer)) {
       return resolved;

package/src/actions/marks/rect/actions.js

@@ -29,13 +29,15 @@ import {
 } from "../../../grammar/roundedRect.js";
 import { STROKE_STYLE_PROPERTIES } from
   "../../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 
 const STYLE_OPTIONS = Object.freeze([
   "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
   ...STROKE_STYLE_PROPERTIES
 ]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", ...STYLE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...STYLE_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...STYLE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
 function requireRectLayer(program, requested, operation) {
@@ -71,6 +73,12 @@ const createRectMark = /* @__PURE__ */ action(
     let next = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "rect" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      next = next.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Rect missing")
+      });
+    }
     next = applyLayeredMarkInheritance(next, id, inherited)
       .createGraphics({
         id,
@@ -120,10 +128,11 @@ const rematerializeRectMark = /* @__PURE__ */ action(
     if (this.markConfigs[id]?.gradientPlot?.materialized === true) {
       return this.materializeGradientPlotFill({ id });
     }
-    const dataset = findDataset(this, layer.data);
-    if (dataset === undefined) {
+    const sourceDataset = findDataset(this, layer.data);
+    if (sourceDataset === undefined) {
       throw new Error(`Rect mark "${id}" requires an existing dataset.`);
     }
+    const dataset = applyItemMissingPolicy(layer, sourceDataset);
     if (!canMaterializeRect(this, layer)) {
       return replaceGraphicItems(this, id, "rect", []);
     }
@@ -151,7 +160,7 @@ const editRectMark = /* @__PURE__ */ action(
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editRectMark");
     requestedRectStyleDetails(args, "editRectMark");
-    if (!STYLE_OPTIONS.some(option => Object.hasOwn(args, option))) {
+    if (!["missing", ...STYLE_OPTIONS].some(option => Object.hasOwn(args, option))) {
       throw new Error("editRectMark requires at least one editable property.");
     }
     const layer = requireRectLayer(this, args.target, "editRectMark");
@@ -163,16 +172,22 @@ const editRectMark = /* @__PURE__ */ action(
         "editRectMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
       );
     }
-    const next = this._withMarkConfig(
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Rect missing")
+        })
+      : this;
+    const next = semantic._withMarkConfig(
       layer.id,
       {
         ...normalizeRectMarkConfig(
           args,
-          this.markConfigs[layer.id] ?? DEFAULT_RECT_MARK
+          semantic.markConfigs[layer.id] ?? DEFAULT_RECT_MARK
         ),
         fillExplicit: Object.hasOwn(args, "fill")
           ? true
-          : this.markConfigs[layer.id]?.fillExplicit ?? false
+          : semantic.markConfigs[layer.id]?.fillExplicit ?? false
       }
     );
     const materialized = canMaterializeRect(next, layer)

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

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

@@ -39,13 +39,14 @@ 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 +140,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 +154,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`,
@@ -465,20 +475,29 @@ 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.");
+    }
+    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/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,26 @@ 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 === "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,
@@ -12,6 +12,7 @@ import {
 const REGRESSION_OPTIONS = Object.freeze([
   "target", "x", "y", "groupBy", "method", "degree", "span",
   "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;
   }
 );