dataface 0.3.2.dev22__py3-none-any.whl → 0.3.2.dev111__py3-none-any.whl

dataface/core/render/chart/emitters/bar.py

@@ -10,7 +10,10 @@ from dataface.core.compile.models.chart.resolved.bar import ResolvedBarChart
 from dataface.core.compile.models.primitives import OverlapSpec
 from dataface.core.compile.tick_values import numeric_domain_bounds
 from dataface.core.diagnostics.chart_data import ChartDataError
-from dataface.core.diagnostics.codes_render import ERR_HISTOGRAM_NON_NUMERIC
+from dataface.core.diagnostics.codes_render import (
+    ERR_HISTOGRAM_NON_NUMERIC,
+    ERR_LABEL_VALUES_NOT_TEMPORAL,
+)
 from dataface.core.render.chart._types import VLDict
 from dataface.core.render.chart.emitters._cartesian import (
     apply_domain_headroom_bounds,
@@ -51,14 +54,14 @@ from dataface.core.render.chart.type_inference import (
 from dataface.core.render.chart.validation import (
     validate_color_series,
     validate_preaggregated_data,
+    validate_raw_rows_for_histogram,
 )
 from dataface.core.render.chart.vl_field_maps import (
-    SCALE_FIELD_MAP,
     axis_to_vl,
     bar_corner_props,
     bar_mark_radius,
     bar_mark_to_vl,
-    map_fields,
+    emit_resolved_scale_vl,
     measure_axis_to_vl,
 )
 from dataface.core.render.utils import normalize_data_types
@@ -230,7 +233,9 @@ def _emit_histogram(
     """Emit a histogram spec: binned quantitative x, aggregate-count y, color-only grouping.
 
     Mirrors V1 _map_histogram exactly. Does NOT call validate_preaggregated_data —
-    histograms consume raw rows (VL handles binning + aggregation).
+    histograms consume raw rows (VL handles binning + aggregation) — but does
+    call validate_raw_rows_for_histogram, the mirror-image guard that rejects
+    the opposite mistake: data that's already one row per bucket.
     """
     # Validate before building: missing or non-numeric x crashes vl_convert.
     if chart.x is None:
@@ -248,6 +253,7 @@ def _emit_histogram(
             field=chart.x,
             vl_type=x_vl_type,
         )
+    validate_raw_rows_for_histogram(chart, data)
 
     # Histogram bars are always positive (counts) → top-anchored corner rounding.
     # bar_mark_to_vl no longer carries the corner radius (sign-aware rounding
@@ -414,7 +420,7 @@ class BarEmitter:
                 chart_id=chart.id,
                 axis_y=chart.style.axis_y,
                 tooltip_format=chart.style.tooltip_format,
-                background=chart.style.background,
+                background=chart.background,
                 single_series_fill=chart.style.single_series_fill,
                 legend=chart.legend,
                 config=config,
@@ -562,11 +568,7 @@ def _emit_vertical(
     x_scale: dict[str, Any] = {}
     if ax.scale is not None and ax.scale.padding is not None:
         x_scale["padding"] = ax.scale.padding
-    # chart-local band_padding_inner wins over theme bar.padding shorthand
-    if ax.scale is not None and ax.scale.band_padding_inner is not None:
-        x_scale["paddingInner"] = ax.scale.band_padding_inner
-    else:
-        x_scale["paddingInner"] = bar_mark.padding
+    x_scale["paddingInner"] = bar_mark.padding
     x_scale.update(cartesian_x_scale_domain(ax.scale, x_vl_type, chart.id))
     if x_vl_type == "quantitative" and bar_mark.size is not None:
         # Vega-Lite centers each fixed continuousBandSize bar on its data
@@ -630,10 +632,11 @@ def _emit_vertical(
             ay_vl["values"] = list(_NORMALIZE_QUARTILE_TICKS)
     else:
         is_stacked = bool(measure_field) and chart.stack not in (None, "none")
-        ay_scale_zero = ay.scale.zero if ay.scale is not None else None
+        _ay_cont = ay.scale.continuous if ay.scale is not None else None
+        ay_scale_zero = _ay_cont.zero if _ay_cont is not None else None
         bar_zero = not is_stacked and ay_scale_zero is not False
         authored_domain = numeric_domain_bounds(
-            ay.scale.domain if ay.scale is not None else None
+            _ay_cont.domain if _ay_cont is not None else None
         )
         y_ticks: list[float] | None = list(ay.tick_values) if ay.tick_values else None
         if y_ticks and "values" not in ay_vl:
@@ -642,14 +645,14 @@ def _emit_vertical(
         if authored_domain is not None:
             y_scale = {"domain": list(authored_domain)}
             if ay.scale is not None:
-                y_scale.update(map_fields(ay.scale, SCALE_FIELD_MAP))
+                y_scale.update(emit_resolved_scale_vl(ay.scale))
                 # An authored domain already IS the exact bounds — "zero" is a
                 # domain-inference hint, meaningless once the domain is pinned.
                 y_scale.pop("zero", None)
         elif bar_zero:
             y_scale = {"domainMin": (y_ticks[0] if y_ticks else 0.0), "zero": True}
             if ay.scale is not None:
-                extra_scale = map_fields(ay.scale, SCALE_FIELD_MAP)
+                extra_scale = emit_resolved_scale_vl(ay.scale)
                 extra_scale.pop("zero", None)
                 y_scale.update(extra_scale)
         else:
@@ -780,6 +783,29 @@ def _emit_horizontal(
             "chart must go through the resolve pipeline before emitting."
         )
 
+    # style.axis_x.labels.values only has meaning against a temporal/ISO-bucketed
+    # scale (the labelExpr membership filter build_cartesian_x_encoding wires
+    # in for the vertical path). Horizontal bar's categorical axis is always
+    # emitted as a flat VL "nominal" y-encoding (see y_enc below) — there is no
+    # date-aware label path here for the filter to hook into, so honoring it
+    # would be a no-op regardless of whether the values are ISO-shaped. Raise
+    # the same coded error the vertical path raises for non-temporal x, rather
+    # than silently dropping the authored filter. Unlike the vertical path's
+    # guard, this fires unconditionally on ISO-ness (an explicit
+    # orientation: horizontal override with genuinely ISO-shaped x data would
+    # still be unable to honor labels.values), so the cause/remedy passed here
+    # name the orientation, never claim the data itself is invalid.
+    if ax.labels.values is not None:
+        raise ChartDataError.from_code(
+            ERR_LABEL_VALUES_NOT_TEMPORAL,
+            field=cat_field,
+            cause=(
+                "a horizontal bar's categorical axis never honors it, "
+                "regardless of date format"
+            ),
+            remedy="Set orientation: vertical, or remove labels.values.",
+        )
+
     # VL x = measure axis.
     color_ch_early = chart.resolved_channels.get("color") if wide is False else None
     measure_field = (
@@ -809,16 +835,15 @@ def _emit_horizontal(
     # In Vega-Lite, paddingInner on a quantitative scale is a no-op visually, but
     # V1 emits it unconditionally via effective.scale applied to all channels,
     # and the existing tests assert it is present here.
-    _ay_scale_zero = ay.scale.zero if ay.scale is not None else None
+    _ay_cont_h = ay.scale.continuous if ay.scale is not None else None
+    _ay_scale_zero_h = _ay_cont_h.zero if _ay_cont_h is not None else None
     x_enc_scale: VLDict = {
-        "zero": _ay_scale_zero if isinstance(_ay_scale_zero, bool) else True
+        "zero": _ay_scale_zero_h if isinstance(_ay_scale_zero_h, bool) else True
     }
     if ay.scale is not None:
-        extra_x_scale = map_fields(ay.scale, SCALE_FIELD_MAP)
+        extra_x_scale = emit_resolved_scale_vl(ay.scale)
         extra_x_scale.pop("zero", None)
         x_enc_scale.update(extra_x_scale)
-    if ax.scale is not None and ax.scale.band_padding_inner is not None:
-        x_enc_scale["paddingInner"] = ax.scale.band_padding_inner
     x_enc: dict[str, Any] = {
         "field": measure_field,
         "type": "quantitative",
@@ -835,8 +860,9 @@ def _emit_horizontal(
             ay_vl["values"] = list(_NORMALIZE_QUARTILE_TICKS)
     else:
         # domainMax: use baked stacked total; fall back to nice-tick top.
+        _ay_cont_x = ay.scale.continuous if ay.scale is not None else None
         authored_x_domain = numeric_domain_bounds(
-            ay.scale.domain if ay.scale is not None else None
+            _ay_cont_x.domain if _ay_cont_x is not None else None
         )
         if measure_field and chart.stack not in (None, "none"):
             if authored_x_domain is None:
@@ -852,7 +878,10 @@ def _emit_horizontal(
                 x_enc["scale"], ay.domain_max, ay.domain_min
             )
 
-    # Categorical axis (VL y): axis_to_vl(ax) + orient from ay.categorical_orient
+    # Categorical axis (VL y): axis_to_vl(ax) + orient from ay.position
+    # (categorical_orient was deleted 2026-08 — position now serves this role
+    # too; _resolve.py bakes it "left"-default here via _bake_ay_position_left,
+    # matching the deleted field's static default, before computing x_edge).
     # Horizontal bar: categorical labels on VL y; is_horizontal_bar pins allow+angle=0.
     label_layout = resolve_axis_x_overlap(
         ax,
@@ -868,11 +897,11 @@ def _emit_horizontal(
         label_overlap=label_layout.label_overlap,
         label_angle=label_layout.angle,
     )
-    if ay.categorical_orient is not None:
-        ax_vl["orient"] = ay.categorical_orient
-    # Own-side align (ax.label.align resolved to the axis's own
+    if ay.position is not None:
+        ax_vl["orient"] = ay.position
+    # Own-side align (ax.labels.align resolved to the axis's own
     # orient side — either authored directly, or resolve-mapped from
-    # charts.bar.axis_x.label.align: inward) flips label growth back toward
+    # charts.bar.axis_x.labels.align: inward) flips label growth back toward
     # the plot. Symmetric case to vl_field_maps.py's measure_axis_to_vl guard.
     cat_orient = ax_vl.get("orient")
     # Every row, not a capped sample: an under-measured gutter from a wide
@@ -891,7 +920,7 @@ def _emit_horizontal(
     # measure (zero rows). No font.case exclusion here: horizontal bar's
     # categorical axis never runs inject_axis_label_case (that only wires
     # into build_cartesian_x_encoding's temporal/ordinal x path, which this
-    # VL-y categorical axis doesn't go through), so label.font.case has no
+    # VL-y categorical axis doesn't go through), so labels.font.case has no
     # rendered effect to mismeasure against.
     if (
         cat_orient in ("left", "right")
@@ -900,12 +929,12 @@ def _emit_horizontal(
         and cat_labels
     ):
         cat_tick_size = (
-            ax.ticks.size if ax.ticks.size is not None else DEFAULT_VL_TICK_SIZE
+            ax.ticks.length if ax.ticks.length is not None else DEFAULT_VL_TICK_SIZE
         )
-        cat_padding = measured_label_padding(cat_labels, ax.label.font, cat_tick_size)
+        cat_padding = measured_label_padding(cat_labels, ax.labels.font, cat_tick_size)
         cat_label_limit = (
-            ax.label.max_width
-            if ax.label.max_width is not None
+            ax.labels.max_width
+            if ax.labels.max_width is not None
             else DEFAULT_VL_LABEL_LIMIT
         )
         ax_vl["labelPadding"] = cap_padding_to_label_limit(
@@ -935,11 +964,7 @@ def _emit_horizontal(
     y_scale: dict[str, Any] = {}
     if ax.scale is not None and ax.scale.padding is not None:
         y_scale["padding"] = ax.scale.padding
-    # chart-local band_padding_inner wins over theme bar.padding shorthand
-    if ax.scale is not None and ax.scale.band_padding_inner is not None:
-        y_scale["paddingInner"] = ax.scale.band_padding_inner
-    else:
-        y_scale["paddingInner"] = bar_mark.padding
+    y_scale["paddingInner"] = bar_mark.padding
 
     y_enc: dict[str, Any] = {
         "field": cat_field,

dataface/core/render/chart/emitters/geo.py

@@ -11,7 +11,11 @@ from dataface.core.compile.models.style.theme import (
     GeoshapeChartStyle,
     GeoshapeMarkStyle,
 )
-from dataface.core.render.chart.emitters._channels import channel_to_encoding
+from dataface.core.render.chart._types import VLDict
+from dataface.core.render.chart.emitters._channels import (
+    channel_to_encoding,
+    gradient_scale_to_vl,
+)
 from dataface.core.render.chart.geo_tooltip import (
     build_point_tooltip_fields,
     validate_map_lookup_key_contract,
@@ -218,18 +222,9 @@ class GeoshapeEmitter:
                 if map_config is not None and map_config.color is not None
                 else None
             )
-            _geo_scale: dict[str, Any] = {}
-            if _geo_gradient is not None:
-                if isinstance(_geo_gradient.palette, str):
-                    _geo_scale = {"scheme": _geo_gradient.palette}
-                else:
-                    _geo_scale = {"range": list(_geo_gradient.palette)}
-                if _geo_gradient.min is not None and _geo_gradient.max is not None:
-                    _geo_scale["domain"] = [_geo_gradient.min, _geo_gradient.max]
-                elif _geo_gradient.min is not None:
-                    _geo_scale["domainMin"] = _geo_gradient.min
-                elif _geo_gradient.max is not None:
-                    _geo_scale["domainMax"] = _geo_gradient.max
+            _geo_scale: VLDict = (
+                gradient_scale_to_vl(_geo_gradient) if _geo_gradient is not None else {}
+            )
             color_enc = {
                 "field": value_field,
                 "type": "quantitative",

dataface/core/render/chart/emitters/heatmap.py

@@ -6,7 +6,11 @@ from dataclasses import dataclass
 from typing import Any
 
 from dataface.core.compile.models.chart.resolved.heatmap import ResolvedHeatmapChart
-from dataface.core.render.chart.emitters._channels import channel_to_encoding
+from dataface.core.render.chart.emitters._channels import (
+    apply_color_legend,
+    channel_to_encoding,
+    gradient_scale_to_vl,
+)
 from dataface.core.render.chart.emitters._label_overlap import resolve_axis_x_overlap
 from dataface.core.render.chart.spec import ChartSpec, RenderBox
 from dataface.core.render.chart.vl_field_maps import (
@@ -114,7 +118,7 @@ class HeatmapEmitter:
             y_type = "nominal"
             # Row labels are the literal per-row values (no d3 format applies
             # to a nominal field), so an own-side align (resolved from
-            # axis_y.label.align: inward, or an authored left/right) is
+            # axis_y.labels.align: inward, or an authored left/right) is
             # measured directly against them — same exact-content case
             # bar.py's categorical own-side gate uses. Only worth the
             # O(rows) dedup pass when align is actually set — otherwise
@@ -128,7 +132,7 @@ class HeatmapEmitter:
                         if row.get(chart.y) is not None
                     )
                 )
-                if ay.label.align is not None
+                if ay.labels.align is not None
                 else ()
             )
             y_axis = measure_axis_to_vl(ay, data, (), category_labels=y_category_labels)
@@ -157,31 +161,21 @@ class HeatmapEmitter:
                         from_slug=True,
                         font=chart.legend.title.font,
                     )
-                # legend: None suppresses the series legend on heatmap
-                # (oracle always emits null; also suppresses LegendToggleFeature).
-                enc["legend"] = None
-                # Apply color_gradient only when there is a field-bound color encoding.
+                # Heatmap's color channel is the whole measure, so it needs a key
+                # like every other family — wire the resolved legend style through
+                # like bar/line/scatter/pie do. VL renders its native continuous
+                # gradient legend for a quantitative field with no extra code.
+                apply_color_legend(enc, chart.legend)
+                # color_gradient is the cascade-complete gradient (theme/board
+                # defaults merged with any chart-local style.color.gradient
+                # override) — strictly more complete than a "gradient" mode
+                # channel's own ch.scale, which is built from the chart-local
+                # gradient dict alone and can be missing a domain the cascade
+                # supplies (e.g. board-level min/max). Always prefer it over
+                # whatever channel_to_encoding already set.
                 _cg = chart.style.color_gradient
                 if _cg is not None:
-                    _scheme = _cg.palette if isinstance(_cg.palette, str) else None
-                    _range = (
-                        list(_cg.palette) if isinstance(_cg.palette, list) else None
-                    )
-                    if "scale" not in enc:
-                        enc["scale"] = {}
-                    if _scheme is not None and "range" not in enc["scale"]:
-                        enc["scale"] = {**enc["scale"], "scheme": _scheme}
-                    elif _range is not None and "range" not in enc["scale"]:
-                        enc["scale"] = {**enc["scale"], "range": _range}
-                    if _cg.min is not None and _cg.max is not None:
-                        enc["scale"] = {
-                            **enc["scale"],
-                            "domain": [_cg.min, _cg.max],
-                        }
-                    elif _cg.min is not None:
-                        enc["scale"] = {**enc["scale"], "domainMin": _cg.min}
-                    elif _cg.max is not None:
-                        enc["scale"] = {**enc["scale"], "domainMax": _cg.max}
+                    enc["scale"] = gradient_scale_to_vl(_cg)
                 # Tooltip format on color encoding for quantitative heatmap values.
                 if enc.get("type") == "quantitative":
                     fmt = chart.style.tooltip_format

dataface/core/render/chart/emitters/line.py

@@ -381,7 +381,7 @@ class LineEmitter:
         sub_layers = emit_line_layer(
             style.line_mark,
             style.point_mark,
-            style.background,
+            chart.background,
             style.single_series_fill,
             has_color_enc,
             top_encoding["color"] if has_color_enc else {},
@@ -416,7 +416,7 @@ class LineEmitter:
                 chart_id=chart.id,
                 axis_y=style.axis_y,
                 tooltip_format=style.tooltip_format,
-                background=style.background,
+                background=chart.background,
                 single_series_fill=style.single_series_fill,
                 legend=chart.legend,
                 config=build_palette_config(chart.palette),

dataface/core/render/chart/emitters/scatter.py

@@ -7,7 +7,6 @@ from decimal import Decimal
 from typing import Any
 
 from dataface.core.compile.models.chart.resolved.scatter import ResolvedScatterChart
-from dataface.core.compile.models.style.theme import ScaleStyle
 from dataface.core.render.chart.emitters._cartesian import (
     apply_domain_headroom_bounds,
     build_palette_config,
@@ -23,24 +22,14 @@ from dataface.core.render.chart.emitters._layers import emit_scatter_layer
 from dataface.core.render.chart.spec import ChartSpec, RenderBox
 from dataface.core.render.chart.type_inference import _utc_time_label_expr
 from dataface.core.render.chart.vl_field_maps import (
-    SCALE_ENCODING_FIELD_MAP,
-    SCALE_FIELD_MAP,
     axis_to_vl,
-    map_fields,
+    emit_resolved_scale_vl,
     measure_axis_to_vl,
 )
 from dataface.core.text.case import format_display_text
 from dataface.core.text.format_d3 import is_time_format
 
 
-def _build_axis_scale(scale: ScaleStyle) -> dict[str, Any]:
-    """Build the VL scale dict from board-level scale only."""
-    out: dict[str, Any] = {}
-    out.update(map_fields(scale, SCALE_FIELD_MAP))
-    out.update(map_fields(scale, SCALE_ENCODING_FIELD_MAP))
-    return out
-
-
 def _suppress_zero_for_scatter_y(data: list[dict[str, Any]], y_field: str) -> bool:
     """Return True when scatter y-axis zero should be suppressed (ratio > 0.25).
 
@@ -82,16 +71,10 @@ class ScatterEmitter:
             # Scatter x is always quantitative (continuous). The strategy resolver
             # short-circuits to allow+angle=0 for continuous x; mirror that here
             # by pinning labelAngle explicitly so VL doesn't auto-rotate.
-            if ax.label.angle is None:
+            if ax.labels.angle is None:
                 x_axis["labelAngle"] = 0.0
-            x_scale = (
-                _build_axis_scale(chart.style.scale)
-                if chart.style.scale is not None
-                else {}
-            )
-            if ax.scale is not None:
-                x_scale.update(map_fields(ax.scale, SCALE_FIELD_MAP))
-                x_scale.update(map_fields(ax.scale, SCALE_ENCODING_FIELD_MAP))
+            x_scale = emit_resolved_scale_vl(chart.style.scale, include_x_only=True)
+            x_scale.update(emit_resolved_scale_vl(ax.scale, include_x_only=True))
             # Use axis title font to match oracle (effective.axis_x.title.font).
             x_enc: dict[str, Any] = {
                 "field": chart.x,
@@ -130,14 +113,8 @@ class ScatterEmitter:
             if ay.tick_values:
                 y_axis["values"] = list(ay.tick_values)
 
-            y_scale = (
-                _build_axis_scale(chart.style.scale)
-                if chart.style.scale is not None
-                else {}
-            )
-            if ay.scale is not None:
-                y_scale.update(map_fields(ay.scale, SCALE_FIELD_MAP))
-                y_scale.update(map_fields(ay.scale, SCALE_ENCODING_FIELD_MAP))
+            y_scale = emit_resolved_scale_vl(chart.style.scale)
+            y_scale.update(emit_resolved_scale_vl(ay.scale))
             if y_type == "quantitative" and "domain" not in y_scale:
                 # Exact headroom-applied bounds baked at resolve(); an authored
                 # `domain` (mapped above) always wins outright.
@@ -234,7 +211,7 @@ class ScatterEmitter:
                 chart_id=chart.id,
                 axis_y=chart.style.axis_y,
                 tooltip_format=chart.style.tooltip_format,
-                background=chart.style.background,
+                background=chart.background,
                 single_series_fill=chart.style.single_series_fill,
                 legend=chart.legend,
                 config=config,

dataface/core/render/chart/features/baseline.py

@@ -165,7 +165,8 @@ def _domain_reaches(
     percent-format chart whose data stays well below 1.0.
     """
     scale = chart.style.axis_y.scale  # type: ignore[union-attr]
-    domain = scale.domain if scale is not None else None
+    _sc_cont_bv = scale.continuous if scale is not None else None
+    domain = _sc_cont_bv.domain if _sc_cont_bv is not None else None
     if (
         domain is not None
         and len(domain) >= 2
@@ -261,15 +262,17 @@ class BaselineFeature:
         # log domain cannot represent — Vega-Lite's entire axis rendering
         # breaks (empirically: every tick label vanishes), not just this layer.
         axis_y_scale = chart.style.axis_y.scale
-        if axis_y_scale is not None and axis_y_scale.type == "log":
+        _bsl_cont = axis_y_scale.continuous if axis_y_scale is not None else None
+        if _bsl_cont is not None and _bsl_cont.type == "log":
             return
         # Determine whether the rule should fire.
         if isinstance(chart, ResolvedBarChart):
             should_fire = True
             # An explicit measure-axis domain that excludes 0 suppresses the rule.
             _scale = chart.style.axis_y.scale
-            if _scale is not None and _scale.domain is not None:
-                _d = _scale.domain
+            _bsl_cont2 = _scale.continuous if _scale is not None else None
+            if _bsl_cont2 is not None and _bsl_cont2.domain is not None:
+                _d = _bsl_cont2.domain
                 if (
                     len(_d) >= 2
                     and all(isinstance(v, (int, float)) for v in _d)
@@ -285,7 +288,8 @@ class BaselineFeature:
             if measure_field is False:
                 return
             scale = chart.style.axis_y.scale
-            zero_setting = scale.zero if scale is not None else None
+            _bsl_cont3 = scale.continuous if scale is not None else None
+            zero_setting = _bsl_cont3.zero if _bsl_cont3 is not None else None
             if zero_setting is False:
                 # The straddle check must cover every mark sharing this SAME
                 # y scale, not just the base series' own values — apply()
@@ -335,12 +339,14 @@ class BaselineFeature:
 
         if measure_field is False:
             return
-
         # Read zero style from the chart's own baked axis cascade (style.axis_y),
         # not board-level style — a chart-local axis patch has to win.
         if not chart.style.axis_y.grid.visible:
             return
         zero_style = chart.style.axis_y.grid.zero
+        assert (
+            zero_style is not None
+        ), "zero grid style must be resolved before emitting the baseline rule"
         rule = _full_rule_at(
             0,
             axis=rule_axis,
@@ -358,7 +364,8 @@ class BaselineFeature:
         assert isinstance(chart, (ResolvedBarChart, ResolvedAreaChart))
         # Same log-domain incompatibility as _insert_zero_rule's datum:0 guard.
         axis_y_scale = chart.style.axis_y.scale
-        if axis_y_scale is not None and axis_y_scale.type == "log":
+        _top_cont = axis_y_scale.continuous if axis_y_scale is not None else None
+        if _top_cont is not None and _top_cont.type == "log":
             return
         rule_axis = (
             "x"
@@ -369,6 +376,9 @@ class BaselineFeature:
         if measure_field is False:
             return
         zero_style = chart.style.axis_y.grid.zero
+        assert (
+            zero_style is not None
+        ), "zero grid style must be resolved before emitting top rules"
         # Horizontal bars put the measure on x, so the 0%/100% datum rules anchor
         # on x — not the categorical y axis (mirrors the zero rule).
         for datum in (0, 1):
@@ -392,10 +402,10 @@ class BaselineFeature:
     ) -> None:
         if not isinstance(chart, (ResolvedLineChart, ResolvedAreaChart)):
             return
-        # axis_y.format is the D3 spec resolved from the face+theme cascade.
+        # axis_y.labels.format is the D3 spec resolved from the face+theme cascade.
         # Check it first — it converts Dataface aliases ("percent_whole") to
         # their literal D3 form (".0%"), which always contains "%".
-        ax_fmt = chart.style.axis_y.format
+        ax_fmt = chart.style.axis_y.labels.format
         if not ((ax_fmt and "%" in ax_fmt) or _is_percent_format(chart.format)):
             return
         # grid.visible=False suppresses the unity rule (mirrors zero-rule gate).
@@ -418,6 +428,9 @@ class BaselineFeature:
         ):
             return
         zero_style = chart.style.axis_y.grid.zero
+        assert (
+            zero_style is not None
+        ), "zero grid style must be resolved before emitting unity rule"
         _insert_rule(
             spec,
             _full_rule_at(