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

dataface/core/compile/resolve/area.py

@@ -22,9 +22,12 @@ from dataface.core.compile.models.style.resolved import (
     build_resolved_axis,
 )
 from dataface.core.compile.resolve._axes import (
+    _author_asked_for_endpoint_labels,
+    _author_hid_legend,
     _bake_ay_orient,
     _bake_cartesian_axes,
     _edge_or_none,
+    _endpoint_labels_off_for_layers,
     _extract_axis_overrides,
     _series_label_layout_for_width,
     _suppress_legend_for_endpoint_labels,
@@ -204,17 +207,22 @@ def _resolve_area(
     board_rcs = board_style.charts
     chart_rcs = build_resolved_style(board_style, normalized)
     area = chart_rcs.area
-    endpoint_labels, show_top_legend = _series_label_layout_for_width(
-        area.endpoint_labels, width
-    )
     primary = _with_color_tokens(normalized.style, board_style)
+    endpoint_labels, tiny_top_legend = _series_label_layout_for_width(
+        _endpoint_labels_off_for_layers(
+            area.endpoint_labels,
+            normalized,
+            _author_asked_for_endpoint_labels(normalized.style),
+        ),
+        width,
+    )
     channels = _channels_for(normalized, data)
     wide_measure_series = isinstance(normalized.y, list)
     x_ch_type = _classify_to_channel_type(normalized.x, data, is_dimension=True)
     resolved_stack = normalized.stack if normalized.stack is not None else area.stack
     _validate_area_encoding(normalized, data, x_ch_type, resolved_stack)
     ax_ov = _extract_axis_overrides(primary, normalized.x_label, normalized.y_label)
-    ax_merged, ay_merged = _bake_cartesian_axes(
+    ax_merged, ay_merged, ax_band_position, ay_band_position = _bake_cartesian_axes(
         chart_rcs,
         normalized,
         "area",
@@ -232,7 +240,8 @@ def _resolve_area(
         endpoint_labels.visible,
         wide_measure_series=wide_measure_series,
     )
-    authored_y_domain = ay_merged.scale.domain if ay_merged.scale is not None else None
+    _ay_cont_area = ay_merged.scale.continuous if ay_merged.scale is not None else None
+    authored_y_domain = _ay_cont_area.domain if _ay_cont_area is not None else None
     stable_extent = _eligible_stable_extent(ay_merged, stable_y_domain)
     _area_axis_values = list(stable_extent) if stable_extent else _area_floats
     if y_field_area:
@@ -247,10 +256,15 @@ def _resolve_area(
     # The layer ambiguity check must see the pre-workaround domain state: it is
     # about an authored chart-level domain, not the synthetic area-log domain.
     _reject_non_positive_log_scale_data(normalized.id, ay_merged, _log_y_fields, data)
+    _ay_cont_log = ay_merged.scale.continuous if ay_merged.scale is not None else None
     if (
-        ay_merged.scale is not None
-        and ay_merged.scale.type == "log"
-        and resolved_stack not in (None, "none")
+        _ay_cont_log is not None
+        and _ay_cont_log.type == "log"
+        and resolved_stack
+        not in (
+            None,
+            "none",
+        )
     ):
         raise CompilationError.from_code(
             ERR_AREA_STACKED_LOG_SCALE_NOT_SUPPORTED,
@@ -259,9 +273,9 @@ def _resolve_area(
         )
     if (
         _log_y_fields
-        and ay_merged.scale is not None
-        and ay_merged.scale.type == "log"
-        and ay_merged.scale.domain is None
+        and _ay_cont_log is not None
+        and _ay_cont_log.type == "log"
+        and _ay_cont_log.domain is None
     ):
         # Vega-Lite's automatic domain inference degenerates for an area mark
         # on a log scale with no explicit domain (verified: renders as a flat
@@ -275,11 +289,14 @@ def _resolve_area(
         _log_y_floats = [
             v for field in _log_y_fields for v in numeric_column_values(data, field)
         ]
-        if _log_y_floats:
+        if _log_y_floats and ay_merged.scale is not None:
+            _new_cont = _ay_cont_log.model_copy(
+                update={"domain": [min(_log_y_floats), max(_log_y_floats)]}
+            )
             ay_merged = ay_merged.model_copy(
                 update={
                     "scale": ay_merged.scale.model_copy(
-                        update={"domain": [min(_log_y_floats), max(_log_y_floats)]}
+                        update={"continuous": _new_cont}
                     )
                 }
             )
@@ -341,9 +358,10 @@ def _resolve_area(
     area_domain_max = area_ticks.domain_max if _non_stacked_area else None
     area_domain_min = area_ticks.domain_min if _non_stacked_area else None
     # Area's x is always a bottom-orient temporal/ordinal axis — no left/right edge.
-    ax = build_resolved_axis(ax_merged, edge=None)
+    ax = build_resolved_axis(ax_merged, band_position=ax_band_position, edge=None)
     ay = build_resolved_axis(
         ay_merged,
+        band_position=ay_band_position,
         edge=_edge_or_none(ay_merged.position),
         tick_values=area_ticks.ticks,
         domain_max=area_domain_max if area_domain_max is not None else ...,
@@ -382,7 +400,9 @@ def _resolve_area(
         if line_overrides:
             line_mark_merged = line_mark_merged.model_copy(update=line_overrides)
     line_mark_merged = line_mark_merged.model_copy(
-        update={"labels": _label_format_fallback(line_mark_merged.labels, ay.format)}
+        update={
+            "labels": _label_format_fallback(line_mark_merged.labels, ay.labels.format)
+        }
     )
     # Density-adaptive stroke for area's top-edge line.  For stacked charts the
     # effective stroke is on the stacked perimeter (already merged above into
@@ -440,7 +460,7 @@ def _resolve_area(
     # visually track the line width).
     resolved_area_mark = _build_resolved_area_mark(area_mark_merged)
     resolved_line_mark = _build_resolved_area_line(line_mark_merged)
-    area_style_tail = _cartesian_style_tail(board_rcs, board_style, ax, ay)
+    area_style_tail = _cartesian_style_tail(board_rcs, ax, ay)
     _area_fmt = _measure_tooltip_format(normalized, primary, board_rcs)
     if _area_fmt:
         area_style_tail["tooltip_format"] = _area_fmt
@@ -459,12 +479,22 @@ def _resolve_area(
         _effective_palette(board_rcs, primary),
         requested_alias_palette=_effective_requested_alias_palette(board_rcs, primary),
         automatic_link_candidate=automatic_link_candidate,
+        layout_padding=area.padding,
         suppress_legend=_suppress_legend_for_endpoint_labels(
             channels,
             endpoint_labels.visible,
+            bool(normalized.layers),
             wide_measure_series=wide_measure_series,
         ),
-        show_top_legend=show_top_legend,
+        top_legend=(
+            "off"
+            if _author_hid_legend(primary)
+            else (
+                "compact"
+                if tiny_top_legend
+                else ("row" if normalized.layers else "off")
+            )
+        ),
     )
     resolved_layers = _resolve_layer_list(
         normalized.layers,
@@ -478,7 +508,7 @@ def _resolve_area(
         _check_layers_y_domain(normalized.id, resolved_layers, authored_y_domain)
     return ResolvedAreaChart(
         **bkw,
-        **_cartesian_kwargs(normalized, board_rcs, variables),
+        **_cartesian_kwargs(normalized, chart_rcs, variables),
         chart_type="area",
         stack=resolved_stack,
         style=ResolvedAreaStyle(

dataface/core/compile/resolve/bar.py

@@ -7,25 +7,33 @@ from typing import Any
 
 from dataface.core.compile.errors import CompilationError
 from dataface.core.compile.merge import merge_onto_base
+from dataface.core.compile.models.chart.authored._data_table import (
+    ChartDataTablePerSeries,
+)
 from dataface.core.compile.models.chart.normalized import (
     BarChart,
 )
 from dataface.core.compile.models.chart.resolved import (
     ResolvedBarChart,
 )
+from dataface.core.compile.models.style.authored import EndpointLabelsConfig
 from dataface.core.compile.models.style.resolved import (
     ResolvedBarStyle,
     ResolvedStyle,
     build_resolved_axis,
 )
 from dataface.core.compile.models.style.theme import (
-    ScaleStyle,
+    BaseScaleStyle,
+    ScaleContinuousStyle,
 )
 from dataface.core.compile.resolve._axes import (
+    _author_asked_for_endpoint_labels,
+    _author_hid_legend,
     _bake_ay_orient,
     _bake_ay_position_left,
     _bake_cartesian_axes,
     _edge_or_none,
+    _endpoint_labels_off_for_layers,
     _extract_axis_overrides,
     _series_label_layout_for_width,
     _suppress_legend_for_endpoint_labels,
@@ -86,6 +94,10 @@ from dataface.core.diagnostics.codes_compile import (
     ERR_BAR_LOG_SCALE_NOT_SUPPORTED,
     ERR_BAR_Y_NOT_NUMERIC,
 )
+from dataface.core.utils import (
+    numeric_column_values,
+    stacked_x_domain_order,
+)
 
 __all__ = [
     "_resolve_bar",
@@ -93,6 +105,125 @@ __all__ = [
 ]
 
 
+def _bar_endpoint_labels_for_stack(
+    endpoint_labels: EndpointLabelsConfig,
+    normalized: BarChart,
+    data: ChartRows,
+    stack_mode: str,
+    horizontal: bool,
+    author_opted_in: bool,
+) -> EndpointLabelsConfig:
+    """Direct labelling is the default; the disqualifiers below turn it back off.
+
+    Every disqualifier here steers the *default* away from a shape it would
+    render badly or not at all. An author who wrote
+    ``style.endpoint_labels.visible: true`` on this chart has said they want
+    the rail on that shape, so ``author_opted_in`` returns the cascaded value
+    untouched: grouped bars label at their bar tops as they always have, and
+    the shapes render refuses (a negative measure, a sorted or centre-stacked
+    horizontal rail, ``multiples:``) raise there with a message naming the
+    conflict. Quietly dropping the rail instead would be neither.
+    """
+    if author_opted_in:
+        return endpoint_labels
+    if normalized.data_table is not None and any(
+        isinstance(entry, ChartDataTablePerSeries) and not entry.by_measure
+        for entry in normalized.data_table.entries
+    ):
+        # A per-series data table already prints one row per series, labelled
+        # in that series' own ink — the rail would name them a second time,
+        # and it costs the plot the height and the axis side it needs.
+        return endpoint_labels.model_copy(update={"visible": False})
+    if stack_mode == "none":
+        # Grouped: every series' last bar rises from the same baseline to a
+        # similar height, so the collision cascade squashes the labels
+        # together. A legend is the honest treatment.
+        return endpoint_labels.model_copy(update={"visible": False})
+    if normalized.multiples is not None:
+        # Each small multiple is its own panel; the rail has no single panel
+        # to sit beside, and FacetFeature refuses the composition outright.
+        return endpoint_labels.model_copy(update={"visible": False})
+    y_fields = (
+        (normalized.y,)
+        if isinstance(normalized.y, str)
+        else tuple(normalized.y) if isinstance(normalized.y, list) else ()
+    )
+    # A negative (zero-crossing) measure breaks the cumulative-midpoint
+    # computation; the render layer raises rather than mislabel. Stack mode
+    # zero/normalize/center all reach that raise, so this check runs
+    # regardless of which one resolved_stack picked.
+    if any(v < 0 for v in _numeric_y_values(data, y_fields)):
+        return endpoint_labels.model_copy(update={"visible": False})
+    # author_opted_in is False by construction here — the opt-in returned above.
+    endpoint_labels = _endpoint_labels_off_for_layers(
+        endpoint_labels, normalized, author_opted_in
+    )
+    if not endpoint_labels.visible:
+        return endpoint_labels
+    if normalized.sort is not None and not numeric_column_values(
+        data, normalized.sort.by
+    ):
+        # Both rails reproduce Vega-Lite's domain order by totalling the sort
+        # column per category. On a non-numeric column VL concatenates the
+        # strings instead, an order this cannot mirror — so the rail would
+        # anchor on a row VL does not draw on top.
+        return endpoint_labels.model_copy(update={"visible": False})
+    if horizontal and stack_mode == "center":
+        # The horizontal rail anchors on the cumulative (0..Σ) axis, which the
+        # diverging center-stack domain doesn't have.
+        return endpoint_labels.model_copy(update={"visible": False})
+    if not _every_series_reaches_the_last_column(
+        normalized, data, y_fields, horizontal
+    ):
+        return endpoint_labels.model_copy(update={"visible": False})
+    return endpoint_labels
+
+
+def _every_series_reaches_the_last_column(
+    normalized: BarChart,
+    data: ChartRows,
+    y_fields: tuple[str, ...],
+    horizontal: bool,
+) -> bool:
+    """True when the final x column carries a segment for every series.
+
+    A stacked bar's labels anchor to that column's segment midpoints, so a
+    series absent from it has nothing to anchor to and goes unnamed while its
+    colour stays in the chart — the reader counts more colours than names.
+    Two shapes hit this: a trailing null, and ``color:`` naming the same field
+    as ``x:``, which gives every series a single distinct column.
+    """
+    color = normalized.color
+    x = normalized.x
+    if not isinstance(color, str) or not isinstance(x, str):
+        return True
+    # Each orientation anchors its rail on a different end of the rendered x
+    # domain, so ask the same question the rail will: the vertical midpoint
+    # path takes the last column (_stacked_midpoints), the horizontal rail the
+    # first row (_cumulative_midpoints), both over the order stacked_x_domain_order
+    # computes in render/chart/features/endpoint_labels.py — which an authored
+    # `sort:` moves. A wholly null anchor row still owns the rail.
+    sort = normalized.sort
+    domain = stacked_x_domain_order(
+        data, x, sort.by if sort else "", bool(sort and sort.order == "desc")
+    )
+    if not domain:
+        return True
+    last_x = domain[0] if horizontal else domain[-1]
+    every_series: set[str] = set()
+    drawn_at_last: set[str] = set()
+    for row in data:
+        series = row.get(color)
+        if series is None:
+            continue
+        every_series.add(series)
+        if row.get(x) == last_x and any(
+            row.get(field) is not None for field in y_fields
+        ):
+            drawn_at_last.add(series)
+    return drawn_at_last == every_series
+
+
 def _resolve_bar(
     normalized: BarChart,
     data: ChartRows,
@@ -106,9 +237,10 @@ def _resolve_bar(
     board_rcs = board_style.charts
     chart_rcs = build_resolved_style(board_style, normalized)
     bar = chart_rcs.bar
-    endpoint_labels, show_top_legend = _series_label_layout_for_width(
-        bar.endpoint_labels, width
-    )
+    # Flat chart.stack overrides style.bar.stack; fall through to the merged bar
+    # style (which already applied style.bar.stack → board theme cascade) so that
+    # per-chart style overrides are respected even when chart.stack is None.
+    resolved_stack = normalized.stack if normalized.stack is not None else bar.stack
     primary = _with_color_tokens(normalized.style, board_style)
     channels = _channels_for(normalized, data)
     x_ch_type = _classify_to_channel_type(normalized.x, data, is_dimension=True)
@@ -130,7 +262,7 @@ def _resolve_bar(
             hint=_bar_y_hint,
         )
     ax_ov = _extract_axis_overrides(primary, normalized.x_label, normalized.y_label)
-    ax_merged, ay_merged = _bake_cartesian_axes(
+    ax_merged, ay_merged, ax_band_position, ay_band_position = _bake_cartesian_axes(
         chart_rcs,
         normalized,
         "bar",
@@ -146,56 +278,83 @@ def _resolve_bar(
     # both for the categorical axis's edge below and the chart's own
     # resolved `orientation` field at the bottom of this function.
     orientation = _bar_orientation(normalized, data, ax_merged.time_unit is not None)
-    ay_merged = _bake_ay_orient(ay_merged, channels, endpoint_labels.visible)
-    # Bar's categorical axis (axis_x) only has a left/right edge when the
-    # chart is horizontal — it then renders on VL's y channel at
-    # ay.categorical_orient (see emitters/bar.py's own-orient swap). A
-    # vertical bar's x stays bottom-orient — no edge.
-    x_edge = (
-        _edge_or_none(ay_merged.categorical_orient)
-        if orientation == "horizontal"
-        else None
+    # Resolved after orientation: two of the disqualifiers below are specific to
+    # the horizontal rail, and the last-column check anchors differently per
+    # orientation.
+    endpoint_labels, tiny_top_legend = _series_label_layout_for_width(
+        _bar_endpoint_labels_for_stack(
+            bar.endpoint_labels,
+            normalized,
+            data,
+            resolved_stack,
+            orientation == "horizontal",
+            _author_asked_for_endpoint_labels(normalized.style),
+        ),
+        width,
     )
-    # Propagate chart-level scale.band_padding_inner to ax.scale so the emitter
-    # can read ax.scale.band_padding_inner without re-examining primary.scale.
-    # (In V1 this flowed via effective.scale → SCALE_FIELD_MAP; V2 reads ax.scale.)
-    _chart_scale = primary.scale if primary is not None else None
-    if _chart_scale is not None and _chart_scale.band_padding_inner is not None:
-        existing_ax_scale = (
-            ax_merged.scale if ax_merged.scale is not None else ScaleStyle()
-        )
-        ax_merged = ax_merged.model_copy(
-            update={
-                "scale": existing_ax_scale.model_copy(
-                    update={"band_padding_inner": _chart_scale.band_padding_inner}
-                )
-            }
-        )
-    # Propagate bar.scale.zero (theme→face cascade result) to ay.scale so the
-    # emitter's ay_scale_zero check reflects an authored explicit zero override.
+    if orientation == "horizontal":
+        # For horizontal bar, ay (the semantic measure axis) maps to VL x,
+        # which has no left/right orient — _emit_horizontal pops it entirely.
+        # ay.position's only remaining role is supplying the swapped
+        # categorical axis's (VL y) orient in emitters/bar.py. The deleted
+        # categorical_orient field always defaulted "left" there, statically —
+        # the horizontal rail sits above the plot (top-row), never left/right,
+        # so it never competes for this axis's side the way the vertical
+        # endpoint-label rail does. Preserve the static default via
+        # _bake_ay_position_left rather than _bake_ay_orient's
+        # endpoint-label-aware auto-resolution.
+        ay_merged = _bake_ay_position_left(ay_merged)
+    else:
+        ay_merged = _bake_ay_orient(ay_merged, channels, endpoint_labels.visible)
+    # Bar's categorical axis (axis_x) only has a left/right edge when the
+    # chart is horizontal — it then renders on VL's y channel at ay.position
+    # (see emitters/bar.py's own-orient swap; categorical_orient was deleted
+    # 2026-08 — position now serves this role too). A vertical bar's x stays
+    # bottom-orient — no edge.
+    x_edge = _edge_or_none(ay_merged.position) if orientation == "horizontal" else None
+    # Propagate bar.scale.continuous.zero (theme→face cascade result) to ay.scale
+    # so the emitter's ay_scale_zero check reflects an authored explicit zero override.
     # Only concrete bools are propagated; "auto"/None means run the picker default
     # (non-stacked bars always anchor at zero by default).
     _bar_scale = bar.scale
-    if _bar_scale is not None and isinstance(_bar_scale.zero, bool):
-        existing_ay_scale = (
-            ay_merged.scale if ay_merged.scale is not None else ScaleStyle()
-        )
-        ay_merged = ay_merged.model_copy(
-            update={
-                "scale": existing_ay_scale.model_copy(update={"zero": _bar_scale.zero})
-            }
-        )
-    if ay_merged.scale is not None and ay_merged.scale.type == "log":
+    _bar_zero = (
+        _bar_scale.continuous.zero
+        if _bar_scale is not None and _bar_scale.continuous is not None
+        else None
+    )
+    if isinstance(_bar_zero, bool):
+        existing_ay_scale = ay_merged.scale
+        if existing_ay_scale is not None:
+            old_cont = existing_ay_scale.continuous
+            new_cont = (
+                old_cont.model_copy(update={"zero": _bar_zero})
+                if old_cont is not None
+                else ScaleContinuousStyle(zero=_bar_zero)
+            )
+            ay_merged = ay_merged.model_copy(
+                update={
+                    "scale": existing_ay_scale.model_copy(
+                        update={"continuous": new_cont}
+                    )
+                }
+            )
+        else:
+            ay_merged = ay_merged.model_copy(
+                update={
+                    "scale": BaseScaleStyle(
+                        continuous=ScaleContinuousStyle(zero=_bar_zero)
+                    )
+                }
+            )
+    _ay_cont_log = ay_merged.scale.continuous if ay_merged.scale is not None else None
+    if _ay_cont_log is not None and _ay_cont_log.type == "log":
         raise CompilationError.from_code(
             ERR_BAR_LOG_SCALE_NOT_SUPPORTED,
             chart_id=normalized.id,
         )
-    # Flat chart.stack overrides style.bar.stack; fall through to the merged bar
-    # style (which already applied style.bar.stack → board theme cascade) so that
-    # per-chart style overrides are respected even when chart.stack is None.
-    resolved_stack = normalized.stack if normalized.stack is not None else bar.stack
     is_stacked = resolved_stack not in (None, "none")
-    ay_scale_zero = ay_merged.scale.zero if ay_merged.scale is not None else None
+    _ay_cont_zero = ay_merged.scale.continuous if ay_merged.scale is not None else None
+    ay_scale_zero = _ay_cont_zero.zero if _ay_cont_zero is not None else None
     # Non-stacked bars anchor at zero by default unless scale.zero is explicitly False.
     # Stacked bars only anchor when scale.zero is explicitly True.
     bar_zero = (not is_stacked and ay_scale_zero is not False) or ay_scale_zero is True
@@ -209,7 +368,7 @@ def _resolve_bar(
     stable_extent = _eligible_stable_extent(
         ay_merged, stable_y_domain, stacked=is_stacked
     )
-    authored_y_domain = ay_merged.scale.domain if ay_merged.scale is not None else None
+    authored_y_domain = _ay_cont_zero.domain if _ay_cont_zero is not None else None
     if resolved_stack == "normalize" or not y_fields:
         # normalize-stack domain is always [0,1]; no y_field means no ticks.
         tick_values: tuple[float, ...] = ()
@@ -258,15 +417,16 @@ def _resolve_bar(
             stacked_domain_max = apply_headroom(
                 _raw_stacked_max, _axis_headroom(ay_merged)
             )
-    ax = build_resolved_axis(ax_merged, edge=x_edge)
+    ax = build_resolved_axis(ax_merged, band_position=ax_band_position, edge=x_edge)
     ay = build_resolved_axis(
         ay_merged,
+        band_position=ay_band_position,
         edge=_edge_or_none(ay_merged.position),
         tick_values=tick_values,
         domain_max=bar_domain_max if bar_domain_max is not None else ...,
         domain_min=bar_domain_min if bar_domain_min is not None else ...,
     )
-    style_tail = _cartesian_style_tail(board_rcs, board_style, ax, ay)
+    style_tail = _cartesian_style_tail(board_rcs, ax, ay)
     _bar_fmt = _measure_tooltip_format(normalized, primary, board_rcs)
     if _bar_fmt:
         style_tail["tooltip_format"] = _bar_fmt
@@ -285,10 +445,18 @@ def _resolve_bar(
         _effective_palette(board_rcs, primary),
         requested_alias_palette=_effective_requested_alias_palette(board_rcs, primary),
         automatic_link_candidate=automatic_link_candidate,
+        layout_padding=bar.padding,
         suppress_legend=_suppress_legend_for_endpoint_labels(
-            channels, endpoint_labels.visible
+            channels, endpoint_labels.visible, bool(normalized.layers)
+        ),
+        # A grouped bar keeps its legend (see _bar_endpoint_labels_for_stack)
+        # and reads left to right, so the legend belongs above the plot in the
+        # same order as the bars within a group — not down a side rail.
+        top_legend=(
+            "off"
+            if _author_hid_legend(primary)
+            else "compact" if tiny_top_legend else ("row" if not is_stacked else "off")
         ),
-        show_top_legend=show_top_legend,
     )
     resolved_layers = _resolve_layer_list(
         normalized.layers, board_style, "bar", bar, normalized.query_name, 0.0
@@ -299,19 +467,19 @@ def _resolve_bar(
     # label: if either format is None, inherit the resolved measure-axis format.
     raw_total = bar.marks.bar.total_label
     resolved_total = (
-        raw_total.model_copy(update={"format": ay.format})
-        if raw_total.format is None and ay.format is not None
+        raw_total.model_copy(update={"format": ay.labels.format})
+        if raw_total.format is None and ay.labels.format is not None
         else raw_total
     )
     bar_mark = bar.marks.bar.model_copy(
         update={
-            "labels": _label_format_fallback(bar.marks.bar.labels, ay.format),
+            "labels": _label_format_fallback(bar.marks.bar.labels, ay.labels.format),
             "total_label": resolved_total,
         }
     )
     return ResolvedBarChart(
         **bkw,
-        **_cartesian_kwargs(normalized, board_rcs, variables),
+        **_cartesian_kwargs(normalized, chart_rcs, variables),
         chart_type="bar",
         stack=resolved_stack,
         stacked_domain_max=stacked_domain_max,
@@ -351,22 +519,28 @@ def _resolve_histogram(
     histogram.marks.bar.border apply correctly.
     """
     board_rcs = board_style.charts
+    chart_rcs = build_resolved_style(board_style, normalized)
     primary = _with_color_tokens(normalized.style, board_style)
     hist = merge_onto_base(board_rcs.histogram, primary)
     channels = _channels_for(normalized, data)
     x_ch_type = _classify_to_channel_type(normalized.x, data, is_dimension=True)
     ax_ov = _extract_axis_overrides(primary, normalized.x_label, normalized.y_label)
-    # board_rcs (not chart_rcs) suffices here: histogram never calls
-    # build_resolved_style, and axis Layers 4-6 (chart-local overrides) reach
-    # the cascade via ax_ov regardless of which rcs backs Layers 1-3.
-    ax_merged, ay_merged = _bake_cartesian_axes(
+    # board_rcs (not chart_rcs) suffices for axis baking: axis Layers 4-6
+    # (chart-local overrides) reach the cascade via ax_ov regardless of which
+    # rcs backs Layers 1-3. chart_rcs is only needed below for the shared
+    # background/title-case kwargs, which are genuinely chart-local decisions.
+    ax_merged, ay_merged, ax_band_position, ay_band_position = _bake_cartesian_axes(
         board_rcs, normalized, "histogram", x_ch_type, "quantitative", ax_ov
     )
     ay_merged = _bake_ay_position_left(ay_merged)
     # Histogram's x is always a bottom-orient bin axis — no left/right edge.
-    ax = build_resolved_axis(ax_merged, edge=None)
-    ay = build_resolved_axis(ay_merged, edge=_edge_or_none(ay_merged.position))
-    style_tail = _cartesian_style_tail(board_rcs, board_style, ax, ay)
+    ax = build_resolved_axis(ax_merged, band_position=ax_band_position, edge=None)
+    ay = build_resolved_axis(
+        ay_merged,
+        band_position=ay_band_position,
+        edge=_edge_or_none(ay_merged.position),
+    )
+    style_tail = _cartesian_style_tail(board_rcs, ax, ay)
     # histogram reuses ResolvedBarStyle; these bar-only fields are unread by
     # the histogram emit path (no stack, no endpoint labels, no grouped x offset).
     _s = normalized.style
@@ -387,8 +561,9 @@ def _resolve_histogram(
                 board_rcs, primary
             ),
             automatic_link_candidate=automatic_link_candidate,
+            layout_padding=hist.padding,
         ),
-        **_cartesian_kwargs(normalized, board_rcs, variables),
+        **_cartesian_kwargs(normalized, chart_rcs, variables),
         chart_type="histogram",
         stack="none",
         stacked_domain_max=None,
@@ -404,7 +579,13 @@ def _resolve_histogram(
                 rhythm_slot=normalized.rhythm_slot,
                 has_layers=bool(normalized.layers),
             ),
-            endpoint_labels=board_rcs.bar.endpoint_labels,
+            # A histogram bins x and aggregates y to a count, so there is no
+            # per-row value for a rail to anchor to — it would place labels
+            # against a measure the chart never plots. Bar's slot supplies the
+            # rest of the style; this one field is off for the family.
+            endpoint_labels=board_rcs.bar.endpoint_labels.model_copy(
+                update={"visible": False}
+            ),
             label_usable_ratio=board_rcs.label_usable_ratio,
             title_font=_tf,
             **style_tail,