ggaction 0.0.17 → 0.0.18

package/src/actions/marks/area/actions.js

@@ -1,3 +1,5 @@
+import { validateFillPaint } from "../../../grammar/paint.js";
+import { validateAreaPaintConfig } from "../../../grammar/areaPaint.js";
 import { validateAreaMissing } from "../../../grammar/areaEndpoints.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -81,7 +83,7 @@ const createAreaMark = /* @__PURE__ */ action(
     if (missing === "break" && ["density", "horizon"].some(type => findUpstreamTransform(this, findDataset(this, data), type))) {
       throw new Error("Area missing:break does not reinterpret density or horizon data.");
     }
-    const fill = validateNonEmptyString(args.fill ?? DEFAULT_COLORS.mark, "Area fill");
+    const fill = validateFillPaint(args.fill ?? DEFAULT_COLORS.mark, "Area fill");
     const opacity = validateUnitInterval(args.opacity ?? 0.2, "Area opacity");
     const curve = validateCurveInterpolation(args.curve ?? "linear");
     const { stroke, strokeWidth } = validateAreaCreateOutline(args);
@@ -127,14 +129,14 @@ const configureAreaStrokeFromFill = /* @__PURE__ */ action(
     }
     const { stroke: _stroke, ...config } = this.markConfigs[id] ?? {};
     void _stroke;
-    return this._withMarkConfig(id, {
+    return this._withMarkConfig(id, validateAreaPaintConfig({
       ...config,
       strokeFromFill: true,
       strokeWidth: validateNonNegativeFinite(
         args.strokeWidth ?? 1,
         "Area strokeWidth"
       )
-    });
+    }));
   }
 );
 
