ggaction 0.0.21 → 0.0.23

package/src/actions/data/shared.js

@@ -1,3 +1,4 @@
+import { datasetInputReferences, rebindTransformDatasetInputs } from "../../core/datasetReferences.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
@@ -12,6 +13,15 @@ import {
   validateRowsAgainstSchema
 } from "../../grammar/datasetSchema.js";
 
+export function resolveDatasetTransformInputs(program, transform) {
+  const replacements = new Map();
+  for (const reference of datasetInputReferences({ transform: [transform] })) {
+    const input = resolveDatasetReference(program, reference.id, "Lookup dataset");
+    if (input.id !== reference.id) replacements.set(reference.id, input.id);
+  }
+  return rebindTransformDatasetInputs(transform, replacements);
+}
+
 export const MATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
 export function requireDerivedDataset(program, id, type) {

package/src/actions/data/timeUnit.js

@@ -6,7 +6,7 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "field", "unit", "as", "temporalUnit", "timeZone",
-  "weekStartsOn", "weekRule"
+  "weekStartsOn", "weekRule", "missing"
 ]);
 
 export const materializeTimeUnitData = /* @__PURE__ */ derivedMaterializer(

package/src/actions/distributions/revision.js

@@ -321,8 +321,10 @@ function rebindAxisOwner(program, channel, axisId, {
     });
   }
   const scale = next.resolvedScales[nextScale];
