fix: strip disallowed properties from secondary encoding channels (x2, y2)

Vega-Lite secondary channels (x2, y2, theta2, radius2) only allow a
restricted set of properties (field, aggregate, bandPosition, bin,
timeUnit, title, value). The VegaLiteWriter was emitting type, scale,
and axis on these channels, causing Altair schema validation errors.

Added is_secondary_channel() to detect internal aesthetics (pos1end,
pos2end) that map to secondary channels, and an early return in
build_column_encoding() that emits only the allowed properties.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cpsievert

ggsql-python/tests/test_ggsql.py

@@ -194,6 +194,33 @@ def test_render_multi_layer(self):
         assert "layer" in spec_dict
 
 
+class TestSecondaryChannelEncoding:
+    """Tests for Vega-Lite secondary channel encoding (x2, y2)."""
+
+    def test_bar_y2_has_no_disallowed_properties(self):
+        """Bar chart y2 encoding should not have type, scale, or axis properties."""
+        reader = ggsql.DuckDBReader("duckdb://memory")
+        df = pl.DataFrame({"survived": [0, 1, 1, 0, 0, 1, 0, 1, 0, 0]})
+        reader.register("titanic", df)
+        spec = reader.execute(
+            "SELECT survived FROM titanic "
+            "VISUALISE survived AS x "
+            "DRAW bar "
+            "LABEL title => 'Survival Count'"
+        )
+        writer = ggsql.VegaLiteWriter()
+        vl = json.loads(writer.render(spec))
+
+        # Find y2 in any layer
+        for layer in vl.get("layer", [vl]):
+            y2 = layer.get("encoding", {}).get("y2")
+            if y2 is not None:
+                assert "axis" not in y2, f"y2 should not have 'axis': {y2}"
+                assert "scale" not in y2, f"y2 should not have 'scale': {y2}"
+                assert "type" not in y2, f"y2 should not have 'type': {y2}"
+                assert "field" in y2, f"y2 should have 'field': {y2}"
+
+
 class TestRenderAltairDataFrameConversion:
     """Tests for DataFrame handling in render_altair()."""
 

src/plot/aesthetic.rs

@@ -331,6 +331,22 @@ pub fn is_facet_aesthetic(aesthetic: &str) -> bool {
     false
 }
 
+/// Check if an internal aesthetic maps to a Vega-Lite **secondary** encoding channel
+/// (x2, y2, theta2, radius2).
+///
+/// Vega-Lite secondary channels only support a restricted set of properties
+/// (`field`, `aggregate`, `bandPosition`, `bin`, `timeUnit`, `title`, `value`).
+/// Properties like `type`, `scale`, and `axis` must not be emitted for these.
+///
+/// Matches internal names like `pos1end`, `pos2end`, etc.
+#[inline]
+pub fn is_secondary_channel(name: &str) -> bool {
+    name.starts_with("pos") && name.ends_with("end") && {
+        let mid = &name[3..name.len() - 3];
+        !mid.is_empty() && mid.chars().all(|c| c.is_ascii_digit())
+    }
+}
+
 /// Check if aesthetic is an internal positional (pos1, pos1min, pos2max, etc.)
 ///
 /// This function works with **internal** aesthetic names after transformation.

src/writer/vegalite/encoding.rs

@@ -3,7 +3,7 @@
 //! This module handles building Vega-Lite encoding channels from ggsql aesthetic mappings,
 //! including type inference, scale properties, and title handling.
 
-use crate::plot::aesthetic::{is_positional_aesthetic, AestheticContext};
+use crate::plot::aesthetic::{is_positional_aesthetic, is_secondary_channel, AestheticContext};
 use crate::plot::scale::{linetype_to_stroke_dash, shape_to_svg_path, ScaleTypeKind};
 use crate::plot::{CoordKind, ParameterValue};
 use crate::{AestheticValue, DataFrame, Plot, Result};
@@ -819,6 +819,27 @@ fn build_column_encoding(
     let primary = aesthetic_ctx
         .primary_internal_positional(aesthetic)
         .unwrap_or(aesthetic);
+
+    // Vega-Lite secondary channels (x2, y2, theta2, radius2) only allow a restricted
+    // set of properties: field, aggregate, bandPosition, bin, timeUnit, title, value.
+    // Properties like type, scale, and axis must not be emitted.
+    if is_secondary_channel(aesthetic) {
+        let mut encoding = json!({ "field": col });
+
+        // Apply title handling (title is allowed on secondary channels)
+        apply_title_to_encoding(
+            &mut encoding,
+            aesthetic,
+            original_name,
+            ctx.spec,
+            ctx.titled_families,
+            ctx.primary_aesthetics,
+            &aesthetic_ctx,
+        );
+
+        return Ok(encoding);
+    }
+
     let mut identity_scale = false;
 
     // Determine field type from scale or infer from data