@@ -199,7 +201,7 @@ const rematerializeAreaMark = /* @__PURE__ */ action(
     if (args.scales !== false && strokeEncoding?.scale !== undefined) {
       resolved = resolved.rematerializeScale({ id: strokeEncoding.scale });
     }
-    const config = this.markConfigs[id];
+    const config = validateAreaPaintConfig(this.markConfigs[id]);
     const { paths, fills, strokes } = resolveAreaMaterialization({
       rows: dataset.values,
       layer,
@@ -273,7 +275,7 @@ const editAreaMark = /* @__PURE__ */ action(
     let config = { ...this.markConfigs[layer.id] };
     Object.assign(config, strokeDetails);
     if (Object.hasOwn(args, "fill")) {
-      config.fill = validateNonEmptyString(args.fill, "Area fill");
+      config.fill = validateFillPaint(args.fill, "Area fill");
       if (config.errorBand !== undefined) config.errorBand = { ...config.errorBand, fill: config.fill };
     }
     if (Object.hasOwn(args, "opacity")) {
@@ -314,6 +316,7 @@ const editAreaMark = /* @__PURE__ */ action(
       );
     }
 
+    validateAreaPaintConfig(config);
     let next = this._withMarkConfig(layer.id, config);
     if (Object.hasOwn(args, "missing")) {
       const missing = validateAreaMissing(args.missing);

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

@@ -6,6 +6,7 @@ import {
 } from "../../../grammar/areaSeries.js";
 import {
   mapContinuousScaleValues,
+  mapOrdinalPositionValues,
   mapOrdinalValues
 } from "../../../grammar/scales/index.js";
 import { mapScaleConsumerValues } from
@@ -37,9 +38,8 @@ function resolveAreaPaths({
   }
   return derived.series.map(series => {
     if (densityTransform === undefined && derived.orientation === "horizontal") {
-      const y = mapContinuousScaleValues(
-        series.values.map(value => value.y),
-        yScale
+      const y = (["point", "band"].includes(yScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
+        series.values.map(value => value.y), yScale
       );
       const lower = mapContinuousScaleValues(
         series.values.map(value => value.x),
@@ -57,9 +57,8 @@ function resolveAreaPaths({
       );
     }
     if (densityTransform !== undefined && derived.mode === "x-density") {
-      const y = mapContinuousScaleValues(
-        series.values.map(value => value.y),
-        yScale
+      const y = (["point", "band"].includes(yScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
+        series.values.map(value => value.y), yScale
       );
       const upper = mapContinuousScaleValues(
         series.values.map(value => value.x),
@@ -80,7 +79,7 @@ function resolveAreaPaths({
         { independentAxis: "y" }
       );
     }
-    const x = mapContinuousScaleValues(
+    const x = (["point", "band"].includes(xScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
       series.values.map(value => value.x),
       xScale
     );
@@ -134,8 +133,8 @@ export function resolveAreaMaterialization({
     layer.encoding?.y?.stack === "center";
   const rawDerived = densityTransform === undefined
     ? centered
-      ? deriveCenteredAreaSeries(rows, layer)
-      : deriveAreaSeries(rows, layer)
+      ? deriveCenteredAreaSeries(rows, layer, { xDomain: xScale.domain })
+      : deriveAreaSeries(rows, layer, { xDomain: xScale.domain, yDomain: yScale.domain })
     : deriveDensityAreaSeries(rows, layer, densityTransform);
   const colorEncoding = layer.encoding?.color;
   const layout = layer.layout?.mode ?? colorEncoding?.layout ?? "overlay";

package/src/actions/marks/bar/create.js

@@ -10,15 +10,15 @@ import {
 } from "../shared.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
-import { requestedRectStyleDetails } from
+import { requestedRectStyleDetails, RECT_RADIUS_PROPERTIES } from
   "../../../grammar/roundedRect.js";
 import { STROKE_STYLE_PROPERTIES } from
   "../../../grammar/strokeStyle.js";
 import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "missing", "fill", "opacity", "stroke", "strokeWidth",
-  "cornerRadius", ...STROKE_STYLE_PROPERTIES
+  "id", "data", "orientation", "missing", "fill", "opacity", "stroke", "strokeWidth",
+  ...RECT_RADIUS_PROPERTIES, ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const createBarMark = /* @__PURE__ */ action(
@@ -29,6 +29,9 @@ export const createBarMark = /* @__PURE__ */ action(
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createBarMark");
     requestedRectStyleDetails(args, "createBarMark");
+    if (args.orientation !== undefined && !["vertical", "horizontal"].includes(args.orientation)) {
+      throw new Error("Bar orientation must be vertical or horizontal.");
+    }
     const id = resolveMarkId(this, args.id, {
       defaultId: "bar",
       label: "Bar mark id",
@@ -59,6 +62,9 @@ export const createBarMark = /* @__PURE__ */ action(
         value: validateItemMissing(args.missing, "Bar missing")
       });
     }
+    if (args.orientation !== undefined) {
+      created = created.editSemantic({ property: `layer[${id}].mark.orientation`, value: args.orientation });
+    }
     created = applyLayeredMarkInheritance(created, id, inherited);
     created = created
       .createGraphics({
@@ -70,7 +76,7 @@ export const createBarMark = /* @__PURE__ */ action(
     created = materializeInheritedMark(created, id);
     const appearance = Object.fromEntries(
       [
-        "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+        "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
         ...STROKE_STYLE_PROPERTIES
       ]
         .filter(property => Object.hasOwn(args, property))

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

@@ -9,15 +9,16 @@ import { canMaterializeBar } from "../../../materialization/marks/index.js";
 import { DEFAULT_BAR_STROKE_WIDTH } from "../../../materialization/bars/resolve.js";
 import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { validateMarkOptions } from "../shared.js";
-import { requestedRectStyleDetails } from
+import { requestedRectStyleDetails, RECT_RADIUS_PROPERTIES } from
   "../../../grammar/roundedRect.js";
 import { STROKE_STYLE_PROPERTIES } from
   "../../../grammar/strokeStyle.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
+import { validateFillPaint } from "../../../grammar/paint.js";
 import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const EDIT_OPTIONS = Object.freeze([
-  "target", "missing", "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+  "target", "missing", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
   ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -30,7 +31,7 @@ export const editBarMark = /* @__PURE__ */ action(
     validateMarkOptions(args, EDIT_OPTIONS, "editBarMark");
     const styleDetails = requestedRectStyleDetails(args, "editBarMark");
     const changes = [
-      "missing", "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+      "missing", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
       ...STROKE_STYLE_PROPERTIES
     ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
@@ -56,6 +57,9 @@ export const editBarMark = /* @__PURE__ */ action(
         "editBarMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
       );
     }
+    if (Object.hasOwn(args, "opacity") && layer.encoding?.opacity !== undefined) {
+      throw new Error("editBarMark opacity conflicts with a field encoding; use encodeOpacity with value to replace it.");
+    }
     if (args.stroke === false && Object.hasOwn(args, "strokeWidth")) {
       throw new Error(
         "editBarMark cannot set strokeWidth while removing stroke."
@@ -72,7 +76,7 @@ export const editBarMark = /* @__PURE__ */ action(
     const appearance = { ...config.barAppearance };
     Object.assign(appearance, styleDetails);
     if (Object.hasOwn(args, "fill")) {
-      appearance.fill = validateNonEmptyString(args.fill, "Bar fill");
+      appearance.fill = validateFillPaint(args.fill, "Bar fill");
     }
     if (Object.hasOwn(args, "opacity")) {
       appearance.opacity = validateUnitInterval(args.opacity, "Bar opacity");

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

@@ -13,19 +13,17 @@ import {
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { offsetCategoryRectangles } from
   "../../../materialization/categorySlotOffset.js";
-import { materializeRectItem } from "../../../grammar/roundedRect.js";
-import { STROKE_STYLE_PROPERTIES } from
-  "../../../grammar/strokeStyle.js";
+import { materializeRectItem, RECT_STYLE_PROPERTIES } from "../../../grammar/roundedRect.js";
 import { replaceGraphicItems } from "../../primitives/editGraphics.js";
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
 function editRectangles(program, id, rectangles) {
   const appearance = program.markConfigs[id]?.barAppearance ?? {};
-  const hasShapeStyle = ["cornerRadius", ...STROKE_STYLE_PROPERTIES]
+  const hasShapeStyle = RECT_STYLE_PROPERTIES
     .some(property => Object.hasOwn(appearance, property));
   if (hasShapeStyle) {
-    const radius = appearance.cornerRadius ?? 0;
+    const radius = appearance;
     return replaceGraphicItems(
       program,
       id,
@@ -92,6 +90,11 @@ export const rematerializeBarMark = /* @__PURE__ */ action(
       resolved = resolved.rematerializeScale({ id: strokeScaleId });
     }
 
+    const opacityScaleId = required.layer.encoding?.opacity?.scale;
+    if (opacityScaleId !== undefined && args.scales !== false) {
+      resolved = resolved.rematerializeScale({ id: opacityScaleId });
+    }
+
     if (required.materialization === "aggregate") {
       const offsetChannel = resolveBarOffsetChannel(required.layer);
       const offsetScaleId = required.layer.encoding?.[offsetChannel]?.scale;
@@ -104,7 +107,7 @@ export const rematerializeBarMark = /* @__PURE__ */ action(
       ));
     }
 
-    if (required.materialization === BAR_GRAINS.ranged) {
+    if ([BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(required.materialization)) {
       const width = resolved.markConfigs[id]?.barWidth;
       return editRectangles(resolved, id, offsetCategoryRectangles(
         resolved, required.layer, deriveRangedRectangles(required, resolved, width)

package/src/actions/marks/line/actions.js

@@ -18,7 +18,7 @@ import {
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
-import { validateCurveInterpolation } from "../../../grammar/curveCommands.js";
+import { validateCurveInterpolation, validateCardinalTension } from "../../../grammar/curveCommands.js";
 import {
   resolveCoordinateBounds,
   resolveCoordinatePolarFrame
@@ -43,11 +43,11 @@ import {
 const DEFAULT_LINE_STROKE = DEFAULT_COLORS.mark;
 const DEFAULT_LINE_WIDTH = 2;
 const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "stroke", "strokeWidth", "opacity", "curve", "closed",
+  "id", "data", "stroke", "strokeWidth", "opacity", "curve", "tension", "closed",
   ...STROKE_STYLE_PROPERTIES
 ]);
 const EDIT_OPTIONS = Object.freeze([
-  "target", "stroke", "strokeWidth", "opacity", "curve", "closed",
+  "target", "stroke", "strokeWidth", "opacity", "curve", "tension", "closed",
   ...STROKE_STYLE_PROPERTIES
 ]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
@@ -118,6 +118,7 @@ const createLineMark = /* @__PURE__ */ action(
       "Line strokeWidth"
     );
     const curve = validateCurveInterpolation(args.curve ?? "linear");
+    validateCardinalTension(args.tension, curve);
     const closed = Object.hasOwn(args, "closed")
       ? validateClosed(args.closed)
       : false;
@@ -151,6 +152,7 @@ const createLineMark = /* @__PURE__ */ action(
         {
           ...(Object.hasOwn(args, "strokeWidth") ? { strokeWidth } : {}),
           ...(Object.hasOwn(args, "curve") ? { curve } : {}),
+          ...(args.tension === undefined ? {} : { tension: args.tension }),
           ...(Object.hasOwn(args, "closed") ? { closed } : {}),
           ...strokeDetails
         }
@@ -277,7 +279,7 @@ const editLineMark = /* @__PURE__ */ action(
     validateMarkOptions(args, EDIT_OPTIONS, "editLineMark");
     const strokeDetails = requestedStrokeDetails(args, "editLineMark");
     if (!EDIT_OPTIONS.slice(1).some(key => Object.hasOwn(args, key))) {
-      throw new Error("editLineMark requires stroke, strokeWidth, opacity, curve, or closed.");
+      throw new Error("editLineMark requires stroke, strokeWidth, opacity, curve, tension, or closed.");
     }
     const target = Object.hasOwn(args, "target")
       ? validateUserId(args.target, "Line mark id")
@@ -315,6 +317,11 @@ const editLineMark = /* @__PURE__ */ action(
     })) {
       if (Object.hasOwn(args, key)) config[key] = validate(args[key], `Line ${key}`);
     }
+    if (args.curve !== undefined && args.curve !== "cardinal" && args.tension === undefined) {
+      delete config.tension;
+    }
+    if (Object.hasOwn(args, "tension")) config.tension = args.tension;
+    validateCardinalTension(config.tension, config.curve ?? "linear");
     validatePolarLineConfig(layer, config);
     const next = this._withMarkConfig(layer.id, config);
     const materialized = canMaterializeLine(next, layer)

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

@@ -3,6 +3,7 @@ import {
 } from "../../../grammar/lineSeries.js";
 import {
   mapContinuousScaleValues,
+  mapOrdinalPositionValues,
   normalizeStrokeDashPattern
 } from "../../../grammar/scales/index.js";
 import { buildCurvePathCommands } from
@@ -97,9 +98,7 @@ export function resolvePositionedLineMaterialization({
   const radiusScaleId = layer.encoding?.radius?.scale;
   const lineOptions = polar
     ? { thetaDomain: resolvedScales[thetaScaleId].domain }
-    : layer.encoding?.x?.bin === undefined
-      ? undefined
-      : { xBinBoundaries };
+    : { xBinBoundaries, xDomain: resolvedScales[xScaleId].domain };
   const derived = deriveLineSeries(rows, layer, lineOptions);
   const commands = polar
     ? derived.series.map(series => buildPolarLinePathCommands({
@@ -111,7 +110,9 @@ export function resolvePositionedLineMaterialization({
         closed: config.closed ?? false
       }))
     : derived.series.map(series => {
-        const x = mapContinuousScaleValues(
+        const mapX = ["nominal", "ordinal"].includes(layer.encoding.x.fieldType)
+          ? mapOrdinalPositionValues : mapContinuousScaleValues;
+        const x = mapX(
           series.values.map(value => value.x),
           resolvedScales[xScaleId]
         );
@@ -119,9 +120,12 @@ export function resolvePositionedLineMaterialization({
           series.values.map(value => value.y),
           resolvedScales[yScaleId]
         );
+        // A raw singleton retains its data position and series identity, but
+        // contributes no segment. Do not fabricate another observation.
+        if (series.values.length === 1) return [{ op: "M", x: x[0], y: y[0] }];
         return buildCurvePathCommands(
           series.values.map((_, index) => ({ x: x[index], y: y[index] })),
-          config.curve ?? "linear"
+          config.curve ?? "linear", config.tension
         );
       });
   const appearance = appearanceMapper(layer, resolvedScales,

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

@@ -96,7 +96,7 @@ export const editPointMark = /* @__PURE__ */ action(
       }
     }
     if (Object.hasOwn(args, "strokeWidth")) {
-      if (typeof config.stroke !== "string") {
+      if (typeof config.stroke !== "string" && layer.encoding?.stroke?.field === undefined) {
         throw new Error("Point strokeWidth requires an active stroke.");
       }
       config.strokeWidth = validateNonNegativeFinite(

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

@@ -25,7 +25,7 @@ import { resolveMarkGraphicPlacement } from
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import {
-  requestedRectStyleDetails
+  requestedRectStyleDetails, hasRectRadius, RECT_RADIUS_PROPERTIES
 } from "../../../grammar/roundedRect.js";
 import { STROKE_STYLE_PROPERTIES } from
   "../../../grammar/strokeStyle.js";
@@ -33,7 +33,7 @@ import { applyItemMissingPolicy, validateItemMissing } from
   "../../../grammar/itemMissing.js";
 
 const STYLE_OPTIONS = Object.freeze([
-  "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+  "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
   ...STROKE_STYLE_PROPERTIES
 ]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...STYLE_OPTIONS]);
@@ -117,7 +117,7 @@ const rematerializeRectMark = /* @__PURE__ */ action(
     const graphic = this.graphicSpec.objects[id];
     if (layer?.mark?.type !== "rect") throw new Error(`Unknown rect mark "${id}".`);
     const roundedCollection = graphic?.type === "collection" &&
-      Object.hasOwn(this.markConfigs[id] ?? {}, "cornerRadius") &&
+      hasRectRadius(this.markConfigs[id]) &&
       graphic.items?.every(item => ["rect", "path"].includes(item.type));
     if (
       (graphic?.type !== "rect" && !roundedCollection) ||

package/src/actions/marks/remove.js

@@ -163,6 +163,7 @@ export function removeOwnedMark(program, id, partial = false) {
     next = next.editGraphics({ target: id, remove: true });
   }
   return next
+    ._withoutMaterializationConfig(["guides", "legendGroups", id])
     ._withoutMaterializationConfig(["marks", id])
     ._withContext({
       ...(program.context.currentMark === id ? { currentMark: undefined } : {}),
@@ -262,6 +263,7 @@ export const removeMark = /* @__PURE__ */ closedAction(
       if (next.graphicSpec.objects[id] !== undefined) {
         next = next.editGraphics({ target: id, remove: true });
       }
+      next = next._withoutMaterializationConfig(["guides", "legendGroups", id]);
       next = next._withoutMaterializationConfig(["marks", id]);
       next = next._withoutMaterializationConfig(["jitters", id]);
       next = next._withoutMaterializationConfig(["pointPacking", id]);

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

@@ -298,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";
@@ -41,10 +42,6 @@ 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", "missing", ...STYLE_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
@@ -195,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
 ]);
 
@@ -271,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.");
     }
@@ -482,6 +488,12 @@ const editTextMark = /* @__PURE__ */ action(
     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`,

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/primitives/semanticValidation/layer.js

@@ -66,6 +66,10 @@ export function validateLayerSemanticValue(
       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" ||

package/src/actions/regression/create.js

@@ -10,7 +10,7 @@ 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"
 ]);

package/src/actions/regression/edit.js

@@ -21,7 +21,7 @@ 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"
 ]);
@@ -111,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 && args.interval !== false) {
     for (const key of [
-      "degree", "span", "confidenceMethod", "level", "interval"
+      "degree", "span", "robustIterations", "confidenceMethod", "level", "interval"
     ]) {
       if (
         !Object.hasOwn(raw, key) &&

package/src/actions/regression/resolve.js

@@ -1,3 +1,5 @@
+import { requireStringValue as requireRegressionField } from "../../core/validation.js";
+export { requireStringValue as requireRegressionField } from "../../core/validation.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { findLayer } from "../../selectors/layers.js";
 
@@ -8,12 +10,6 @@ export function requireRegressionObject(value, label) {
   return value;
 }
 
-export function requireRegressionField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function findRegressionPoint(program, requested) {
   const eligible = program.semanticSpec.layers.filter(layer =>

package/src/actions/scales/channels.js

@@ -5,6 +5,7 @@ import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
 import { findLayer } from "../../selectors/layers.js";
 import { requireSemanticScale } from "../../selectors/scales.js";
 import { findScaleConsumers } from "./consumers/index.js";
+import { axisScaleBindings } from "../../materialization/coordinateBounds.js";
 
 const DEFINITIONS = Object.freeze({
   editXScale: Object.freeze({
@@ -41,7 +42,7 @@ const DEFINITIONS = Object.freeze({
     channel: "color",
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "unknown"
+      "interpolate", "midpoint", "base", "constant", "unknown"
     ])
   }),
   editStrokeScale: Object.freeze({
@@ -49,7 +50,7 @@ const DEFINITIONS = Object.freeze({
     targetOnly: true,
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "unknown"
+      "interpolate", "midpoint", "base", "constant", "unknown"
     ])
   }),
   editSizeScale: Object.freeze({
@@ -99,9 +100,11 @@ function allConsumers(program) {
 }
 
 function channelScaleIds(program, channel) {
-  return [...new Set(allConsumers(program)
+  return [...new Set([...allConsumers(program)
     .filter(consumer => normalizePositionScaleChannel(consumer.channel) === channel)
-    .map(consumer => consumer.encoding.scale))];
+    .map(consumer => consumer.encoding.scale),
+    ...program.semanticSpec.scales.filter(scale => axisScaleBindings(program, scale.id)
+      .some(binding => binding.channel === channel)).map(scale => scale.id)])];
 }
 
 function requireSingleScale(ids, operation, scope) {
@@ -115,6 +118,8 @@ function requireSingleScale(ids, operation, scope) {
 function validateScaleChannel(program, id, channel, operation) {
   requireSemanticScale(program, id);
   const consumers = findScaleConsumers(program, id);
+  const axes = axisScaleBindings(program, id);
+  if (consumers.length === 0 && axes.length === 1 && axes[0].channel === channel) return id;
   if (consumers.length === 0) {
     throw new Error(`${operation} requires a scale bound to the ${channel} channel.`);
   }