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

dataface/core/font_measure.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import math
+
 from dataface.core.fonts import (
     SOURCE_CODE_PRO_FONT_FAMILY,
     SOURCE_SERIF_4_FONT_FAMILY,
@@ -43,6 +45,32 @@ def get_font_measurer(
     return _load_measurer(get_font_path(font_family, numeric=numeric))
 
 
+def suffix_reservation_slots(suffix: str, font_family: str) -> int:
+    """Digit-width slots a magnitude suffix needs against ``font_family``.
+
+    ``ceil(suffix_advance / digit_advance)`` — not character count. A
+    suffix's advance is not an integer multiple of the digit width even in a
+    tabular face, so the slot count is quantised and leaves a sub-digit
+    residual: the reservation makes a column scan, it does not make the
+    digits share an exact x. Character count under-reserves ``mn``: its
+    advance is 2.26 digit-widths, so a 2-character reservation would leave
+    the suffix overrunning the column by a quarter digit.
+
+    Both digit and suffix are measured through
+    ``get_font_measurer(font_family, numeric=True)`` — the same numeric-face
+    resolution every render call site uses, which always resolves to the
+    tabular face digits actually paint in regardless of the surrounding body
+    font, and degrades an unvendored family the same way every other numeral
+    measurement does.
+    """
+    if not suffix:
+        return 0
+    measurer = get_font_measurer(font_family, numeric=True)
+    digit_advance = measurer.measure("0", 1.0)
+    suffix_advance = measurer.measure(suffix, 1.0)
+    return math.ceil(suffix_advance / digit_advance)
+
+
 def css_weight_to_axis(weight: str | float) -> float:
     """Convert a CSS ``font-weight`` value to a variable-font ``wght`` axis value."""
     if isinstance(weight, (int, float)):

dataface/core/fonts.py

@@ -151,7 +151,7 @@ FONT_REGISTRY: tuple[VendoredFace, ...] = (
         web_file="NotoColorEmoji-Regular.woff2",
         unicode_range=_EMOJI_UNICODE_RANGES,
     ),
-    # No web_file below this line. See VendoredFace.web_file.
+    # Source Code Pro is the only measure-only row. See VendoredFace.web_file.
     VendoredFace(
         family=SOURCE_CODE_PRO_FONT_FAMILY,
         style="normal",
@@ -164,16 +164,19 @@ FONT_REGISTRY: tuple[VendoredFace, ...] = (
     VendoredFace(
         family=DFT_SERIF_OLDSTYLE_TABULAR_FONT_FAMILY,
         style="normal",
-        # Vendored and registered for ReportLab, but no built-in theme emits it; it is
-        # reachable only if an author names it in a theme font stack.
+        # No built-in theme emits either oldstyle face; both are reachable by naming
+        # them in a theme font stack. That is why they are served rather than
+        # measure-only — selecting oldstyle figures through `font-feature-settings`
+        # instead does not survive static export (see fonts/README.md), so the family
+        # is the only route, and a family the browser cannot download is not a route.
         measure_file="DFTSerifOldstyleTabular-Regular.ttf",
-        web_file=None,
+        web_file="DFTSerifOldstyleTabular-Regular.woff2",
     ),
     VendoredFace(
         family=DFT_SERIF_OLDSTYLE_PROPORTIONAL_FONT_FAMILY,
         style="normal",
         measure_file="DFTSerifOldstyleProportional-Regular.ttf",
-        web_file=None,
+        web_file="DFTSerifOldstyleProportional-Regular.woff2",
     ),
 )
 

dataface/core/inspect/__init__.py

@@ -6,12 +6,18 @@ open-source components: DbtSchemaSource, LayeredSchemaResolver, schema
 search, and the HTML inspect templates.
 """
 
-from dataface.core.inspect.renderer import (
-    InspectProfileCompileError,
-    render_inspect_dashboard,
-    resolve_source_name,
-    validate_inspect_variables,
-)
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from dataface.core.inspect.renderer import (
+        InspectProfileCompileError,
+        render_inspect_dashboard,
+        resolve_source_name,
+        validate_inspect_variables,
+    )
 
 # Static list of available inspect templates.
 # Template files live in dataface/core/inspect/templates/{name}.yml
@@ -32,3 +38,37 @@ __all__ = [
     "validate_inspect_variables",
     "INSPECT_TEMPLATES",
 ]
+
+# Submodule (sources/, db_types, etc.) imports run this __init__ first, so
+# these re-exports must not eagerly pull in renderer's (and transitively
+# core.compile's) heavy import chain just to expose INSPECT_TEMPLATES.
+_LAZY_ATTRS: dict[str, tuple[str, str]] = {
+    "InspectProfileCompileError": (
+        "dataface.core.inspect.renderer",
+        "InspectProfileCompileError",
+    ),
+    "render_inspect_dashboard": (
+        "dataface.core.inspect.renderer",
+        "render_inspect_dashboard",
+    ),
+    "resolve_source_name": ("dataface.core.inspect.renderer", "resolve_source_name"),
+    "validate_inspect_variables": (
+        "dataface.core.inspect.renderer",
+        "validate_inspect_variables",
+    ),
+}
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        module_path, attr_name = _LAZY_ATTRS[name]
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+    module = importlib.import_module(module_path)
+    value = getattr(module, attr_name)
+    globals()[name] = value  # cache: repeated access is O(1) and `is` identity holds
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_LAZY_ATTRS))

dataface/core/project.py

@@ -5,7 +5,7 @@ import re
 from abc import ABC, abstractmethod
 from collections.abc import Iterable, Iterator
 from functools import cached_property
-from pathlib import PurePosixPath, PureWindowsPath
+from pathlib import PurePath, PurePosixPath, PureWindowsPath
 from posixpath import normpath
 from typing import TYPE_CHECKING, Any, NamedTuple
 
@@ -56,6 +56,18 @@ def assert_relpath(ref: str, anchor: str = ".") -> None:
         raise ValueError(f"file ref {ref!r} would escape above the project root")
 
 
+def posix_relpath(path: PurePath, root: PurePath) -> str:
+    """Project-relative POSIX identity for *path* under *root*.
+
+    ``str(Path.relative_to(...))`` emits the OS-native separator — a no-op on
+    POSIX, but backslashes on Windows, which ``assert_relpath`` then rejects.
+    File identity is always a POSIX relpath, so normalize with ``as_posix()``.
+    *path* and *root* are typed ``PurePath`` (not ``PurePosixPath``) because
+    real callers pass OS-native ``Path`` objects from disk.
+    """
+    return path.relative_to(root).as_posix()
+
+
 # Directories skipped when walking the project tree for files.
 # A host that overrides Project's file-access methods (e.g. CloudManagedProject's
 # git-blob reader) applies the same filter without duplicating the set.

dataface/core/render/chart/data_table_attachment.py

@@ -903,7 +903,7 @@ def _label_stub_left_layer(
 ) -> dict[str, Any]:
     """Left-gutter label layer anchored to the left y-axis tick column.
 
-    x = -axis_y.label.padding (same column as left-oriented y-axis tick labels,
+    x = -axis_y.labels.padding (same column as left-oriented y-axis tick labels,
     which extend leftward from x=0 with text-anchor end / align right).
     mark.limit caps the text width so VL's autosize does not shrink the plot.
 
@@ -912,7 +912,8 @@ def _label_stub_left_layer(
     """
     axis_label_padding = resolved_axis_style(
         charts_style, "axis_y", "quantitative"
-    ).label.padding
+    ).labels.padding
+    assert axis_label_padding is not None, "axis_y.labels.padding unset"
     x_pixel = -axis_label_padding
     mark = _label_mark_props(style, align="right")
     if limit is not None:
@@ -944,7 +945,7 @@ def _label_stub_right_layer(
 ) -> dict[str, Any]:
     """Right-cap label layer anchored to the right y-axis tick column.
 
-    x = spec_width + axis_y.label.padding (same column as right-oriented y-axis
+    x = spec_width + axis_y.labels.padding (same column as right-oriented y-axis
     tick labels, which extend rightward from that anchor with text-anchor start /
     align left). mark.limit caps the text width so VL's autosize does not shrink
     the plot.
@@ -954,7 +955,8 @@ def _label_stub_right_layer(
     """
     axis_label_padding = resolved_axis_style(
         charts_style, "axis_y", "quantitative"
-    ).label.padding
+    ).labels.padding
+    assert axis_label_padding is not None, "axis_y.labels.padding unset"
     x_pixel = spec_width + axis_label_padding
     mark = _label_mark_props(style, align="left")
     if limit is not None:
@@ -1042,8 +1044,8 @@ def attach_data_table(
         axis_y_orient: Resolved y-axis orient — ``"right"`` or ``"left"``
             (line charts with right-edge endpoint labels). Determines which label
             emitter fires: right-oriented → label at ``spec_width +
-            axis_y.label.padding`` with ``align: left``; left-oriented → label at
-            ``-axis_y.label.padding`` with ``align: right``. Required — callers must
+            axis_y.labels.padding`` with ``align: left``; left-oriented → label at
+            ``-axis_y.labels.padding`` with ``align: right``. Required — callers must
             resolve this from the chart's axis_y.orient before calling.
 
     Returns:
@@ -1643,13 +1645,13 @@ def _label_period_filter_expr(
         axis_st = resolved_axis_style(
             resolved_chart_style, "axis_x", x_type or "temporal", ct_axis_x
         )
-        raw_label_tu = axis_st.label.time_unit
+        raw_label_tu = axis_st.labels.time_unit
         # Chart-local authored label.time_unit wins when the board-level style
         # has no override — the resolver merges chart-local style into the chart's
         # resolved style object, not back into charts_style, so the fallback reads
         # directly from the chart-local axis_x that was baked into the resolved chart.
         if raw_label_tu is None and chart_local_axis_x is not None:
-            raw_label_tu = chart_local_axis_x.label.time_unit
+            raw_label_tu = chart_local_axis_x.labels.time_unit
         format_tu = resolve_label_time_unit(dft_time_unit, raw_label_tu)
         if not format_tu:
             return None
@@ -1670,14 +1672,14 @@ def _label_period_filter_expr(
         if not x_distinct or spec_width / len(x_distinct) >= _LABEL_STRIP_MIN_BAND_PX:
             return None
         safe_field = x_field.replace("'", "\\'")
-        font = axis_st.label.font
+        font = axis_st.labels.font
         measurer = get_font_measurer(font.family)
         dates = sorted(datetime.date.fromisoformat(str(v)[:10]) for v in x_distinct)
         band = (spec_width * resolved_chart_style.label_usable_ratio) / len(dates)
         flush_axis = (
             chart_local_axis_x
             if chart_local_axis_x is not None
-            and chart_local_axis_x.label.flush is not None
+            and chart_local_axis_x.labels.flush is not None
             else axis_st
         )
         visibility_tu, _ = resolve_temporal_label_visibility(
@@ -1689,8 +1691,8 @@ def _label_period_filter_expr(
             band,
             axis_st.fiscal_year_start_month,
             allow_skip=(
-                axis_st.label.overlap.skip
-                if axis_st.label.overlap is not None
+                axis_st.labels.overlap.skip
+                if axis_st.labels.overlap is not None
                 else False
             ),
             edge_labels_flushed=temporal_edge_labels_flushed("temporal", flush_axis),

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

@@ -15,8 +15,10 @@ from typing import Any, NamedTuple
 
 from dataface.core.compile.models.chart.authored._annotations import ChartSort
 from dataface.core.compile.models.style.resolved import ResolvedChartsStyle
-from dataface.core.compile.models.style.resolved._base import ResolvedAxisStyle
-from dataface.core.compile.models.style.theme import ScaleStyle
+from dataface.core.compile.models.style.resolved._base import (
+    ResolvedAxisStyle,
+    ResolvedScaleStyle,
+)
 from dataface.core.compile.style_cascade import (
     chart_type_axis_patch,
     resolved_axis_style,
@@ -37,9 +39,8 @@ from dataface.core.render.chart.type_inference import (
     y_zero_scale,
 )
 from dataface.core.render.chart.vl_field_maps import (
-    SCALE_FIELD_MAP,
     axis_to_vl,
-    map_fields,
+    emit_resolved_scale_vl,
 )
 from dataface.core.render.utils import slug_to_text
 from dataface.core.text.case import format_display_text
@@ -56,7 +57,7 @@ _CONTINUOUS_VL_TYPES = frozenset({"temporal", "quantitative"})
 
 
 def cartesian_x_scale_domain(
-    scale: ScaleStyle | None, vl_type: str, chart_id: str
+    scale: ResolvedScaleStyle | None, vl_type: str, chart_id: str
 ) -> VLDict:
     """Return the VL x-scale ``domain`` entry for an authored cartesian x scale.
 
@@ -66,7 +67,8 @@ def cartesian_x_scale_domain(
     a band scale as exactly two categories, collapsing every mark onto the
     first one, rather than extending a continuous range.
     """
-    if scale is None or scale.domain is None:
+    _sc_cont = scale.continuous if scale is not None else None
+    if _sc_cont is None or _sc_cont.domain is None:
         return {}
     if vl_type not in _CONTINUOUS_VL_TYPES:
         raise ChartDataError.from_code(
@@ -74,7 +76,7 @@ def cartesian_x_scale_domain(
             chart_id=chart_id,
             vl_type=vl_type,
         )
-    return {"domain": list(scale.domain)}
+    return {"domain": list(_sc_cont.domain)}
 
 
 def chart_sort_to_vl(sort: ChartSort | None) -> VLDict | None:
@@ -272,24 +274,24 @@ def min_height_for_horizontal_bar_categories(
         "ordinal",
         chart_type_axis_patch(resolved_charts, "bar", "axis_x"),
     )
-    label = axis_x.label
+    label = axis_x.labels
     bar_mark = resolved_charts.marks.bar
     font_size = label.font.size
-    separation = label.separation
+    min_gap = label.min_gap
     padding = label.padding
     bar_size = bar_mark.size
     assert (
         font_size is not None
-    ), "axis_x.label.font.size unset — theme cascade must populate it"
+    ), "axis_x.labels.font.size unset — theme cascade must populate it"
     assert (
-        separation is not None
-    ), "axis_x.label.separation unset — theme cascade must populate it"
+        min_gap is not None
+    ), "axis_x.labels.min_gap unset — theme cascade must populate it"
     assert (
         padding is not None
-    ), "axis_x.label.padding unset — theme cascade must populate it"
+    ), "axis_x.labels.padding unset — theme cascade must populate it"
     assert bar_size is not None, "marks.bar.size unset — theme cascade must populate it"
     label_line = font_size + 2 * padding
-    band_step = max(bar_size, label_line) + separation
+    band_step = max(bar_size, label_line) + min_gap
     return _HORIZONTAL_BAR_LAYOUT_CHROME_PX + n_categories * band_step
 
 
@@ -326,13 +328,14 @@ def build_cartesian_y_encoding(
 
     Tick values from ay.tick_values are baked into ay_vl["values"] when present.
     Authored domain replaces the data-driven zero/domainMin computation, but
-    still carries type/base/exponent/constant (etc.) via SCALE_FIELD_MAP — a
-    domain and a scale type are not mutually exclusive (e.g. log needs both).
+    still carries type/base/exponent/constant (etc.) via emit_resolved_scale_vl
+    — a domain and a scale type are not mutually exclusive (e.g. log needs both).
 
     Callers that need a VL ``stack`` key (area charts) mutate the returned dict.
     """
+    _ay_cont = ay.scale.continuous if ay.scale is not None else None
     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:
@@ -340,7 +343,7 @@ def build_cartesian_y_encoding(
     if authored_domain is not None:
         y_scale: VLDict = {"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 (VL's "extend the domain to include 0"),
             # meaningless once the domain is pinned explicitly, and its

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

@@ -5,10 +5,15 @@ from __future__ import annotations
 from typing import Any
 
 from dataface.core.compile.models.chart.resolved import ResolvedStyleChannel
+from dataface.core.compile.models.primitives import (
+    VEGA_SCHEME_NAMES,
+    ScaleTargetConfig,
+)
 from dataface.core.compile.models.style.resolved import (
     ResolvedAxisStyle,
     ResolvedLegendStyle,
 )
+from dataface.core.render.chart._types import VLDict
 from dataface.core.render.chart.time_unit_detect import (
     BUCKETED_CALENDAR_UNITS,
     canonicalize_and_sort_ordinal_x,
@@ -24,6 +29,48 @@ from dataface.core.render.chart.vl_conditions import resolved_channel_to_vl_cond
 from dataface.core.render.chart.vl_field_maps import axis_to_vl, legend_to_vl
 
 
+def gradient_scale_to_vl(scale: ScaleTargetConfig) -> VLDict:
+    """Build a VL continuous-scale dict from a resolved gradient ScaleTargetConfig.
+
+    ``palette`` is either a Vega scheme name (forwarded as VL ``scheme``) or a
+    Dataface named palette / explicit color list, resolved to hex ``range``
+    stops via ``resolve_palette_stops`` — the same resolution table/KPI
+    conditional formatting already use for this field. Forwarding a Dataface
+    name straight through as a VL scheme string (the pre-fix behavior) is a
+    silent no-op: Vega logs an unrecognized-scheme warning and paints with its
+    default coloring instead of erroring, so the chart looks fine while
+    ignoring the palette the author asked for.
+
+    A ``list[float]`` (the opacity/stroke_width channel default) is not a
+    color palette and passes straight through as ``range`` unchanged —
+    ``resolve_palette_stops`` is color-stop-only.
+
+    Shared by ``channel_to_encoding``'s gradient mode and the geoshape/heatmap
+    chart-style gradient paths (``geo.py``, ``heatmap.py``) so the three
+    render sites decide scheme-vs-stops the same way instead of each
+    reimplementing the branch.
+    """
+    palette = scale.palette
+    if isinstance(palette, str):
+        if palette in VEGA_SCHEME_NAMES:
+            vl_scale: VLDict = {"scheme": palette}
+        else:
+            from dataface.core.render.chart.table_support import (  # noqa: PLC0415
+                resolve_palette_stops,
+            )
+
+            vl_scale = {"range": resolve_palette_stops(palette)}
+    else:
+        vl_scale = {"range": list(palette)}
+    if scale.min is not None and scale.max is not None:
+        vl_scale["domain"] = [scale.min, scale.max]
+    elif scale.min is not None:
+        vl_scale["domainMin"] = scale.min
+    elif scale.max is not None:
+        vl_scale["domainMax"] = scale.max
+    return vl_scale
+
+
 def gap_fill_ordinal_time(
     ax: ResolvedAxisStyle,
     x_field: str,
@@ -105,6 +152,9 @@ def gap_fill_ordinal_time(
             return canonicalize_and_sort_ordinal_x(data, x_field)
 
     dim_fields = [color_field] if color_field else []
+    assert (
+        ax.fill is not None
+    ), "x-axis fill must be resolved before ordinal time-series completion"
     return complete_ordinal_time_series(
         data, x_field, time_unit, dim_fields, ax.fill, ax.fiscal_year_start_month
     )
@@ -167,14 +217,11 @@ def channel_to_encoding(
 
     if ch.mode == "gradient":
         assert ch.scale is not None
-        gradient_scale: dict[str, Any] = {"range": list(ch.scale.palette)}
-        if ch.scale.min is not None and ch.scale.max is not None:
-            gradient_scale["domain"] = [ch.scale.min, ch.scale.max]
-        elif ch.scale.min is not None:
-            gradient_scale["domainMin"] = ch.scale.min
-        elif ch.scale.max is not None:
-            gradient_scale["domainMax"] = ch.scale.max
-        enc = {"field": ch.data_field, "type": "quantitative", "scale": gradient_scale}
+        enc = {
+            "field": ch.data_field,
+            "type": "quantitative",
+            "scale": gradient_scale_to_vl(ch.scale),
+        }
         if axis_style is not None:
             ax = axis_to_vl(axis_style)
             if ax:
@@ -242,6 +289,7 @@ __all__ = [
     "apply_color_legend",
     "channel_to_encoding",
     "field_encoding",
+    "gradient_scale_to_vl",
     "infer_vega_type_from_data",
     "pin_legend_display_order",
 ]

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

@@ -24,6 +24,7 @@ from dataface.core.render.chart.time_unit_detect import (
     resolve_temporal_label_visibility,
 )
 from dataface.core.render.chart.type_inference import infer_vega_type_from_data
+from dataface.core.text.format_d3 import portable_strftime
 
 
 class AxisLabelLayout(NamedTuple):
@@ -63,7 +64,7 @@ def _generic_temporal_labels(
         "yearquarter": lambda value: f"Q{(value.month - 1) // 3 + 1}",
         "yearmonth": lambda value: value.strftime("%b"),
         "yearweek": lambda value: value.strftime("W%V"),
-        "yearmonthdate": lambda value: value.strftime("%-d %b"),
+        "yearmonthdate": lambda value: portable_strftime(value, "%-d %b"),
         "monthofyear": lambda value: value.strftime("%b"),
         "dayofweek": lambda value: value.strftime("%a"),
         "dayofmonth": lambda value: str(value.day),
@@ -94,7 +95,7 @@ def _generic_layout(
         if _fits_flat(considered_widths, usable_width):
             return AxisLabelLayout(directive, 0.0, None, 0, "")
     if overlap.tilt:
-        angle, _ = _pick_tilt_for_widths(axis.label, considered_widths, usable_width)
+        angle, _ = _pick_tilt_for_widths(axis.labels, considered_widths, usable_width)
         return AxisLabelLayout(directive, angle, None, 0, "")
     return AxisLabelLayout(directive, 0.0, None, 0, "")
 
@@ -203,14 +204,16 @@ def _temporal_layout(
     if encoding_time_unit is None:
         return AxisLabelLayout("allow", 0.0, None, 0, "")
 
-    font = axis.label.font
+    font = axis.labels.font
     measurer = get_font_measurer(font.family)
     usable_width = chart_width * label_usable_ratio
-    format_time_unit = resolve_label_time_unit(encoding_time_unit, axis.label.time_unit)
+    format_time_unit = resolve_label_time_unit(
+        encoding_time_unit, axis.labels.time_unit
+    )
     dates = [datetime.date.fromisoformat(value[:10]) for value in values]
     if (
         encoding_time_unit in {"yearweek", "yearmonthdate"}
-        and axis.label.time_unit in (None, "auto")
+        and axis.labels.time_unit in (None, "auto")
         and bucket_aligned_temporal
     ):
         candidates = (
@@ -252,7 +255,7 @@ def _temporal_layout(
                 measurer.measure(str(dates[index].day), font.size) for index in indices
             ]
             angle = (
-                _pick_tilt_for_widths(axis.label, widths, usable_width)[0]
+                _pick_tilt_for_widths(axis.labels, widths, usable_width)[0]
                 if overlap.tilt
                 else 0.0
             )
@@ -266,7 +269,7 @@ def _temporal_layout(
     elif encoding_time_unit in {
         "yearweek",
         "yearmonthdate",
-    } and axis.label.time_unit in (None, "auto"):
+    } and axis.labels.time_unit in (None, "auto"):
         native_labels = _generic_temporal_labels(
             values, encoding_time_unit, encoding_time_unit
         )
@@ -361,14 +364,14 @@ def _temporal_layout(
         "yearquarter": lambda date: f"Q{(date.month - 1) // 3 + 1}",
         "yearmonth": lambda date: date.strftime("%b"),
         "yearweek": lambda date: date.strftime("W%V"),
-        "yearmonthdate": lambda date: date.strftime("%-d %b"),
+        "yearmonthdate": lambda date: portable_strftime(date, "%-d %b"),
     }
     widths = [
         measurer.measure(label_texts[format_time_unit](date), font.size)
         for date in visible_dates
     ]
     if overlap.tilt:
-        angle, _ = _pick_tilt_for_widths(axis.label, widths, usable_width)
+        angle, _ = _pick_tilt_for_widths(axis.labels, widths, usable_width)
         return AxisLabelLayout(
             directive, angle, visibility, anchor_index, format_time_unit
         )
@@ -387,11 +390,11 @@ def resolve_axis_x_overlap(
     chart_width: float,
 ) -> AxisLabelLayout:
     """Return render-local overlap, angle, and temporal visibility choices."""
-    overlap = axis.label.overlap
+    overlap = axis.labels.overlap
     if overlap is None:
-        return AxisLabelLayout(None, axis.label.angle, None, 0, "")
-    if axis.label.angle is not None:
-        return AxisLabelLayout("allow", axis.label.angle, None, 0, "")
+        return AxisLabelLayout(None, axis.labels.angle, None, 0, "")
+    if axis.labels.angle is not None:
+        return AxisLabelLayout("allow", axis.labels.angle, None, 0, "")
     if is_horizontal_bar:
         return AxisLabelLayout("allow", 0.0, None, 0, "")
     if not x_field or not data:
@@ -420,7 +423,7 @@ def resolve_axis_x_overlap(
             edge_labels_flushed,
         )
 
-    font = axis.label.font
+    font = axis.labels.font
     measurer = get_font_measurer(font.family)
     widths = [measurer.measure(value, font.size) for value in values]
     gap = get_chart_rendering().axis.label_gap_spaces * measurer.measure(" ", font.size)
@@ -428,7 +431,7 @@ def resolve_axis_x_overlap(
     usable_width = chart_width * label_usable_ratio
     if overlap.tilt and not _fits_flat(widths, usable_width):
         angle, _ = _pick_tilt(
-            axis.label,
+            axis.labels,
             x_field,
             data,
             chart_width,

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

@@ -21,7 +21,7 @@ Two tick-content scopes are safe to measure, both covered here:
 
 1. **Baked** — ``tick_values`` + a concrete ``format`` (quantitative axes on
    a theme that sets ``axis.ticks.count``). Dataface already knows the exact
-   values VL will render (``axis.values`` is emitted explicitly); measuring
+   values VL will render (``axis.scale.values`` is emitted explicitly); measuring
    is exact, not an estimate. ``quantitative_tick_labels``.
 2. **Unbaked** — no ``tick_values`` (e.g. the ``stark``/``plain`` themes,
    which leave ``axis.ticks.count`` unset so VL picks its own "nice" ticks).
@@ -64,7 +64,7 @@ _BREATHING_ROOM_PX = 4.0
 DEFAULT_VL_TICK_SIZE: float = 5.0
 
 # Vega-Lite's own default axis.labelLimit when the theme leaves
-# axis.label.max_width unset — the pixel width VL truncates a rendered label
+# axis.labels.max_width unset — the pixel width VL truncates a rendered label
 # to (with an ellipsis) before this module ever measures it.
 DEFAULT_VL_LABEL_LIMIT: float = 180.0
 
@@ -101,7 +101,7 @@ def measured_label_padding(
 
     Returns 0.0 for an empty label list (nothing to reserve for). Callers
     resolve VL's own tickSize default (``DEFAULT_VL_TICK_SIZE``) themselves
-    when the theme leaves ``axis.ticks.size`` unset.
+    when the theme leaves ``axis.ticks.length`` unset.
     """
     if not labels:
         return 0.0
@@ -117,7 +117,7 @@ def cap_padding_to_label_limit(
 
     ``measured_label_padding`` sizes the gutter to the widest label's full,
     untruncated text width. Vega-Lite truncates any rendered label wider than
-    ``labelLimit`` (``axis.label.max_width``, or its own ``DEFAULT_VL_LABEL_LIMIT``
+    ``labelLimit`` (``axis.labels.max_width``, or its own ``DEFAULT_VL_LABEL_LIMIT``
     when unset) to that width plus an ellipsis — so reserving more than
     ``label_limit + tick_size + breathing_room`` leaves dead gutter space no
     rendered label ever fills. Capping the final padding value is equivalent

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

@@ -282,7 +282,7 @@ def _emit_multi_metric_area(
         style.area_mark,
         style.line_mark,
         style.point_mark,
-        style.background,
+        chart.background,
         style.single_series_fill,
         True,
         wide.color,
@@ -344,7 +344,7 @@ class AreaEmitter:
             style.area_mark,
             style.line_mark,
             style.point_mark,
-            style.background,
+            chart.background,
             style.single_series_fill,
             color_ch is not None,
             top_encoding["color"] if color_ch is not None else {},
@@ -380,7 +380,7 @@ class AreaEmitter:
                 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),