+  const previousTicks = next.guideConfigs.axis?.[axisId]?.ticks;
   const ticks = normalizeTickConfig(
-    next.guideConfigs.axis?.[axisId]?.ticks,
+    previousTitle !== nextTitle && previousTicks?.mode === "values"
+      ? { ...previousTicks, inferredValues: true } : previousTicks,
     scale
   );
   if (ticks !== undefined) {

package/src/actions/encodings/angle.js

@@ -1,3 +1,4 @@
+import { APPEARANCE_MARK_TYPES } from "../../core/vocabulary.js";
 import { action } from "../../core/action.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import {
@@ -34,7 +35,7 @@ export const encodeAngle = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "tick"],
+      APPEARANCE_MARK_TYPES.encodeAngle,
       "point or Tick mark"
     );
     if (hasValue && !Number.isFinite(args.value)) {

package/src/actions/encodings/appearance.js

@@ -1,3 +1,5 @@
+import { APPEARANCE_MARK_TYPES } from "../../core/vocabulary.js";
+import { removeEncoding } from "./remove.js";
 import { canMaterializeBar } from "../../materialization/marks/index.js";
 import { action } from "../../core/action.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
@@ -16,6 +18,7 @@ import {
 } from "../../selectors/layers.js";
 import {
   applyEncodingScale,
+  releaseDetachedEncodingScale,
   applyDetachedScaleRematerialization,
   clearMarkGraphic,
   rematerializeEncoding,
@@ -38,7 +41,7 @@ function encodeAppearanceField(program, channel, args, operation) {
   const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
-    ["point"],
+    APPEARANCE_MARK_TYPES[operation],
     "point mark"
   );
   const fieldTypes = channel === "shape" ? ["nominal"] : ["quantitative", "nominal", "ordinal"];
@@ -47,9 +50,7 @@ function encodeAppearanceField(program, channel, args, operation) {
   if (!fieldTypes.includes(fieldType)) {
     throw new Error(`${operation} requires a ${fieldTypes.join(" or ")} field.`);
   }
-  if (channel === "size" && program.markConfigs[target]?.radius !== undefined) {
-    throw new Error("encodeSize cannot be combined with a constant radius.");
-  }
+
   const previous = layer.encoding?.[channel];
   const requestedScale = resolveReassignmentScaleOptions(
     previous,
@@ -65,7 +66,12 @@ function encodeAppearanceField(program, channel, args, operation) {
     allowUnknown: Object.hasOwn(scale, "unknown")
   });
 
-  let next = setEncodingProperties(program, target, channel, {
+  const baseline = channel === "size"
+    ? program._withoutMaterializationConfig(["marks", target, "radius"])
+    : program;
+  const prepared = channel === "size" && program.markConfigs[target]?.radius !== undefined
+    ? releaseDetachedEncodingScale(baseline, scale.id) : baseline;
+  let next = setEncodingProperties(prepared, target, channel, {
     field: args.field,
     fieldType,
     scale: scale.id
@@ -146,9 +152,26 @@ const removePointRadius = /* @__PURE__ */ action(
 const encodeSize = /* @__PURE__ */ action(
   {
     op: "encodeSize",
-    description: "Encode a field as equal-area point size."
+    description: "Assign constant or field-driven equal-area point size."
   },
   function (args = {}) {
+    validateOptions(args, [...FIELD_OPTIONS, "value"], "encodeSize");
+    const hasValue = Object.hasOwn(args, "value");
+    if (hasValue === Object.hasOwn(args, "field")) {
+      throw new Error("encodeSize requires exactly one of value or field.");
+    }
+    if (hasValue) {
+      if (args.fieldType !== undefined || args.scale !== undefined) {
+        throw new Error("Constant size does not accept fieldType or scale.");
+      }
+      if (!Number.isFinite(args.value) || args.value < 0) {
+        throw new RangeError("encodeSize requires a non-negative finite area.");
+      }
+      const { id: target, layer } = resolveTarget(this, args.target, APPEARANCE_MARK_TYPES.encodeSize, "point mark");
+      const next = layer.encoding?.size === undefined ? this
+        : removeEncoding.call(this, { target, channel: "size" });
+      return next.encodeRadius({ target, value: Math.sqrt(args.value / Math.PI) });
+    }
     return encodeAppearanceField(this, "size", args, "encodeSize");
   }
 );
@@ -207,8 +230,8 @@ const encodeOpacity = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "rule", "line", "bar"],
-      "point, rule, line or bar mark"
+      APPEARANCE_MARK_TYPES.encodeOpacity,
+      "point, rule, line, bar or rect mark"
     );
     if (hasValue) {
       validateOpacityValue(args.value, "encodeOpacity");
@@ -221,7 +244,7 @@ const encodeOpacity = /* @__PURE__ */ action(
         .clearOpacityEncoding({ target })
         ._withoutMaterializationConfig(["marks", target, "opacity"])
         ._withMarkConfig(target, { ...config, opacity: args.value });
-      if (layer.mark.type === "line") {
+      if (["line", "rect"].includes(layer.mark.type)) {
         return rematerializeEncoding(next, target, "opacity", undefined, layer);
       }
       if (layer.mark.type === "bar") {
@@ -245,13 +268,13 @@ const encodeOpacity = /* @__PURE__ */ action(
       args.scale ?? {}
     );
     const scale = resolveOpacityScaleDefinition(this, requestedScale);
-    if (layer.mark.type === "line") {
+    if (["line", "rect"].includes(layer.mark.type)) {
       if (Object.hasOwn(scale, "unknown")) {
-        throw new Error("Line opacity does not support unknown fallback.");
+        throw new Error("Line and Rect opacity do not support unknown fallback.");
       }
       validatePathSeriesAppearance(dataset.values, {
         ...layer, encoding: { ...layer.encoding, opacity: { field: args.field, fieldType } }
-      });
+      }, this.semanticSpec.scales);
     }
     readScaleField(dataset.values, args.field, fieldType, {
       allowUnknown: Object.hasOwn(scale, "unknown")
@@ -259,7 +282,9 @@ const encodeOpacity = /* @__PURE__ */ action(
     const { opacity, ...config } = this.markConfigs[target] ?? {};
     void opacity;
     let next = setEncodingProperties(
-      withoutConstantOpacity(this, target),
+      this.markConfigs[target]?.opacity !== undefined || this.markConfigs[target]?.barAppearance?.opacity !== undefined
+        ? releaseDetachedEncodingScale(withoutConstantOpacity(this, target), scale.id)
+        : withoutConstantOpacity(this, target),
       target,
       "opacity",
       { field: args.field, fieldType, scale: scale.id }

package/src/actions/encodings/channels.js

@@ -24,13 +24,14 @@ import {
 import { buildMaterializationPlan } from "../../materialization/planner.js";
 import { hasMaterializedLegend } from "../../materialization/legends.js";
 import { rebindPositionGuides } from "./shared.js";
-import { withoutPreviewLayerEncodings } from
+import { withoutPreviewLayerEncodings, withPreviewLayerEncodings } from
   "../primitives/semanticAction.js";
+import { isIndependentText, normalizeTextOffsetAssignment } from "../../grammar/text.js";
 
 export const ENCODING_CHANNEL_ORDER = Object.freeze([
   "x", "y", "x2", "y2", "theta", "r", "xOffset", "yOffset",
   "group", "pathOrder", "color", "stroke", "size", "shape",
-  "opacity", "strokeWidth", "strokeDash", "angle", "text"
+  "opacity", "strokeWidth", "strokeDash", "angle", "text", "dx", "dy"
 ]);
 
 const CHANNEL_METHODS = Object.freeze({
@@ -52,7 +53,9 @@ const CHANNEL_METHODS = Object.freeze({
   strokeWidth: "encodeStrokeWidth",
   strokeDash: "encodeStrokeDash",
   angle: "encodeAngle",
-  text: "encodeText"
+  text: "encodeText",
+  dx: "encodeDx",
+  dy: "encodeDy"
 });
 
 const FORBIDDEN_PAYLOAD_KEYS = Object.freeze(["target", "coordinate", "id"]);
@@ -340,6 +343,14 @@ function applyEncodingDraft(program, target, requests) {
     target,
     requests
   );
+  if (isIndependentText(findLayer(draft, target))) {
+    const offsets = requests.filter(request => ["dx", "dy"].includes(request.channel));
+    if (offsets.length) {
+      draft = withPreviewLayerEncodings(draft, { id: target, encodings: Object.fromEntries(
+        offsets.map(({ channel, payload }) => [channel, normalizeTextOffsetAssignment(payload, channel)])
+      ) });
+    }
+  }
   for (const { channel, payload } of requests) {
     const focusedAction = draft[CHANNEL_METHODS[channel]];
     draft = invokeWrappedActionImplementation(

package/src/actions/encodings/color/continuous.js

@@ -5,13 +5,14 @@ import {
   resolveTemporalUnit
 } from "../../../grammar/scales/index.js";
 import { validateContinuousColorConsumer } from "../../../grammar/scales/colorConsumers.js";
-import { validatePathSeriesAppearance } from "../../../grammar/pathSeries.js";
+import { validatePathGroupAppearance } from "../../../materialization/marks/grouping.js";
+import { readArcColorValues } from "../../../grammar/arcs.js";
 import { validateAggregateFieldValues } from "../../../grammar/aggregate.js";
 import {
   resolveQuantitativeColorScaleDefinition
 } from "../../scales/definitions.js";
 import {
-  resolveReassignmentScaleOptions,
+  releaseDetachedEncodingScale,
   resolveTarget
 } from "../shared.js";
 import {
@@ -23,7 +24,9 @@ import {
 } from "../../../materialization/encodings.js";
 import {
   assertNoConstantColor,
-  resolveColorScaleOptions
+  withoutConstantColor,
+  resolveColorScaleOptions,
+  resolveColorReassignmentScaleOptions
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
@@ -40,14 +43,15 @@ export function encodeContinuousColor(program, args) {
   const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
-    ["point", "bar", "rect", "text", "area"],
+    ["point", "line", "bar", "rect", "text", "area", "arc", "tick"],
     "continuous color mark"
   );
   const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
-  assertNoConstantColor(program, layer);
+  const baseline = withoutConstantColor(program, layer);
+  assertNoConstantColor(baseline, layer);
   const temporalUnit = resolveTemporalUnit(args, args.fieldType, layer.encoding?.color);
-  const requestedScale = resolveReassignmentScaleOptions(
-    layer.encoding?.color,
+  const requestedScale = resolveColorReassignmentScaleOptions(
+    program, layer, "color", args.fieldType,
     resolveColorScaleOptions(args)
   );
   const scale = resolveQuantitativeColorScaleDefinition(
@@ -56,9 +60,15 @@ export function encodeContinuousColor(program, args) {
     requestedScale
   );
   const aggregate = validateContinuousColorConsumer(layer, args, scale, { inferAggregate: true });
-  if (layer.mark.type === "area") {
-    validatePathSeriesAppearance(dataset.values, {
+  if (["line", "area"].includes(layer.mark.type)) {
+    validatePathGroupAppearance(program, {
       ...layer, encoding: { ...layer.encoding, color: { field: args.field, fieldType: args.fieldType } }
+    }, dataset);
+  }
+  if (layer.mark.type === "arc") {
+    readArcColorValues(dataset.values, {
+      ...layer, encoding: { ...layer.encoding,
+        color: { field: args.field, fieldType: args.fieldType, temporalUnit } }
     });
   }
   if (aggregate !== undefined) validateAggregateFieldValues(dataset.values, args.field, args.fieldType);
@@ -75,7 +85,8 @@ export function encodeContinuousColor(program, args) {
   } else {
     readQuantitativeField(dataset.values, args.field);
   }
-  const next = applyTemporalUnit(program, target, "color", temporalUnit, layer.encoding?.color)
+  const prepared = baseline === program ? baseline : releaseDetachedEncodingScale(baseline, scale.id);
+  let next = applyTemporalUnit(prepared, target, "color", temporalUnit, layer.encoding?.color)
     .editSemantic({
       property: `layer[${target}].encoding.color.field`,
       value: args.field
@@ -88,6 +99,11 @@ export function encodeContinuousColor(program, args) {
       property: `layer[${target}].encoding.color.scale`,
       value: scale.id
     });
+  if (layer.mark.type === "tick") {
+    const config = { ...next.markConfigs[target] };
+    delete config.stroke;
+    next = next._withMarkConfig(target, config);
+  }
   const encoded = aggregate === undefined
     ? next
     : next.editSemantic({

package/src/actions/encodings/color/index.js

@@ -1,3 +1,7 @@
+import { findRaincloudParent } from "../../../selectors/raincloud.js";
+import { APPEARANCE_MARK_TYPES } from "../../../core/vocabulary.js";
+import { removeEncoding } from "../remove.js";
+import { validateNonEmptyString } from "../../../core/validation.js";
 import { inferSeriesGroup } from "../shared.js";
 import { action } from "../../../core/action.js";
 import {
@@ -12,7 +16,7 @@ import {
 import { resolveColorScaleDefinition } from "../../scales/definitions.js";
 import {
   applyEncodingScale,
-  resolveReassignmentScaleOptions,
+  releaseDetachedEncodingScale,
   resolveTarget,
   validateOptions
 } from "../shared.js";
@@ -26,15 +30,18 @@ import {
 import { findUpstreamTransform } from
   "../../../materialization/dataProvenance.js";
 import { validatePathSeriesAppearance } from "../../../grammar/pathSeries.js";
+import { readCategoricalLineColor, validateCategoricalColorConsumer } from "../../../grammar/scales/colorConsumers.js";
 import { encodeContinuousColor } from "./continuous.js";
 import {
   applyColorLayoutCompanion
 } from "./layout.js";
 import {
   assertNoConstantColor,
+  withoutConstantColor,
   COLOR_ENCODING_OPTIONS,
   resolveColorLayout,
-  resolveColorScaleOptions
+  resolveColorScaleOptions,
+  resolveColorReassignmentScaleOptions
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
@@ -44,10 +51,32 @@ import { applyRequestedItemMissingPolicy } from
 const encodeColor = /* @__PURE__ */ action(
   {
     op: "encodeColor",
-    description: "Encode a field as graphical color."
+    description: "Assign constant or field-driven graphical color."
   },
   function (args = {}) {
     validateOptions(args, COLOR_ENCODING_OPTIONS, "encodeColor");
+    const hasValue = Object.hasOwn(args, "value");
+    if (hasValue === Object.hasOwn(args, "field")) {
+      throw new Error("encodeColor requires exactly one of value or field.");
+    }
+    const raincloud = findRaincloudParent(this, args.target);
+    if (raincloud !== undefined) {
+      const { target, ...color } = args;
+      return this.editRaincloudPlot({ target, color });
+    }
+    if (hasValue) {
+      if (COLOR_ENCODING_OPTIONS.some(key => !["target", "value"].includes(key) && args[key] !== undefined)) {
+        throw new Error("Constant color accepts only value and target.");
+      }
+      const value = validateNonEmptyString(args.value, "Color value");
+      const { id: target, layer } = resolveTarget(this, args.target,
+        APPEARANCE_MARK_TYPES.encodeColor, "color mark");
+      const next = layer.encoding?.color === undefined ? this
+        : removeEncoding.call(this, { target, channel: "color" });
+      const method = { point: "editPointMark", line: "editLineMark", bar: "editBarMark",
+        area: "editAreaMark", arc: "editArcMark", rect: "editRectMark", text: "editTextMark" }[layer.mark.type];
+      return next[method]({ target, [layer.mark.type === "line" ? "stroke" : "fill"]: value });
+    }
     const requestedFieldType = args.fieldType ?? "nominal";
     if (!["nominal", "ordinal"].includes(requestedFieldType)) {
       return encodeContinuousColor(this, {
@@ -63,11 +92,12 @@ const encodeColor = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "line", "bar", "area", "arc", "rect", "text"],
+      APPEARANCE_MARK_TYPES.encodeColor,
       "color mark"
     );
     const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
-    assertNoConstantColor(this, layer);
+    const baseline = withoutConstantColor(this, layer);
+    assertNoConstantColor(baseline, layer);
     const densityTransform = dataset.transform?.length === 1 &&
       dataset.transform[0].type === "density"
       ? dataset.transform[0]
@@ -86,7 +116,7 @@ const encodeColor = /* @__PURE__ */ action(
         "Bar color encoding requires a complete histogram encoding or a complete ordinal aggregate encoding."
       );
     }
-    const layout = resolveColorLayout(layer, args.layout, barGrain);
+    const layout = resolveColorLayout(layer, args.layout, barGrain, args.field);
     const createsCenterGroup = layer.mark.type === "area" &&
       layout === "center" && layer.encoding?.group === undefined;
     const ordinaryGroup = layer.mark.type === "area" && !createsCenterGroup &&
@@ -104,22 +134,21 @@ const encodeColor = /* @__PURE__ */ action(
         "Area color encoding must match an existing group encoding."
       );
     }
-    if (layer.mark.type === "line" || ordinaryGroup) {
-      validatePathSeriesAppearance(dataset.values, {
-        ...layer, encoding: { ...layer.encoding, color: { field: args.field, fieldType } }
-      });
-    }
-    const requestedScale = resolveReassignmentScaleOptions(
-      layer.encoding?.color,
+    const requestedScale = resolveColorReassignmentScaleOptions(
+      this, layer, "color", fieldType,
       resolveColorScaleOptions(args)
     );
     const scale = resolveColorScaleDefinition(this, requestedScale);
-    if (Object.hasOwn(scale, "unknown") && layer.mark.type !== "point") {
-      throw new Error(
-        "Categorical color scale unknown currently requires a row-owned point mark."
-      );
+    const color = { field: args.field, fieldType, scale: scale.id };
+    const lineFallback = validateCategoricalColorConsumer(layer, color, scale);
+    if (layer.mark.type === "line" || ordinaryGroup) {
+      validatePathSeriesAppearance(dataset.values, {
+        ...layer, encoding: { ...layer.encoding, color }
+      }, [...this.semanticSpec.scales.filter(item => item.id !== scale.id), scale]);
     }
-    if (layer.mark.type === "rect") {
+    if (lineFallback) {
+      readCategoricalLineColor(dataset.values, args.field);
+    } else if (layer.mark.type === "rect") {
       readScaleField(dataset.values, args.field, fieldType, {
         allowUnknown: true
       });
@@ -131,9 +160,10 @@ const encodeColor = /* @__PURE__ */ action(
       readNominalField(dataset.values, args.field);
     }
 
+    const prepared = baseline === this ? baseline : releaseDetachedEncodingScale(baseline, scale.id);
     let next = layer.mark.type === "bar" || createsCenterGroup
-      ? inferSeriesGroup(this, layer, args.field, "color")
-      : this;
+      ? inferSeriesGroup(prepared, layer, args.field, "color")
+      : prepared;
     next = applyTemporalUnit(next, target, "color", undefined, layer.encoding?.color).editSemantic({
       property: `layer[${target}].encoding.color.field`,
       value: args.field

package/src/actions/encodings/color/policy.js

@@ -1,11 +1,14 @@
 import {
   BAR_GRAINS,
-  inferBarColorLayout
+  inferBarColorLayout,
+  resolveBarChannels
 } from "../../../grammar/bars/policy.js";
 import { validateColorLayout } from "../../../grammar/seriesLayout.js";
+import { findScaleConsumers } from "../../scales/consumers/common.js";
+import { resolveReassignmentScaleOptions } from "../shared.js";
 
 export const COLOR_ENCODING_OPTIONS = Object.freeze([
-  "field", "target", "fieldType", "scale", "palette", "layout", "aggregate", "temporalUnit"
+  "value", "field", "target", "fieldType", "scale", "palette", "layout", "aggregate", "temporalUnit"
 ]);
 
 export function resolveColorScaleOptions(args) {
@@ -19,6 +22,50 @@ export function resolveColorScaleOptions(args) {
   return { ...options, palette: args.palette };
 }
 
+export function resolveColorReassignmentScaleOptions(
+  program, layer, channel, fieldType, options = {}
+) {
+  const previous = layer.encoding?.[channel];
+  const requested = resolveReassignmentScaleOptions(previous, options);
+  if (options.id !== undefined || previous?.scale === undefined) return requested;
+  const categorical = type => ["nominal", "ordinal"].includes(type);
+  if (categorical(previous.fieldType) === categorical(fieldType)) return requested;
+  const otherConsumer = consumer => consumer.layer.id !== layer.id ||
+    consumer.channel !== channel;
+  if (!findScaleConsumers(program, previous.scale).some(otherConsumer)) return requested;
+  // Re-encoding one mark must not change the scale family of its siblings.
+  // Explicit scale IDs still opt into normal shared-resource validation.
+  const id = `${layer.id}-${channel}-${fieldType}`;
+  if (findScaleConsumers(program, id).some(otherConsumer)) {
+    throw new Error(`Color reassignment requires scale.id because "${id}" has other consumers.`);
+  }
+  return { ...options, id };
+}
+
+export function withoutConstantColor(program, layer) {
+  const previous = program.markConfigs[layer.id];
+  const explicit = { point: previous?.fill !== undefined, line: previous?.stroke !== undefined,
+    bar: previous?.barAppearance?.fill !== undefined, area: previous?.errorBand?.fill !== undefined,
+    arc: previous?.fill !== undefined, rect: previous?.fillExplicit === true,
+    text: previous?.fillExplicit === true }[layer.mark.type];
+  if (!explicit) return program;
+  const config = { ...previous };
+  if (layer.mark.type === "bar") {
+    config.barAppearance = { ...config.barAppearance };
+    delete config.barAppearance.fill;
+  } else if (layer.mark.type === "line") {
+    delete config.stroke;
+  } else {
+    if (["point", "arc"].includes(layer.mark.type)) delete config.fill;
+    if (["rect", "text"].includes(layer.mark.type)) config.fillExplicit = false;
+    if (config.errorBand !== undefined) {
+      config.errorBand = { ...config.errorBand };
+      delete config.errorBand.fill;
+    }
+  }
+  return program._withMarkConfig(layer.id, config);
+}
+
 export function assertNoConstantColor(program, layer) {
   if (layer.mark.type === "text" && layer.source !== undefined) {
     throw new Error("Source-owned text uses inheritColor or constant fill; field color requires row-backed text.");
@@ -47,7 +94,13 @@ export function isRangedArea(layer) {
   );
 }
 
-export function resolveColorLayout(layer, requested, barGrain) {
+export function resolveColorLayout(layer, requested, barGrain, field) {
+  const category = layer.encoding?.[resolveBarChannels(layer)?.category];
+  // Coloring the category does not introduce another partition. An explicit
+  // group or a stored/requested layout still owns series placement.
+  const categoryColorOnly = barGrain === BAR_GRAINS.aggregate &&
+    ["nominal", "ordinal"].includes(category?.fieldType) &&
+    category.field === field && layer.encoding?.group === undefined;
   const existing = layer.encoding?.color === undefined
     ? undefined
     : layer.encoding.color.layout ?? (
@@ -62,7 +115,7 @@ export function resolveColorLayout(layer, requested, barGrain) {
     layer.mark.type === "bar"
       ? barGrain === BAR_GRAINS.histogram
         ? "stack"
-        : [BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(barGrain) ? "overlay" : "group"
+        : [BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(barGrain) || categoryColorOnly ? "overlay" : "group"
       : layer.mark.type === "area"
         ? "overlay"
         : undefined

package/src/actions/encodings/parallel.js

@@ -1,4 +1,6 @@
 import { closedAction } from "../../core/action.js";
+import { validateMarkClipCoordinate } from "../../selectors/markClip.js";
+import { validateLineMissingScope } from "../../grammar/lineMissing.js";
 
 import {
   normalizeParallelDimensions,
@@ -31,6 +33,7 @@ export const encodeParallelCoordinates = /* @__PURE__ */ closedAction(
       ["line"],
       "line mark"
     );
+    validateLineMissingScope({ ...layer, encoding: { ...layer.encoding, parallel: {} } });
     if (
       ["x", "y", "theta", "radius"].some(
         channel => layer.encoding?.[channel] !== undefined
@@ -45,6 +48,7 @@ export const encodeParallelCoordinates = /* @__PURE__ */ closedAction(
       layer,
       operation: "encodeParallelCoordinates"
     });
+    validateMarkClipCoordinate(this, layer, this.markConfigs[target]?.clip, "parallel");
     const dimensions = normalizeParallelDimensions(
       dataset.values,
       args.dimensions,

package/src/actions/encodings/position/policies/bar.js

@@ -50,6 +50,9 @@ function resolveBarChannelPolicy({
     const weight = args.weight === undefined
       ? undefined
       : normalizeStatisticalWeight(args.weight, "Histogram weight");
+    if (weight !== undefined && opposite?.aggregate !== undefined && opposite.aggregate !== "count") {
+      throw new Error("Binned bar weights require count aggregation.");
+    }
     return { bin, aggregate, stack, weight };
   } else if (
     fieldType === "quantitative" &&
@@ -59,14 +62,15 @@ function resolveBarChannelPolicy({
     if (args.bin !== undefined) {
       throw new Error("Histogram bar y encoding does not support bin.");
     }
-    if (field !== xEncoding.field) {
-      throw new Error("Bar y field must match the binned x field.");
+    aggregate = validateAggregate(args.aggregate ?? "count");
+    validateAggregateFieldType(aggregate, fieldType);
+    if (aggregate === "count" && field !== xEncoding.field) {
+      throw new Error("Count bar y field must match the binned x field.");
     }
-    aggregate = args.aggregate ?? "count";
-    stack = Object.hasOwn(args, "stack") ? args.stack : "zero";
-    if (aggregate !== "count") {
-      throw new Error('Histogram bar y aggregate must be "count".');
+    if (aggregate !== "count" && xEncoding.weight !== undefined) {
+      throw new Error("Binned bar weights require count aggregation.");
     }
+    stack = Object.hasOwn(args, "stack") ? args.stack : aggregate === "count" ? "zero" : null;
     stack = validateStack(stack, "Histogram bar y encoding");
     if (stack === "center") {
       throw new Error("Centered bars are not supported.");