ggaction 0.0.17 → 0.0.19

package/src/actions/distributions/revision.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { DEFAULT_TICK_COUNT } from "../guides/tickValues.js";
 import { findLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
@@ -296,39 +297,44 @@ export function clearCartesianPositions(program, id) {
   return next;
 }
 
-function rebindAxis(program, channel, {
+function rebindAxis(program, channel, options) {
+  return cartesianAxisOwners(program).filter(owner => owner.channel === channel)
+    .reduce((next, owner) => rebindAxisOwner(next, channel, owner.id, options), program);
+}
+
+function rebindAxisOwner(program, channel, axisId, {
   previousScale,
   nextScale,
   previousTitle,
   nextTitle
 }) {
-  const semantic = program.semanticSpec.guides.axis?.[channel];
+  const semantic = program.semanticSpec.guides.axis?.[axisId];
   if (semantic?.scale !== previousScale) return program;
   let next = program.editSemantic({
-    property: `guide.axis.${channel}.scale`,
+    property: `guide.axis.${axisId}.scale`,
     value: nextScale
   });
   if (semantic.title === previousTitle) {
     next = next.editSemantic({
-      property: `guide.axis.${channel}.title`,
+      property: `guide.axis.${axisId}.title`,
       value: nextTitle
     });
   }
   const scale = next.resolvedScales[nextScale];
   const ticks = normalizeTickConfig(
-    next.guideConfigs.axis?.[channel]?.ticks,
+    next.guideConfigs.axis?.[axisId]?.ticks,
     scale
   );
   if (ticks !== undefined) {
-    next = next._withGuideConfig(channel, "ticks", {
+    next = next._withGuideConfig(axisId, "ticks", {
       ...ticks,
       scale: nextScale
     });
   }
-  const labels = next.guideConfigs.axis?.[channel]?.labels;
+  const labels = next.guideConfigs.axis?.[axisId]?.labels;
   if (labels !== undefined) {
-    const tickConfig = next.guideConfigs.axis[channel].ticks;
-    next = next._withGuideConfig(channel, "labels", {
+    const tickConfig = next.guideConfigs.axis[axisId].ticks;
+    next = next._withGuideConfig(axisId, "labels", {
       ...labels,
       scale: nextScale,
       mode: tickConfig.mode,
@@ -338,30 +344,30 @@ function rebindAxis(program, channel, {
         : { count: tickConfig.count })
     });
     if (tickConfig.mode === "values") {
-      const config = next.guideConfigs.axis[channel].labels;
+      const config = next.guideConfigs.axis[axisId].labels;
       if (Object.hasOwn(config, "count")) {
         const { count: _count, ...withoutCount } = config;
-        next = next._withGuideConfig(channel, "labels", withoutCount);
+        next = next._withGuideConfig(axisId, "labels", withoutCount);
       }
     } else {
-      const config = next.guideConfigs.axis[channel].labels;
+      const config = next.guideConfigs.axis[axisId].labels;
       if (Object.hasOwn(config, "values")) {
         const { values: _values, ...withoutValues } = config;
-        next = next._withGuideConfig(channel, "labels", withoutValues);
+        next = next._withGuideConfig(axisId, "labels", withoutValues);
       }
     }
   }
-  const title = next.guideConfigs.axis?.[channel]?.title;
+  const title = next.guideConfigs.axis?.[axisId]?.title;
   if (title !== undefined) {
-    next = next._withGuideConfig(channel, "title", {
+    next = next._withGuideConfig(axisId, "title", {
       ...title,
       scale: nextScale
     });
   }
   const methods = axisMethods(channel);
-  if (ticks !== undefined) next = next[methods.ticks]();
-  if (labels !== undefined) next = next[methods.labels]();
-  if (title !== undefined) next = next[methods.title]();
+  if (ticks !== undefined) next = next[methods.ticks](axisId === channel ? undefined : axisTargetArgs(axisId, channel));
+  if (labels !== undefined) next = next[methods.labels](axisId === channel ? undefined : axisTargetArgs(axisId, channel));
+  if (title !== undefined) next = next[methods.title](axisId === channel ? undefined : axisTargetArgs(axisId, channel));
   return next;
 }
 

package/src/actions/encodings/appearance.js

@@ -1,9 +1,8 @@
+import { canMaterializeBar } from "../../materialization/marks/index.js";
 import { action } from "../../core/action.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
 import {
-  readNominalField,
-  readQuantitativeField,
   readScaleField,
   validateOpacityValue
 } from "../../grammar/scales/index.js";
@@ -42,11 +41,11 @@ function encodeAppearanceField(program, channel, args, operation) {
     ["point"],
     "point mark"
   );
-  const expectedFieldType = channel === "shape" ? "nominal" : "quantitative";
+  const fieldTypes = channel === "shape" ? ["nominal"] : ["quantitative", "nominal", "ordinal"];
   const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
-  const fieldType = args.fieldType ?? expectedFieldType;
-  if (fieldType !== expectedFieldType) {
-    throw new Error(`${operation} requires a ${expectedFieldType} field.`);
+  const fieldType = args.fieldType ?? fieldTypes[0];
+  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.");
@@ -59,17 +58,12 @@ function encodeAppearanceField(program, channel, args, operation) {
   const scale = resolveAppearanceScaleDefinition(
     program,
     channel,
-    requestedScale
+    requestedScale,
+    fieldType
   );
-  if (Object.hasOwn(scale, "unknown")) {
-    readScaleField(dataset.values, args.field, fieldType, {
-      allowUnknown: true
-    });
-  } else if (channel === "shape") {
-    readNominalField(dataset.values, args.field);
-  } else {
-    readQuantitativeField(dataset.values, args.field);
-  }
+  readScaleField(dataset.values, args.field, fieldType, {
+    allowUnknown: Object.hasOwn(scale, "unknown")
+  });
 
   let next = setEncodingProperties(program, target, channel, {
     field: args.field,
@@ -152,7 +146,7 @@ const removePointRadius = /* @__PURE__ */ action(
 const encodeSize = /* @__PURE__ */ action(
   {
     op: "encodeSize",
-    description: "Encode a quantitative field as equal-area point size."
+    description: "Encode a field as equal-area point size."
   },
   function (args = {}) {
     return encodeAppearanceField(this, "size", args, "encodeSize");
@@ -184,6 +178,17 @@ const clearOpacityEncoding = /* @__PURE__ */ action(
   }
 );
 
+function withoutConstantOpacity(program, target) {
+  const { opacity, ...config } = program.markConfigs[target] ?? {};
+  void opacity;
+  if (config.barAppearance?.opacity !== undefined) {
+    const { opacity: barOpacity, ...appearance } = config.barAppearance;
+    void barOpacity;
+    config.barAppearance = appearance;
+  }
+  return program._withMarkConfig(target, config);
+}
+
 const encodeOpacity = /* @__PURE__ */ action(
   {
     op: "encodeOpacity",
@@ -202,14 +207,13 @@ const encodeOpacity = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "rule", "line"],
-      "point, rule or line mark"
+      ["point", "rule", "line", "bar"],
+      "point, rule, line or bar mark"
     );
     if (hasValue) {
       validateOpacityValue(args.value, "encodeOpacity");
       assertEncodingSelectionCompatibility(this, target, ["opacity"]);
-      const { opacity, ...config } = this.markConfigs[target] ?? {};
-      void opacity;
+      const config = withoutConstantOpacity(this, target).markConfigs[target];
       const withoutLegend = this.guideConfigs.legend?.opacity?.target === target
         ? this.removeOpacityLegend()
         : this;
@@ -220,6 +224,11 @@ const encodeOpacity = /* @__PURE__ */ action(
       if (layer.mark.type === "line") {
         return rematerializeEncoding(next, target, "opacity", undefined, layer);
       }
+      if (layer.mark.type === "bar") {
+        return canMaterializeBar(next, findLayer(next, target))
+          ? applyDetachedScaleRematerialization(next.rematerializeBarMark({ id: target }), [layer])
+          : next;
+      }
       const materialized = layer.mark.type === "rule"
         ? next.rematerializeRuleMark({ id: target })
         : next.rematerializePointMark({ id: target });
@@ -244,17 +253,13 @@ const encodeOpacity = /* @__PURE__ */ action(
         ...layer, encoding: { ...layer.encoding, opacity: { field: args.field, fieldType } }
       });
     }
-    if (Object.hasOwn(scale, "unknown")) {
-      readScaleField(dataset.values, args.field, fieldType, {
-        allowUnknown: true
-      });
-    } else {
-      readQuantitativeField(dataset.values, args.field);
-    }
+    readScaleField(dataset.values, args.field, fieldType, {
+      allowUnknown: Object.hasOwn(scale, "unknown")
+    });
     const { opacity, ...config } = this.markConfigs[target] ?? {};
     void opacity;
     let next = setEncodingProperties(
-      this._withoutMaterializationConfig(["marks", target, "opacity"]),
+      withoutConstantOpacity(this, target),
       target,
       "opacity",
       { field: args.field, fieldType, scale: scale.id }
@@ -262,6 +267,9 @@ const encodeOpacity = /* @__PURE__ */ action(
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
+    if (layer.mark.type === "bar" && !canMaterializeBar(next, findLayer(next, target))) {
+      return next.rematerializeScale({ id: scale.id });
+    }
     return rematerializeEncoding(next, target, "opacity", scale.id, layer);
   }
 );

package/src/actions/encodings/barWidth.js

@@ -4,11 +4,33 @@ import {
   BAR_GRAINS,
   resolveBarColorLayout,
   resolveBarOffsetChannel,
+  resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
 import { normalizeBarWidth } from "../../grammar/bars/geometry.js";
+import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import {
+  getScaleConsumerMarkSteps,
+  getSourceDependentMarkSteps
+} from "../../materialization/marks/index.js";
+
+function rematerializeWidth(program, target, layer, width) {
+  const next = program._withMarkConfig(target, {
+    ...program.markConfigs[target], barWidth: width
+  }).rematerializeBarMark({ id: target });
+  const category = resolveBarChannels(layer)?.category;
+  const encoding = layer.encoding?.[category];
+  if (encoding?.fieldType !== "temporal") return next;
+  const marks = getScaleConsumerMarkSteps(next, [encoding.scale])
+    .filter(step => step.args.id !== target);
+  return applyMaterializationPlan(next, [
+    ...marks,
+    ...[target, ...marks.map(step => step.args.id)]
+      .flatMap(id => getSourceDependentMarkSteps(next, id))
+  ]);
+}
 
-const OPTIONS = Object.freeze(["band", "pixels", "target"]);
+const OPTIONS = Object.freeze(["band", "pixels", "interval", "target"]);
 
 const encodeBarWidth = /* @__PURE__ */ action(
   {
@@ -26,22 +48,30 @@ const encodeBarWidth = /* @__PURE__ */ action(
     const layout = resolveBarColorLayout(layer);
     const width = normalizeBarWidth(
       args,
-      this.markConfigs[target]?.barWidth
+      this.markConfigs[target]?.barWidth ?? (layer.mark.orientation === undefined ? undefined : { pixels: 5 })
     );
     const grouped = layout === "group";
     const offsetChannel = resolveBarOffsetChannel(layer);
     const grain = resolveBarGrain(layer);
+    if (layer.mark.orientation !== undefined && width.band !== undefined) {
+      throw new Error("Numeric-center bars require pixel width.");
+    }
     if (grain === undefined && this.markConfigs[target]?.boxPlot === undefined && (
       layer.encoding?.x === undefined || layer.encoding?.y === undefined
     )) {
       return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width });
     }
+    if (width.interval !== undefined && grain !== undefined) {
+      const category = resolveBarChannels(layer)?.category;
+      if (grain !== BAR_GRAINS.aggregate || grouped || layer.encoding?.[category]?.fieldType !== "temporal") {
+        throw new Error("Bar interval width requires ungrouped aggregate temporal categories.");
+      }
+    }
     if (grain === BAR_GRAINS.histogram) {
       throw new Error("encodeBarWidth requires an aggregate or ranged category slot, not histogram bins.");
     }
-    if (grain === BAR_GRAINS.ranged) {
-      return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width })
-        .rematerializeBarMark({ id: target });
+    if ([BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(grain)) {
+      return rematerializeWidth(this, target, layer, width);
     }
     if (
       grain !== BAR_GRAINS.aggregate ||
@@ -56,12 +86,7 @@ const encodeBarWidth = /* @__PURE__ */ action(
       );
     }
 
-    return this
-      ._withMarkConfig(target, {
-        ...this.markConfigs[target],
-        barWidth: width
-      })
-      .rematerializeBarMark({ id: target });
+    return rematerializeWidth(this, target, layer, width);
   }
 );
 

package/src/actions/encodings/channels.js

@@ -155,7 +155,6 @@ function resolveScaleOnly(program, id) {
   }
   const consumers = findScaleConsumers(program, id);
   if (
-    semanticScale.radialMapping !== undefined &&
     consumers.length > 0 &&
     consumers.every(isPendingMeasuredRadiusConsumer)
   ) {

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

@@ -39,7 +39,7 @@ export function encodeContinuousColor(program, args) {
   const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
-    ["point", "bar", "rect"],
+    ["point", "bar", "rect", "text"],
     "continuous color mark"
   );
   const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);

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

@@ -63,7 +63,7 @@ const encodeColor = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "line", "bar", "area", "arc", "rect"],
+      ["point", "line", "bar", "area", "arc", "rect", "text"],
       "color mark"
     );
     const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);

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

@@ -20,6 +20,9 @@ export function resolveColorScaleOptions(args) {
 }
 
 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.");
+  }
   const config = program.markConfigs[layer.id];
   const hasConstant = {
     point: config?.fill !== undefined,
@@ -27,7 +30,8 @@ export function assertNoConstantColor(program, layer) {
     area: config?.errorBand?.fill !== undefined,
     bar: config?.barAppearance?.fill !== undefined,
     arc: config?.fill !== undefined,
-    rect: config?.fillExplicit === true
+    rect: config?.fillExplicit === true,
+    text: config?.fillExplicit === true
   }[layer.mark.type] ?? false;
   if (hasConstant) {
     throw new Error(
@@ -58,15 +62,18 @@ export function resolveColorLayout(layer, requested, barGrain) {
     layer.mark.type === "bar"
       ? barGrain === BAR_GRAINS.histogram
         ? "stack"
-        : barGrain === BAR_GRAINS.ranged ? "overlay" : "group"
+        : [BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(barGrain) ? "overlay" : "group"
       : layer.mark.type === "area"
         ? "overlay"
         : undefined
   );
 
-  if (["point", "line", "rect"].includes(layer.mark.type) && layout !== undefined) {
+  if (["point", "line", "rect", "text"].includes(layer.mark.type) && layout !== undefined) {
     throw new Error(`Color layout is not supported for ${layer.mark.type} marks.`);
   }
+  if (barGrain === BAR_GRAINS.centered && layout !== "overlay") {
+    throw new Error("Numeric-center bars support only overlay layout.");
+  }
   if (layer.mark.type === "area" && layout === "group") {
     throw new Error('Area color layout does not support "group".');
   }

package/src/actions/encodings/density/resolve.js

@@ -1,12 +1,7 @@
+export { requireStringValue as requireDensityField } from "../../../core/validation.js";
 import { isPlainObject } from "../../../core/immutable.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 
-export function requireDensityField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function resolveDensityScaleOptions(value, defaults, label) {
   if (value !== undefined && !isPlainObject(value)) {

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

@@ -11,11 +11,6 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
     throw new Error(`Arc ${channel} encoding does not support stack.`);
   }
   if (channel === "radius") {
-    if (layer.encoding?.theta?.fieldType === "quantitative") {
-      throw new Error(
-        "Arc radius encoding cannot be combined with quantitative theta."
-      );
-    }
     if (args.mapping !== undefined) {
       validateRadialMapping(args.mapping);
       if (fieldType !== "quantitative" || !["count", "sum"].includes(args.aggregate)) {
@@ -30,7 +25,16 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
       return { ...emptyPositionPolicy(), aggregate: args.aggregate };
     }
     if (args.aggregate !== undefined) {
-      throw new Error("Arc radius encoding does not support aggregate.");
+      if (!["count", "sum"].includes(args.aggregate)) throw new Error("Arc radius aggregate supports count or sum.");
+      const theta = layer.encoding?.theta;
+      if (theta !== undefined && !["count", "sum"].includes(theta.aggregate)) {
+        throw new Error("Grouped arc radius requires aggregated categorical theta.");
+      }
+      if (args.aggregate === "count" && Object.hasOwn(args, "field")) {
+        throw new Error("Arc radius count does not accept a field.");
+      }
+      if (args.weight !== undefined) throw new Error("Arc radius encoding does not support weight.");
+      return { ...emptyPositionPolicy(), aggregate: args.aggregate };
     }
     if (args.weight !== undefined) {
       throw new Error("Arc radius encoding does not support weight.");
@@ -38,10 +42,8 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
     return emptyPositionPolicy();
   }
   if (fieldType === "quantitative") {
-    if (layer.encoding?.radius !== undefined) {
-      throw new Error(
-        "Quantitative arc theta cannot be combined with radius encoding."
-      );
+    if (layer.encoding?.radius?.aggregate !== undefined) {
+      throw new Error("Grouped arc radius requires aggregated categorical theta.");
     }
     if (args.aggregate !== undefined) {
       throw new Error("Quantitative arc theta does not support aggregate.");

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

@@ -26,16 +26,16 @@ export function resolveAreaPositionPolicy({
   const density = dataset.transform?.find(transform => transform.type === "density");
   if (["nominal", "ordinal"].includes(fieldType)) {
     if (
-      density?.placement?.type !== "category" ||
+      density !== undefined && (density.placement?.type !== "category" ||
       density.placement.channel !== channel ||
-      density.placement.categoryField !== field
+      density.placement.categoryField !== field)
     ) {
       throw new Error(
         "Categorical area position requires a matching category density placement."
       );
     }
     if (args.aggregate !== undefined || args.bin !== undefined || args.stack !== undefined) {
-      throw new Error("Categorical density position does not support aggregate, bin, or stack.");
+      throw new Error("Categorical area position does not support aggregate, bin, or stack.");
     }
     return emptyPositionPolicy();
   }

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

@@ -26,7 +26,15 @@ function resolveBarChannelPolicy({
   let stack;
   const xEncoding = layer.encoding?.x;
   const opposite = layer.encoding?.[channel === "x" ? "y" : "x"];
-  const pendingBoxRange = program.markConfigs[layer.id]?.boxPlot !== undefined;
+  const pendingRange = program.markConfigs[layer.id]?.boxPlot !== undefined ||
+    layer.encoding?.[`${channel}2`] !== undefined;
+
+  if (layer.mark?.orientation !== undefined) {
+    if (fieldType !== "quantitative" || ["bin", "aggregate", "stack", "weight"].some(key => args[key] !== undefined)) {
+      throw new Error("Oriented numeric bars require raw quantitative positions without bin, aggregate, stack, or weight.");
+    }
+    return { bin, aggregate, stack };
+  }
 
   if (["nominal", "ordinal", "temporal"].includes(fieldType)) {
     if (args.aggregate !== undefined || args.bin !== undefined || args.stack !== undefined) {
@@ -73,11 +81,11 @@ function resolveBarChannelPolicy({
     }
     aggregate = args.aggregate ?? (
       ["nominal", "ordinal", "temporal"].includes(opposite?.fieldType) &&
-      !pendingBoxRange
+      !pendingRange
         ? "mean"
         : undefined
     );
-    if (pendingBoxRange && args.aggregate === undefined) {
+    if (pendingRange && args.aggregate === undefined) {
       return { bin, aggregate, stack };
     }
     stack = Object.hasOwn(args, "stack") ? args.stack : opposite === undefined ? undefined : null;
@@ -106,7 +114,8 @@ export function resolveBarPositionPolicy(context) {
   const policy = resolveBarChannelPolicy(context);
   const oppositeChannel = channel === "x" ? "y" : "x";
   const opposite = layer.encoding?.[oppositeChannel];
-  const pendingBoxRange = program.markConfigs[layer.id]?.boxPlot !== undefined;
+  const pendingRange = program.markConfigs[layer.id]?.boxPlot !== undefined ||
+    layer.encoding?.[`${channel}2`] !== undefined;
   const candidate = {
     ...layer,
     encoding: {
@@ -118,7 +127,7 @@ export function resolveBarPositionPolicy(context) {
   // Absence of an aggregate/stack is sufficient to represent an unresolved role.
   let companion;
   if (
-    !pendingBoxRange && resolveBarGrain(layer) === undefined &&
+    !pendingRange && resolveBarGrain(layer) === undefined &&
     opposite?.fieldType === "quantitative" && opposite.bin === undefined
   ) {
     const resolved = resolveBarChannelPolicy({
@@ -138,7 +147,7 @@ export function resolveBarPositionPolicy(context) {
     }
   }
   const orientation = resolveBarOrientation(candidate);
-  if (opposite !== undefined && orientation === undefined && !pendingBoxRange) {
+  if (opposite !== undefined && orientation === undefined && !pendingRange) {
     throw new Error(
       `Bar ${channel} encoding requires a quantitative field opposite a categorical position.`
     );

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

@@ -68,6 +68,13 @@ export function resolveLinePositionPolicy({
         stack: undefined
       };
     }
+    if (["nominal", "ordinal"].includes(fieldType)) {
+      if (layer.encoding?.y !== undefined && layer.encoding.y.aggregate === undefined &&
+          layer.encoding.y.fieldType !== "quantitative") {
+        throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");
+      }
+      return emptyPositionPolicy();
+    }
     const directPair =
       layer.encoding?.y?.aggregate === undefined &&
       ["quantitative", "temporal"].includes(layer.encoding?.y?.fieldType) &&
@@ -82,7 +89,7 @@ export function resolveLinePositionPolicy({
       )
     ) {
       throw new Error(
-        "Line x encoding requires a temporal field or a compatible derived quantitative field."
+        "Line x encoding requires a categorical or temporal field, or a compatible quantitative field."
       );
     }
     return emptyPositionPolicy();
@@ -93,15 +100,19 @@ export function resolveLinePositionPolicy({
   if (layer.encoding?.x?.bin !== undefined && args.aggregate === undefined) {
     throw new Error("Binned line x encoding requires an aggregate y encoding.");
   }
-  const quantitativePair =
+  if (["nominal", "ordinal"].includes(layer.encoding?.x?.fieldType) &&
+      args.aggregate === undefined && fieldType !== "quantitative") {
+    throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");
+  }
+  const continuousPair =
     fieldType === "quantitative" &&
-    layer.encoding?.x?.fieldType === "quantitative" &&
+    ["quantitative", "temporal", "nominal", "ordinal"].includes(layer.encoding?.x?.fieldType) &&
     layer.encoding.x.bin === undefined;
   const prospectiveDirect =
     args.aggregate === undefined &&
     (fieldType === "temporal" ||
       (fieldType === "quantitative" &&
-        (layer.encoding?.x === undefined || quantitativePair)));
+        (layer.encoding?.x === undefined || continuousPair)));
   if (interval || (windowOutput && args.aggregate === undefined) || prospectiveDirect) {
     if (!["quantitative", "temporal"].includes(fieldType)) {
       throw new Error(
@@ -125,12 +136,12 @@ export function resolveLinePositionPolicy({
 
   if (layer.encoding?.x !== undefined) {
     const compatibleAggregateX =
-      layer.encoding.x.fieldType === "temporal" ||
+      ["temporal", "nominal", "ordinal"].includes(layer.encoding.x.fieldType) ||
       (layer.encoding.x.fieldType === "quantitative" &&
         layer.encoding.x.bin !== undefined);
     if (!compatibleAggregateX) {
       throw new Error(
-        "Aggregate line y encoding requires a temporal or binned quantitative x encoding."
+        "Aggregate line y encoding requires a temporal, categorical, or binned quantitative x encoding."
       );
     }
   }

package/src/actions/encodings/position/resolve.js

@@ -142,7 +142,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
       ? undefined
       : args.mapping ?? findSemanticScale(program, previous?.scale)?.radialMapping
     : undefined;
-  const countRadius = mapping !== undefined && (args.aggregate ?? previous?.aggregate) === "count";
+  const countRadius = channel === "radius" && layer.mark.type === "arc" &&
+    !clearRadialMapping && (args.aggregate ?? previous?.aggregate) === "count";
   const requestedFieldType = args.fieldType ?? previous?.fieldType ?? (
     ["rule", "rect", "text", "point", "tick"].includes(layer.mark.type) && hasDatum
       ? inferDatumFieldType(args.datum, operation)
@@ -179,7 +180,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     } else readScaleField(dataset.values, field, fieldType, { temporalUnit });
   }
   const effectiveArgs = { ...args };
-  if (clearRadialMapping) delete effectiveArgs.mapping;
+  if (clearRadialMapping && args.aggregate === undefined) delete effectiveArgs.mapping;
   else if (mapping !== undefined) effectiveArgs.mapping = mapping;
   const directQuantitativeArcTheta =
     layer.mark.type === "arc" &&

package/src/actions/encodings/ranged.js

@@ -127,6 +127,9 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
 
   let next = program;
   if (layer.mark.type === "bar") {
+    if (layer.mark.orientation !== undefined && primaryChannel !== (layer.mark.orientation === "vertical" ? "y" : "x")) {
+      throw new Error("Numeric bar endpoints must use the measure channel.");
+    }
     if (layer.layout?.mode !== undefined && layer.layout.mode !== "overlay") throw new Error("Ranged bars support only overlay layout; clear series layout before assigning endpoints.");
     for (const property of ["aggregate", "stack", "bin"]) {
       if (layer.encoding?.[primaryChannel]?.[property] !== undefined) {
@@ -210,6 +213,20 @@ function rangeAction(channel) {
     const { layer, dataset } = resolveTarget(this, args.target, ["area", "bar", "rect", "rule"], "ranged mark");
     let next = this;
     let lower = { field: args.lower }, upper = { field: args.upper };
+    if (layer.mark.type === "bar") {
+      if (layer.mark.orientation !== undefined && channel !== (layer.mark.orientation === "vertical" ? "y" : "x")) {
+        throw new Error("Numeric bar endpoints must use the measure channel.");
+      }
+      common.target = layer.id;
+      const resolved = resolvePositionEncoding(this, channel, {
+        ...common, ...lower,
+        ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+        ...(args.scale === undefined ? {} : { scale: args.scale })
+      }, op);
+      next = setEncodingProperties(next, layer.id, `${channel}2`, {
+        ...upper, fieldType: common.fieldType, scale: resolved.scale.id
+      });
+    }
     if (layer.mark.type === "area") {
       common.target = layer.id;
       const prepared = prepareAreaRange(this, layer, dataset, channel, args, common);