ggaction 0.0.13 → 0.0.16

package/src/actions/primitives/editGraphics.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
 import { validateGeneratedItemLimit } from "../../core/validation.js";
 import {
@@ -63,6 +63,32 @@ function replaceDrawableItems(value, id, type) {
   });
 }
 
+export function replaceGraphicItems(program, target, baseType, items) {
+  let next = program.editGraphics({ target, property: "items", value: items });
+  const graphic = next.graphicSpec.objects[target];
+  if (
+    graphic.type !== "collection" ||
+    !graphic.items.every(item => item.type === baseType)
+  ) return next;
+  const normalized = freezeOwned({
+    ...graphic,
+    type: baseType,
+    items: freezeOwned(graphic.items.map(item => freezeOwned({
+      id: item.id,
+      properties: item.properties
+    })))
+  });
+  return next._clone({
+    graphicSpec: freezeOwned({
+      ...next.graphicSpec,
+      objects: freezeOwned({
+        ...next.graphicSpec.objects,
+        [target]: normalized
+      })
+    })
+  });
+}
+
 function editGeneratedItem(owner, itemIndex, property, value) {
   const items = [...owner.items];
   const item = items[itemIndex];
@@ -136,13 +162,14 @@ function removeGraphicTree(graphicSpec, id) {
   return freezeOwned({ objects: freezeOwned(objects), order });
 }
 
-const editGraphics = action(
+const editGraphics = /* @__PURE__ */ closedAction(
   {
     op: "editGraphics",
     description: "Replace or remove concrete graphic state.",
     scope: "any"
-  },
-  function ({ target, property, value, remove = false } = {}) {
+  }, ["target", "property", "value", "remove"],
+  function (args = {}) {
+    const { target, property, value, remove = false } = args;
     if (typeof target !== "string" || target.length === 0) {
       throw new TypeError("editGraphics requires a non-empty target string.");
     }

package/src/actions/primitives/graphicProperties.js

@@ -0,0 +1,6 @@
+export function editGraphicProperties(program, target, properties) {
+  for (const [property, value] of Object.entries(properties)) {
+    program = program.editGraphics({ target, property, value });
+  }
+  return program;
+}

package/src/actions/primitives/semantic.js

@@ -1,4 +1,5 @@
 import { createSemanticPrimitiveAction } from "./semanticAction.js";
+import { planResourceRemoval } from "../resources/remove.js";
 import { validateDatasetTransforms } from "../../grammar/transforms.js";
 import {
   validateParallelDimensions,
@@ -17,12 +18,19 @@ function validateParallel(property, value) {
   }
 }
 
-export function registerSemanticPrimitiveAction(ProgramClass) {
-  const validateSemanticValue = createSemanticValueValidator({
+function fullSemanticValidator() {
+  return createSemanticValueValidator({
     validateDatasetTransforms,
     validateParallel,
     sourceMarkTypes: ["point", "bar", "line", "rule", "rect", "arc"]
   });
+}
+
+export function validateStoredSemanticValue(program, parsed, value) {
+  return fullSemanticValidator()(program, parsed, value);
+}
+
+export function registerSemanticPrimitiveAction(ProgramClass) {
   ProgramClass.prototype.editSemantic =
-    createSemanticPrimitiveAction(validateSemanticValue);
+    createSemanticPrimitiveAction(fullSemanticValidator(), planResourceRemoval);
 }

package/src/actions/primitives/semanticAction.js

@@ -1,5 +1,5 @@
 import { hasSemanticScaleReferences } from "../../selectors/scales.js";
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import {
   cloneAndFreeze,
   freezeOwned,
@@ -8,6 +8,7 @@ import {
 } from "../../core/immutable.js";
 import { parseSemanticPath } from "../../grammar/schemas/semanticPath.js";
 
+
 const CONTEXT_KEYS = Object.freeze({
   dataset: "currentData",
   layer: "currentMark",
@@ -79,7 +80,7 @@ function removeEntity(spec, parsed) {
   if (parsed.kind === "scale" && parsed.path.length === 0) {
     if (hasSemanticScaleReferences(spec, parsed.id)) throw new Error(`Scale "${parsed.id}" is still referenced.`);
   }
-  if (["layer", "scale"].includes(parsed.kind) && parsed.path.length === 0) {
+  if (["layer", "scale", "coordinate"].includes(parsed.kind) && parsed.path.length === 0) {
     const nextCollection = collection.filter((_, itemIndex) => itemIndex !== index);
     return freezeOwned({
       ...spec,
@@ -87,10 +88,6 @@ function removeEntity(spec, parsed) {
     });
   }
   if (parsed.kind === "dataset" && parsed.path.length === 0) {
-    const dataset = collection[index];
-    if (dataset.source === undefined) {
-      throw new Error(`Source dataset "${parsed.id}" is immutable after creation.`);
-    }
     const referenced = spec.layers.some(layer => layer.data === parsed.id) ||
       spec.datasets.some(candidate => candidate.source === parsed.id);
     if (referenced) {
@@ -151,14 +148,59 @@ export function withPreviewDatasetValues(program, {
   return program._clone({ semanticSpec });
 }
 
-export function createSemanticPrimitiveAction(validateSemanticValue) {
-  return action(
+// Owned materializers may refresh a generated derived dataset at a stable ID.
+// Keep that privileged immutable transition inside the semantic primitive
+// boundary; public editSemantic still rejects every post-creation dataset edit.
+export function withRematerializedDerivedDataset(program, {
+  id,
+  source,
+  transform,
+  values
+}) {
+  const semanticSpec = {
+    ...program.semanticSpec,
+    datasets: program.semanticSpec.datasets.map(dataset =>
+      dataset.id === id
+        ? { ...dataset, source, transform: [transform], values }
+        : dataset
+    )
+  };
+  return program._clone({ semanticSpec });
+}
+
+// Final-state planners may need to remove mutually constrained roles before
+// replaying their canonical primitive owners. Keep that speculative clone in
+// the primitive boundary and preserve the caller's layer for later dependency
+// and guide reconciliation.
+export function withoutPreviewLayerEncodings(program, { id, channels }) {
+  const removed = new Set(channels);
+  const semanticSpec = {
+    ...program.semanticSpec,
+    layers: program.semanticSpec.layers.map(layer => {
+      if (layer.id !== id) return layer;
+      return {
+        ...layer,
+        encoding: Object.fromEntries(
+          Object.entries(layer.encoding ?? {}).filter(
+            ([channel]) => !removed.has(channel)
+          )
+        )
+      };
+    })
+  };
+  return program._clone({ semanticSpec });
+}
+
+export function createSemanticPrimitiveAction(validateSemanticValue, planNamedRemoval) {
+  return closedAction(
     {
       op: "editSemantic",
       description: "Create, replace, or remove one semantic property.",
       scope: "any"
-    },
-    function ({ property, value, remove = false } = {}) {
+    }, ["property", "value", "remove"],
+    function (args = {}) {
+
+      const { property, value, remove = false } = args;
       if (typeof remove !== "boolean") {
         throw new TypeError("editSemantic remove must be a boolean.");
       }
@@ -170,14 +212,37 @@ export function createSemanticPrimitiveAction(validateSemanticValue) {
       }
 
       const parsed = parseSemanticPath(property, { allowContainer: remove });
+      const removesNamedResource = remove && parsed.path.length === 0 &&
+        ["dataset", "scale", "coordinate"].includes(parsed.kind);
       if (this.compositionSpec !== undefined && !(
-        this.compositionSpec.type === "facet" && parsed.kind === "title"
+        this.compositionSpec.type === "facet" &&
+        (parsed.kind === "title" || removesNamedResource)
       )) {
         throw new Error(
-          "editSemantic on a composition parent currently supports only facet title state."
+          "editSemantic on a composition parent supports only facet title state and unreferenced named resource removal."
         );
       }
       if (remove) {
+        // Source/coordinate removal and facet-parent removal use the same full
+        // dependency policy as the domain lifecycle. Existing unit derived-data
+        // teardown retains its semantic-only primitive contract; its owning
+        // action coordinates configuration and graphics cleanup separately.
+        const resource = removesNamedResource
+          ? this.semanticSpec[parsed.collection].find(item => item.id === parsed.id)
+          : undefined;
+        if (resource !== undefined && (
+          parsed.kind === "coordinate" || this.compositionSpec?.type === "facet" ||
+          (parsed.kind === "dataset" && resource.source === undefined)
+        )) {
+          if (planNamedRemoval === undefined) {
+            throw new Error("Named resource removal requires the full ChartProgram.");
+          }
+          planNamedRemoval(this, {
+            kind: parsed.kind === "dataset" ? "data" : parsed.kind,
+            id: parsed.id,
+            operation: "editSemantic"
+          });
+        }
         const semanticSpec = parsed.kind === "guide"
           ? removeRootProperty(this.semanticSpec, "guides", parsed.path)
           : parsed.kind === "title"
@@ -192,17 +257,28 @@ export function createSemanticPrimitiveAction(validateSemanticValue) {
           parsed.kind === "layer" &&
           parsed.path.length === 0 &&
           this.context.currentMark === parsed.id;
+        const clearsCurrentCoordinate =
+          parsed.kind === "coordinate" &&
+          parsed.path.length === 0 &&
+          this.context.currentCoordinate === parsed.id;
+        const clearsCurrentGuide =
+          parsed.kind === "guide" &&
+          parsed.path.length === 2 &&
+          this.context.currentGuide === parsed.id;
         const removesScale = parsed.kind === "scale" && parsed.path.length === 0;
         const resolvedScales = removesScale ? Object.fromEntries(Object.entries(this.resolvedScales).filter(([id]) => id !== parsed.id)) : this.resolvedScales;
         return this._clone({
           semanticSpec,
           ...(removesScale ? { resolvedScales: freezeOwned(resolvedScales) } : {}),
-          ...(clearsCurrentData || clearsCurrentMark || (removesScale && this.context.currentScale === parsed.id)
+          ...(clearsCurrentData || clearsCurrentMark || clearsCurrentGuide || clearsCurrentCoordinate ||
+              (removesScale && this.context.currentScale === parsed.id)
             ? { context: freezeOwned({
                 ...this.context,
                 ...(removesScale && this.context.currentScale === parsed.id ? { currentScale: undefined } : {}),
                 ...(clearsCurrentData ? { currentData: undefined } : {}),
-                ...(clearsCurrentMark ? { currentMark: undefined } : {})
+                ...(clearsCurrentMark ? { currentMark: undefined } : {}),
+                ...(clearsCurrentCoordinate ? { currentCoordinate: undefined } : {}),
+                ...(clearsCurrentGuide ? { currentGuide: undefined } : {})
               }) }
             : {})
         });

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

@@ -1,5 +1,5 @@
 import { validateUserId } from "../../../core/identifiers.js";
-import { isPlainObject } from "../../../core/immutable.js";
+import { validateDataRows } from "../../../core/validation.js";
 import { hasDataset } from "../../../selectors/datasets.js";
 
 export function validateDatasetSemanticValue(
@@ -10,9 +10,7 @@ export function validateDatasetSemanticValue(
 ) {
   const property = parsed.path[0];
   if (property === "values") {
-    if (!Array.isArray(value) || !value.every(isPlainObject)) {
-      throw new TypeError("Dataset values must be an array of plain row objects.");
-    }
+    validateDataRows(value, `Dataset "${parsed.id}"`);
     return;
   }
   if (property === "source") {

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

@@ -30,7 +30,7 @@ export function validateGuideSemanticValue(_program, parsed, value) {
     validateParallelAxisTitles(value);
     return;
   }
-  if (["legend.series", "legend.color"].includes(parsed.id) && property === "order") {
+  if (["legend.series", "legend.color", "legend.stroke"].includes(parsed.id) && property === "order") {
     normalizeLegendOrder(value);
     return;
   }

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

@@ -1,4 +1,8 @@
-import { validateCoordinateType } from "../../../grammar/coordinates.js";
+import {
+  normalizeCoordinateAspect,
+  validateCoordinateType
+} from "../../../grammar/coordinates.js";
+import { normalizePolarFrameOptions } from "../../../grammar/polar.js";
 import { validateScaleSemanticValue } from "./scale.js";
 import { validateDatasetSemanticValue } from "./dataset.js";
 import { validateLayerSemanticValue } from "./layer.js";
@@ -27,6 +31,10 @@ export function createSemanticValueValidator({
       validateScaleSemanticValue(program, parsed, value);
     } else if (parsed.kind === "coordinate" && parsed.path[0] === "type") {
       validateCoordinateType(value);
+    } else if (parsed.kind === "coordinate" && parsed.path[0] === "aspect") {
+      normalizeCoordinateAspect(value);
+    } else if (parsed.kind === "coordinate" && parsed.path[0] === "polarFrame") {
+      normalizePolarFrameOptions(value);
     } else if (parsed.kind === "guide") {
       validateGuideSemanticValue(program, parsed, value);
     } else if (parsed.kind === "title") {

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

@@ -17,6 +17,8 @@ import { normalizeCategoryOrder } from "../../../grammar/categoryOrder.js";
 import { validateSemanticFieldType } from "../../../grammar/scales/index.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { validateNonEmptySemanticString } from "./shared.js";
+import { normalizeStatisticalWeight } from
+  "../../../grammar/weightedStatistics.js";
 
 function validateLayerSource(program, parsed, value, sourceMarkTypes) {
   validateUserId(value, "Layer source id");
@@ -81,6 +83,9 @@ export function validateLayerSemanticValue(
     validateParallel?.(property, value);
   }
   if (property.endsWith(".aggregate")) validateAggregate(value);
+  if (property === "encoding.x.weight") {
+    normalizeStatisticalWeight(value, "Histogram weight");
+  }
   if (property.endsWith(".bin.maxBins")) normalizeHistogramBin({ maxBins: value });
   if (property.endsWith(".bin.step")) validateHistogramBinStep(value);
   if (property.endsWith(".bin.boundaries")) validateHistogramBinBoundaries(value);

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

@@ -8,9 +8,22 @@ import {
   validateSemanticScaleType
 } from "../../../grammar/scales/index.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
+import { findScaleConsumers } from "../../scales/consumers/index.js";
 
-function validateOwnedProperty(existing, property) {
+function isOffsetScale(program, id, existing) {
+  if (existing?.type !== "ordinal") return false;
+  const consumers = findScaleConsumers(program, id);
+  return consumers.length > 0 && consumers.every(
+    consumer => ["xOffset", "yOffset"].includes(consumer.channel)
+  );
+}
+
+function validateOwnedProperty(program, id, existing, property) {
   if (existing?.type !== undefined) {
+    if (
+      isOffsetScale(program, id, existing) &&
+      ["paddingInner", "paddingOuter", "align"].includes(property)
+    ) return;
     validateScalePropertyForType(existing.type, property);
   }
 }
@@ -31,7 +44,13 @@ export function validateScaleSemanticValue(program, parsed, value) {
       "nice", "zero", "clamp", "base", "exponent", "constant", "midpoint",
       "paddingInner", "paddingOuter", "padding", "align"
     ]) {
-      if (existing?.[owned] !== undefined) validateScalePropertyForType(value, owned);
+      if (existing?.[owned] === undefined) continue;
+      if (
+        value === "ordinal" &&
+        isOffsetScale(program, parsed.id, existing) &&
+        ["paddingInner", "paddingOuter", "align"].includes(owned)
+      ) continue;
+      validateScalePropertyForType(value, owned);
     }
     return;
   }
@@ -41,7 +60,9 @@ export function validateScaleSemanticValue(program, parsed, value) {
     if (typeof value !== "boolean") {
       throw new TypeError(`Scale ${property} must be a boolean.`);
     }
-    if (property !== "reverse") validateOwnedProperty(existing, property);
+    if (property !== "reverse") {
+      validateOwnedProperty(program, parsed.id, existing, property);
+    }
     return;
   }
   if (["base", "exponent", "constant"].includes(property)) {
@@ -51,7 +72,7 @@ export function validateScaleSemanticValue(program, parsed, value) {
     if (property === "base" && value === 1) {
       throw new RangeError("Scale base must not equal 1.");
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
     return;
   }
   if (property === "interpolate") {
@@ -64,20 +85,20 @@ export function validateScaleSemanticValue(program, parsed, value) {
         "Scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
       );
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
     return;
   }
   if (property === "paddingOuter" || property === "padding") {
     if (!Number.isFinite(value) || value < 0) {
       throw new RangeError(`Scale ${property} must be a non-negative finite number.`);
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
     return;
   }
   if (property === "align") {
     if (!Number.isFinite(value) || value < 0 || value > 1) {
       throw new RangeError("Scale align must be between 0 and 1.");
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
   }
 }

package/src/actions/regression/components.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { resolveEligibleLayer } from "../../selectors/layers.js";
@@ -9,19 +9,27 @@ import {
   REGRESSION_UPPER_FIELD
 } from "../../grammar/regression/index.js";
 import { validateAreaCreateOutline } from "../marks/area/index.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 
 const BAND_OPTIONS = Object.freeze([
   "id", "data", "x", "lower", "upper", "groupBy", "coordinate", "xScale", "yScale",
-  "color", "opacity", "stroke", "strokeWidth", "curve"
+  "color", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const LINE_OPTIONS = Object.freeze([
   "id", "data", "x", "y", "groupBy", "coordinate", "xScale", "yScale", "colorScale",
-  "strokeWidth", "curve"
+  "strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES
 ]);
 const EDIT_BAND_OPTIONS = Object.freeze([
-  "target", "color", "opacity", "stroke", "strokeWidth", "curve"
+  "target", "color", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
+]);
+const EDIT_LINE_OPTIONS = Object.freeze([
+  "target", "strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES
 ]);
-const EDIT_LINE_OPTIONS = Object.freeze(["target", "strokeWidth", "curve"]);
 
 function isRegressionLayer(program, layer, type) {
   const dataset = findDataset(program, layer.data);
@@ -64,13 +72,12 @@ function requireRegressionBandDataset(program, args) {
   return { dataset, transform };
 }
 
-export const createRegressionBand = action(
+export const createRegressionBand = /* @__PURE__ */ closedAction(
   {
     op: "createRegressionBand",
     description: "Create and encode a grouped regression confidence band."
-  },
+  }, BAND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, BAND_OPTIONS, "createRegressionBand");
     const id = validateUserId(args.id, "Regression band id");
     const { transform } = requireRegressionBandDataset(this, args);
     validateAreaCreateOutline(args, "createRegressionBand");
@@ -93,7 +100,8 @@ export const createRegressionBand = action(
         coordinate: args.coordinate,
         fill: args.color ?? DEFAULT_COLORS.regressionBand,
         opacity: args.opacity ?? 0.18,
-        ...(args.curve === undefined ? {} : { curve: args.curve })
+        ...(args.curve === undefined ? {} : { curve: args.curve }),
+        ...requestedStrokeDetails(args, "createRegressionBand")
       })
       .editSemantic({
         property: `layer[${id}].encoding.y.title`,
@@ -112,14 +120,16 @@ export const createRegressionBand = action(
   }
 );
 
-export const editRegressionBand = action(
+export const editRegressionBand = /* @__PURE__ */ closedAction(
   {
     op: "editRegressionBand",
     description: "Edit regression-band fill, opacity, and outline."
-  },
+  }, EDIT_BAND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EDIT_BAND_OPTIONS, "editRegressionBand");
-    const changes = ["color", "opacity", "stroke", "strokeWidth", "curve"];
+    const changes = [
+      "color", "opacity", "stroke", "strokeWidth", "curve",
+      ...STROKE_STYLE_PROPERTIES
+    ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
       throw new Error(
         "editRegressionBand requires color, opacity, stroke, strokeWidth, or curve."
@@ -139,21 +149,21 @@ export const editRegressionBand = action(
       ...(Object.hasOwn(args, "strokeWidth")
         ? { strokeWidth: args.strokeWidth }
         : {}),
-      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {})
+      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {}),
+      ...requestedStrokeDetails(args, "editRegressionBand")
     });
   }
 );
 
-export const editRegressionLine = action(
+export const editRegressionLine = /* @__PURE__ */ closedAction(
   {
     op: "editRegressionLine",
     description: "Edit regression-line width or curve."
-  },
+  }, EDIT_LINE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EDIT_LINE_OPTIONS, "editRegressionLine");
     if (
-      !Object.hasOwn(args, "strokeWidth") &&
-      !Object.hasOwn(args, "curve")
+      !["strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES]
+        .some(property => Object.hasOwn(args, property))
     ) {
       throw new Error("editRegressionLine requires strokeWidth or curve.");
     }
@@ -168,25 +178,26 @@ export const editRegressionLine = action(
       ...(Object.hasOwn(args, "strokeWidth")
         ? { strokeWidth: args.strokeWidth }
         : {}),
-      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {})
+      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {}),
+      ...requestedStrokeDetails(args, "editRegressionLine")
     });
   }
 );
 
-export const createRegressionLine = action(
+export const createRegressionLine = /* @__PURE__ */ closedAction(
   {
     op: "createRegressionLine",
     description: "Create and encode grouped regression line paths."
-  },
+  }, LINE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, LINE_OPTIONS, "createRegressionLine");
     const id = validateUserId(args.id, "Regression line id");
     let next = this
       .createLineMark({
         id,
         data: args.data,
         strokeWidth: args.strokeWidth ?? 3,
-        ...(args.curve === undefined ? {} : { curve: args.curve })
+        ...(args.curve === undefined ? {} : { curve: args.curve }),
+        ...requestedStrokeDetails(args, "createRegressionLine")
       })
       .encodeX({
         target: id,

package/src/actions/regression/create.js

@@ -1,6 +1,7 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
 import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   findRegressionPoint,
   inferRegressionGroup,
@@ -13,13 +14,12 @@ const REGRESSION_OPTIONS = Object.freeze([
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
 ]);
 
-export const createRegression = action(
+export const createRegression = /* @__PURE__ */ closedAction(
   {
     op: "createRegression",
     description: "Fit and layer regression lines with optional interval bands."
-  },
+  }, REGRESSION_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REGRESSION_OPTIONS, "createRegression");
     const point = findRegressionPoint(this, args.target);
     const x = args.x === undefined
       ? point.encoding.x.field
@@ -49,11 +49,18 @@ export const createRegression = action(
     if (band !== false) {
       validateKeys(
         band,
-        ["color", "opacity", "stroke", "strokeWidth", "curve"],
+        [
+          "color", "opacity", "stroke", "strokeWidth", "curve",
+          ...STROKE_STYLE_PROPERTIES
+        ],
         "regression band"
       );
     }
-    validateKeys(line, ["strokeWidth", "curve"], "regression line");
+    validateKeys(
+      line,
+      ["strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES],
+      "regression line"
+    );
     const colorEncoding = point.encoding?.color;
     const namespace = point.id;
     const dataId = `${namespace}RegressionData`;