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

dataface/core/render/warnings/bar_band_width_too_narrow.py

@@ -4,7 +4,10 @@ core/diagnostics/codes_render.py for what this fires on.
 Detection rule:
   chart is a (non-horizontal) ResolvedBarChart AND
   vega_specs[chart_id].encoding.x.type in {"nominal", "ordinal"} AND
-  vega_specs[chart_id].width / (distinct x values in chart_results) < _MIN_BAND_WIDTH_PX
+  the estimated per-bar pixel width < _MIN_BAND_WIDTH_PX, where per-bar width
+  is vega_specs[chart_id].width / (distinct x values), further divided by the
+  series count when the emitted spec subdivides the band with an xOffset
+  channel — see _grouped_series_count below.
 
 Floor rationale: the theme's default bar border stroke is 1px
 (``marks.bar.border.width``) and the fill occupies ``band_width * 0.8``
@@ -19,6 +22,7 @@ from __future__ import annotations
 
 from dataface.core.compile.models.chart.resolved.bar import ResolvedBarChart
 from dataface.core.diagnostics import WARN_BAR_BAND_WIDTH_TOO_NARROW, Diagnostic
+from dataface.core.render.chart._types import VLDict
 from dataface.core.render.warnings.base import WarningContext, encoding_channel_type
 
 # Below this per-band pixel width, the bar's fill is unreadable (see rationale above).
@@ -27,6 +31,57 @@ _MIN_BAND_WIDTH_PX = 4.0
 _CATEGORICAL_TYPES = frozenset({"nominal", "ordinal"})
 
 
+def _grouped_series_count(
+    unit: VLDict, chart: ResolvedBarChart, rows: list[VLDict]
+) -> int:
+    """Bars-per-band from the emitter's own offset decision, or 1 if none.
+
+    The bar emitter (``render/chart/emitters/bar.py``) is the single source
+    of truth for whether a band is subdivided — it already accounts for
+    stack mode, ``overlap: full``, wide-form grouping (``y`` as a measure
+    list), and suppressing the offset channel when color is 1:1 with x (that
+    would draw one solo sub-band per category, not a genuine group). Reading
+    its emitted ``xOffset`` channel here means this detector reports exactly
+    what renders; re-deriving the same "is this grouped" predicate from
+    resolved fields drifted from that decision in both directions (false
+    positives on colors the emitter doesn't group by, false negatives on
+    wide-form measures it does).
+
+    Small multiples do NOT get a lower count: Vega-Lite resolves the offset
+    scale shared across facet panels by default (only ``y`` ever gets
+    ``resolve.scale: independent``), so a panel facing one series value still
+    divides its band across the *global* series domain, occupying a single
+    sub-slot — the real render measures sub-pixel bars here, not full-width
+    ones. Counting the offset field's cardinality in the chart's unpartitioned
+    rows is the correct domain, not an overcount.
+    """
+    encoding = unit.get("encoding")
+    offset = encoding.get("xOffset") if isinstance(encoding, dict) else None
+    if not isinstance(offset, dict):
+        return 1
+    # A continuous (gradient) offset field isn't a discrete grouping — guard
+    # the same way the x-axis categorical check above does.
+    if offset.get("type") not in _CATEGORICAL_TYPES:
+        return 1
+    offset_field = offset.get("field")
+    if not isinstance(offset_field, str):
+        return 1
+    # Wide-form (y as a list of measures) folds into a synthetic label field
+    # that Vega-Lite's own `fold` transform creates client-side — it is never
+    # present in the query rows, so the series count is just len(chart.y).
+    if isinstance(chart.y, list):
+        measures = len(chart.y)
+    else:
+        measures = len({row[offset_field] for row in rows if offset_field in row})
+    # A zero count means no series reached this detector at all — an empty
+    # result set, or an offset field absent from every row. Treat the band as
+    # undivided rather than dividing by zero: this is a diagnostic, and it must
+    # never be the thing that fails a render.
+    if measures == 0:
+        return 1
+    return measures
+
+
 def detect(ctx: WarningContext) -> list[Diagnostic]:
     """Return one Diagnostic per bar chart whose bands are sub-readable-width."""
     warnings: list[Diagnostic] = []
@@ -56,26 +111,29 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             continue
 
         x_field: str = chart.x
-        distinct = len(
-            {row[x_field] for row in ctx.chart_results[chart_id] if x_field in row}
-        )
+        rows = ctx.chart_results[chart_id]
+        distinct = len({row[x_field] for row in rows if x_field in row})
         if distinct == 0:
             continue
 
         band_width = render_width / distinct
-        if band_width >= _MIN_BAND_WIDTH_PX:
+        series = _grouped_series_count(unit, chart, rows)
+        bar_width = band_width / series
+        if bar_width >= _MIN_BAND_WIDTH_PX:
             continue
 
         warnings.append(
             Diagnostic.from_code(
                 WARN_BAR_BAND_WIDTH_TOO_NARROW,
                 chart=chart_id,
+                path=f"charts.{chart_id}.x",
                 field=x_field,
                 message=WARN_BAR_BAND_WIDTH_TOO_NARROW.message_template.format(
                     chart_id=chart_id,
                     distinct=distinct,
+                    series=series,
                     render_width=render_width,
-                    band_width=band_width,
+                    bar_width=bar_width,
                     min_band_width=_MIN_BAND_WIDTH_PX,
                 ),
                 fix=WARN_BAR_BAND_WIDTH_TOO_NARROW.fix_template,

dataface/core/render/warnings/base.py

@@ -9,6 +9,8 @@ WarningContext carries everything detectors need:
   - chart_results: chart id → list of row dicts (query output).
   - vega_specs: chart id → Vega-Lite spec dict.
   - table_overflows: chart id → the table's slot overflow captured at render.
+  - authored_chart_heights: chart id → the nearest ancestor's literal
+    authored layout height, in px.
 
 vega_specs is SPARSE: KPI, text, and markdown charts do not compile to
 Vega-Lite, so their ids are OMITTED from this dict (not present as None).
@@ -19,6 +21,18 @@ Detectors that key into vega_specs must guard with:
 table_overflows is likewise SPARSE: only tables that overflowed their slot
 appear, and only on SVG-family renders (non-SVG formats never rasterize a
 table, so it is empty for them).
+
+authored_chart_heights is likewise SPARSE: a chart with no authored height
+anywhere in its ancestor chain is OMITTED, not present as 0 or None. The
+value is a snapshot of the chart's real, assigned px slot height, taken by
+build_resolved_face (via layout_sizing._snapshot_authored_slot_heights)
+immediately after the sizing pass assigns it but before cols-alignment can
+re-expand it — for a `cols:`-wrapped chart, that alignment step re-expands
+the resolved height to the chart's natural/unconstrained size afterward to
+keep siblings visually aligned, discarding the authored cap. Because the
+value is read off the sizing pass's own output (not re-derived), it already
+reflects a `rows:` wrapper splitting its height across children and a
+percentage-authored height resolved against real available space.
 """
 
 from __future__ import annotations
@@ -42,6 +56,10 @@ class WarningContext(BaseModel):
     # chart id → the table's slot overflow at render time (tables only; sparse —
     # captured from the real SVG render, so empty for non-SVG formats).
     table_overflows: dict[str, TableOverflow] = {}
+    # chart id → nearest ancestor's literal authored layout height, in px
+    # (sparse — see module docstring for why this isn't derived from
+    # face_spec.layout's resolved .height).
+    authored_chart_heights: dict[str, float] = {}
 
 
 def encoding_channel_type(vega_spec: dict[str, object], channel: str) -> str:

dataface/core/render/warnings/layered_chart_shared_y_axis_scale_mismatch.py

@@ -13,7 +13,9 @@ Detection rule:
     having axis_y means the user has already opted into split scales)
 
 Diagnostic.field is None — the issue is cross-column, not column-scoped.
-The message names the two columns with the widest ratio.
+The message names the two columns with the widest ratio, and the diagnostic
+marks where each was authored: `path` on the larger series, `related` on the
+smaller one that gets crushed.
 """
 
 from __future__ import annotations
@@ -24,6 +26,7 @@ from dataface.core.compile.models.chart.resolved._layer import LayeredResolvedCh
 from dataface.core.diagnostics import (
     WARN_LAYERED_CHART_SHARED_Y_AXIS_SCALE_MISMATCH,
     Diagnostic,
+    RelatedLocation,
 )
 from dataface.core.render.warnings.base import WarningContext
 
@@ -54,14 +57,19 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             continue
 
         # Collect (column_name, absolute_median, axis_y_set) for the base
-        # chart's own y column plus every layer's y column.
+        # chart's own y column plus every layer's y column. The authored path
+        # each column came from rides along so the two extremes can be marked
+        # where they were actually written.
         column_axis_y: list[tuple[str, bool]] = []
+        column_paths: dict[str, str] = {}
         base_y = chart.y
         if isinstance(base_y, str):
             column_axis_y.append((base_y, False))
-        for layer in chart.layers:
+            column_paths[base_y] = f"charts.{chart_id}.y"
+        for idx, layer in enumerate(chart.layers):
             if layer.y is not None:
                 column_axis_y.append((layer.y, layer.axis_y.position is not None))
+                column_paths.setdefault(layer.y, f"charts.{chart_id}.layers.{idx}.y")
 
         layer_stats: list[tuple[str, float, bool]] = []
         seen_columns: set[str] = set()
@@ -101,11 +109,25 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
         if max_axis_y or min_axis_y:
             continue
 
+        # The complaint is the *ratio between two series*, so it is anchored on
+        # the larger one and carries the smaller — the one being crushed to a
+        # flat line — as a related location. Marking only one of the pair, or
+        # the whole chart block, loses which two columns are at odds.
         warnings.append(
             Diagnostic.from_code(
                 WARN_LAYERED_CHART_SHARED_Y_AXIS_SCALE_MISMATCH,
                 chart=chart_id,
                 field=None,
+                path=column_paths[max_col],
+                related=(
+                    RelatedLocation(
+                        path=column_paths[min_col],
+                        message=(
+                            f"{min_col!r} is ~{ratio:.0f}x smaller — this is the "
+                            "series that flattens"
+                        ),
+                    ),
+                ),
                 message=WARN_LAYERED_CHART_SHARED_Y_AXIS_SCALE_MISMATCH.message_template.format(
                     chart_id=chart_id, col_a=max_col, col_b=min_col, ratio=ratio
                 ),

dataface/core/render/warnings/layout_min_exceeds_height.py

@@ -0,0 +1,68 @@
+"""Detector: WARN_LAYOUT_MIN_EXCEEDS_HEIGHT — see its `doc` in
+core/diagnostics/codes_render.py for what this fires on.
+
+Detection rule:
+  chart is a horizontal ResolvedBarChart AND
+  it has a literal authored height somewhere in its ancestor chain
+  (ctx.authored_chart_heights) AND
+  min_height_for_horizontal_bar_categories(n, ...) — the same readability
+  floor vega_lite.py's _render_vl_artifact applies at render time — exceeds
+  that authored height.
+
+The authored height comes from ctx.authored_chart_heights, a snapshot of
+each chart's real, assigned px slot height taken while it's still intact —
+after the sizing pass assigns it, before cols-alignment can re-expand it.
+See layout_sizing.py's `_snapshot_authored_slot_heights` for the full
+mechanism.
+"""
+
+from __future__ import annotations
+
+from dataface.core.compile.models.chart.resolved.bar import ResolvedBarChart
+from dataface.core.diagnostics import WARN_LAYOUT_MIN_EXCEEDS_HEIGHT, Diagnostic
+from dataface.core.render.chart.emitters._cartesian import (
+    count_horizontal_bar_categories,
+    min_height_for_horizontal_bar_categories,
+)
+from dataface.core.render.warnings.base import WarningContext
+
+
+def detect(ctx: WarningContext) -> list[Diagnostic]:
+    """Return one Diagnostic per horizontal bar whose category floor exceeds
+    its nearest ancestor's authored height."""
+    warnings: list[Diagnostic] = []
+
+    for chart_id, chart in ctx.face_spec.charts.items():
+        if not isinstance(chart, ResolvedBarChart):
+            continue
+        if chart.orientation != "horizontal":
+            continue
+
+        authored_height = ctx.authored_chart_heights.get(chart_id)
+        if authored_height is None:
+            continue
+
+        rows = ctx.chart_results.get(chart_id)
+        if not rows:
+            continue
+
+        n = count_horizontal_bar_categories(chart.x, rows)
+        min_h = min_height_for_horizontal_bar_categories(n, ctx.face_spec.style.charts)
+        if min_h <= authored_height:
+            continue
+
+        warnings.append(
+            Diagnostic.from_code(
+                WARN_LAYOUT_MIN_EXCEEDS_HEIGHT,
+                chart=chart_id,
+                message=WARN_LAYOUT_MIN_EXCEEDS_HEIGHT.message_template.format(
+                    chart_id=chart_id,
+                    n_categories=n,
+                    min_height=min_h,
+                    authored_height=authored_height,
+                ),
+                fix=WARN_LAYOUT_MIN_EXCEEDS_HEIGHT.fix_template,
+            )
+        )
+
+    return warnings

dataface/core/render/warnings/likely_currency_or_percent_missing_formatter.py

@@ -13,13 +13,13 @@ Detection rule (v1, name-match only):
   or contains the substring: percent.
 
   Fire when a matching field's effective y-axis format does not suit its kind.
-  Every format source (chart-root ``format:``, authored ``style.axis_y.format``,
+  Every format source (chart-root ``format:``, authored ``style.axis_y.labels.format``,
   whole-chart ``style.number_format``, the theme default) is baked into the single
-  resolved ``style.axis_y.format`` by the time this detector runs, so it reads
+  resolved ``style.axis_y.labels.format`` by the time this detector runs, so it reads
   that one value rather than trying to recover authored-vs-default intent. A
   percent format carries ``%``; a currency format carries ``$``; the generic SI
   default (``.3~s``) suits neither.
-  - Cartesian charts: check the chart's ``style.axis_y.format``.
+  - Cartesian charts: check the chart's ``style.axis_y.labels.format``.
   - Layered charts share one y-axis, so its format is checked once per layer;
     a warning is emitted per layer whose y field matches a signal and whose
     shared format is unfit.
@@ -108,9 +108,9 @@ def _classify(field_name: str) -> str | None:
 def _format_suits_kind(fmt: str | None, kind: str) -> bool:
     """Whether a resolved d3 number-format string renders ``kind`` sanely.
 
-    Every format source (chart-root ``format:``, authored ``style.axis_y.format``,
+    Every format source (chart-root ``format:``, authored ``style.axis_y.labels.format``,
     the theme default, and whole-chart ``style.number_format``) is baked into the
-    single ``style.axis_y.format`` by the resolved boundary, so authored-vs-default
+    single ``style.axis_y.labels.format`` by the resolved boundary, so authored-vs-default
     can't be read off the resolved chart — but the effective format can. The
     generic SI default (``.3~s``) suits neither kind: a 0–1 percent renders as
     milli-units and currency loses its symbol. A percent format carries ``%``; a
@@ -125,6 +125,12 @@ def _warn(chart_id: str, field: str, kind: str, axis_format: str | None) -> Diag
     return Diagnostic.from_code(
         WARN_LIKELY_CURRENCY_OR_PERCENT_MISSING_FORMATTER,
         chart=chart_id,
+        # `format` lives on `axis_y.labels`, not on `axis_y` — the bare
+        # `axis_y.format` spelling is pre-0.3.2 and now emits a migration
+        # warning. This is the spelling `fix_template` tells authors to set.
+        # Usually an *absent* key (that is the complaint), so it leans on the
+        # candidate walk to land on `axis_y`, then `style`, then the chart.
+        path=f"charts.{chart_id}.style.axis_y.labels.format",
         field=field,
         message=WARN_LIKELY_CURRENCY_OR_PERCENT_MISSING_FORMATTER.message_template.format(
             chart_id=chart_id, field=field, kind=kind, format=axis_format
@@ -154,7 +160,7 @@ def _y_axis_check(chart: ResolvedChart) -> tuple[str | None, list[str]]:
         fields.extend(layer.y for layer in chart.layers if layer.y)
     if not fields:
         return None, []
-    return chart.style.axis_y.format, fields
+    return chart.style.axis_y.labels.format, fields
 
 
 def detect(ctx: WarningContext) -> list[Diagnostic]:

dataface/core/render/warnings/palette_unsupported.py

@@ -30,6 +30,12 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_PALETTE_UNSUPPORTED,
                 chart=chart_id,
+                # `requested_alias_palette` is set on CategoricalColorStyle, so
+                # the authored key is under `style.color.categorical` — either
+                # `palette` or `single_series_palette`. Naming the common one
+                # walks up one level for the other, which is still the right
+                # block. There is no `scale` node on ColorStyle.
+                path=f"charts.{chart_id}.style.color.categorical.palette",
                 field="palette",
                 message=WARN_PALETTE_UNSUPPORTED.message_template.format(
                     chart_id=chart_id,

dataface/core/render/warnings/pie_dominant_segment.py

@@ -50,6 +50,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_PIE_DOMINANT_SEGMENT,
                 chart=chart_id,
+                path=f"charts.{chart_id}.type",
                 field=theta_field,
                 message=WARN_PIE_DOMINANT_SEGMENT.message_template.format(
                     chart_id=chart_id, dominant_field=theta_field, dominant_share=share

dataface/core/render/warnings/pie_too_many_segments.py

@@ -33,6 +33,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_PIE_TOO_MANY_SEGMENTS,
                 chart=chart_id,
+                path=f"charts.{chart_id}.type",
                 message=WARN_PIE_TOO_MANY_SEGMENTS.message_template.format(
                     chart_id=chart_id,
                     segment_count=segment_count,

dataface/core/render/warnings/point_map_out_of_projection.py

@@ -63,6 +63,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_POINT_MAP_OUT_OF_PROJECTION,
                 chart=chart_id,
+                path=f"charts.{chart_id}.projection",
                 message=WARN_POINT_MAP_OUT_OF_PROJECTION.message_template.format(
                     chart_id=chart_id,
                     dropped_count=out_count,

dataface/core/render/warnings/query_returned_zero_rows.py

@@ -29,6 +29,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
                 Diagnostic.from_code(
                     WARN_QUERY_RETURNED_ZERO_ROWS,
                     chart=chart_id,
+                    path=f"charts.{chart_id}.query",
                     field=None,
                     message=WARN_QUERY_RETURNED_ZERO_ROWS.message_template.format(
                         chart_id=chart_id

dataface/core/render/warnings/redundant_encoding.py

@@ -20,7 +20,11 @@ from dataface.core.compile.models.chart.resolved._base import (
 )
 from dataface.core.compile.models.chart.resolved.pie import ResolvedPieChart
 from dataface.core.compile.models.chart.resolved.scatter import ResolvedScatterChart
-from dataface.core.diagnostics import WARN_REDUNDANT_ENCODING, Diagnostic
+from dataface.core.diagnostics import (
+    WARN_REDUNDANT_ENCODING,
+    Diagnostic,
+    RelatedLocation,
+)
 from dataface.core.render.warnings.base import WarningContext
 
 
@@ -62,11 +66,26 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             if chart.chart_type == "bar" and set(channels) == {"x", "color"}:
                 continue
             channel_list = ", ".join(sorted(channels))
+            # The complaint is about the *pair*, so marking one channel alone
+            # tells half of it. Anchor the first and carry every other one as a
+            # related location, each labelled with the channel it is.
+            first, *rest = sorted(channels)
             warnings.append(
                 Diagnostic.from_code(
                     WARN_REDUNDANT_ENCODING,
                     chart=chart_id,
                     field=field,
+                    path=f"charts.{chart_id}.{first}",
+                    related=tuple(
+                        RelatedLocation(
+                            path=f"charts.{chart_id}.{channel}",
+                            message=(
+                                f"also bound to {field!r} — this is the "
+                                "redundant binding"
+                            ),
+                        )
+                        for channel in rest
+                    ),
                     message=WARN_REDUNDANT_ENCODING.message_template.format(
                         chart_id=chart_id, field=field, channels=channel_list
                     ),

dataface/core/render/warnings/registry.py

@@ -15,6 +15,7 @@ from types import ModuleType
 
 import dataface.core.render.warnings.bar_band_width_too_narrow as bar_band_width_too_narrow
 import dataface.core.render.warnings.layered_chart_shared_y_axis_scale_mismatch as layered_chart_shared_y_axis_scale_mismatch
+import dataface.core.render.warnings.layout_min_exceeds_height as layout_min_exceeds_height
 import dataface.core.render.warnings.likely_currency_or_percent_missing_formatter as likely_currency_or_percent_missing_formatter
 import dataface.core.render.warnings.palette_unsupported as palette_unsupported
 import dataface.core.render.warnings.pie_dominant_segment as pie_dominant_segment
@@ -36,6 +37,7 @@ logger = logging.getLogger(__name__)
 DETECTORS: list[ModuleType] = [
     bar_band_width_too_narrow,
     layered_chart_shared_y_axis_scale_mismatch,
+    layout_min_exceeds_height,
     likely_currency_or_percent_missing_formatter,
     palette_unsupported,
     pie_dominant_segment,
@@ -64,9 +66,13 @@ def run_all(ctx: WarningContext) -> list[Diagnostic]:
             results.extend(detector.detect(ctx))
         except Exception:  # noqa: BLE001 — detector failures must not break renders
             logger.exception("Warning detector %r raised; skipping", detector)
-    # One central point derives .path from .chart for every detector's output —
-    # a new detector needs zero position wiring of its own to become
-    # source-map-stampable; it only has to stamp .chart, which it already does.
+    # A detector that knows which authored key its complaint is about composes
+    # its own `charts.<id>.<anchor>` path, so the squiggle lands on that field
+    # rather than the whole chart block. The fallback below is for the
+    # detectors that genuinely have nothing more specific to say — an
+    # unreferenced chart, a table too wide for its slot — and it keeps a new
+    # detector stampable with zero position wiring: stamping `.chart`, which it
+    # already does, is enough.
     for d in results:
         if d.path is None and d.chart is not None:
             d.path = f"charts.{d.chart}"

dataface/core/render/warnings/temporal_single_point.py

@@ -48,6 +48,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_TEMPORAL_SINGLE_POINT,
                 chart=chart_id,
+                path=f"charts.{chart_id}.x",
                 field=chart.x,
                 message=WARN_TEMPORAL_SINGLE_POINT.message_template.format(
                     chart_id=chart_id, chart_type=chart.chart_type

dataface/core/render/warnings/too_many_color_categories.py

@@ -47,6 +47,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_TOO_MANY_COLOR_CATEGORIES,
                 chart=chart_id,
+                path=f"charts.{chart_id}.color",
                 field=color_field,
                 message=WARN_TOO_MANY_COLOR_CATEGORIES.message_template.format(
                     chart_id=chart_id,

dataface/core/render/warnings/too_many_x_categories.py

@@ -2,7 +2,8 @@
 core/diagnostics/codes_render.py for what this fires on.
 
 Detection rule:
-  vega_specs[chart_id].encoding.x.type in {"nominal", "ordinal"}
+  vega_specs[chart_id].encoding.x.type in {"nominal", "ordinal"} (or, for a
+  bar chart, also "temporal" — see _BAR_ALLOWED_X_TYPES below)
   AND distinct x values in chart_results > _MAX_CATEGORIES
 """
 
@@ -11,6 +12,7 @@ from __future__ import annotations
 from dataface.core.compile.models.chart.resolved._base import (
     _CartesianResolvedChartFields,
 )
+from dataface.core.compile.models.chart.resolved.bar import ResolvedBarChart
 from dataface.core.diagnostics import WARN_TOO_MANY_X_CATEGORIES, Diagnostic
 from dataface.core.render.warnings.base import WarningContext, encoding_channel_type
 
@@ -19,6 +21,14 @@ _MAX_CATEGORIES = 50
 
 _CATEGORICAL_TYPES = frozenset({"nominal", "ordinal"})
 
+# A bar draws one band per distinct x value regardless of whether Vega-Lite
+# encodes that axis as ordinal or temporal — the density gate that flips
+# bucketed temporal data off ordinal above ~60 distinct values does so purely
+# to manage axis-label layout, not because the chart stopped being banded.
+# Line/area/scatter charts don't get this widening: a dense temporal axis
+# there is a continuous draw, not a crowded band, however many points it has.
+_BAR_ALLOWED_X_TYPES = _CATEGORICAL_TYPES | frozenset({"temporal"})
+
 
 def detect(ctx: WarningContext) -> list[Diagnostic]:
     """Return one Diagnostic per chart with an overcrowded categorical x-axis."""
@@ -32,8 +42,13 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
         if chart_id not in ctx.vega_specs or chart_id not in ctx.chart_results:
             continue
 
+        allowed_x_types = (
+            _BAR_ALLOWED_X_TYPES
+            if isinstance(chart, ResolvedBarChart)
+            else _CATEGORICAL_TYPES
+        )
         x_type = encoding_channel_type(ctx.vega_specs[chart_id], "x")
-        if x_type not in _CATEGORICAL_TYPES:
+        if x_type not in allowed_x_types:
             continue
 
         x_field: str = chart.x
@@ -47,6 +62,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_TOO_MANY_X_CATEGORIES,
                 chart=chart_id,
+                path=f"charts.{chart_id}.x",
                 field=x_field,
                 message=WARN_TOO_MANY_X_CATEGORIES.message_template.format(
                     chart_id=chart_id,

dataface/core/render/warnings/value_labels_crowd_width.py

@@ -41,12 +41,18 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
         # length (a different axis) and are out of scope; area labels ride the
         # overlaid line mark.
         labels: MarkLabelsStyle
+        # `mark_key` is the authored `marks.<key>` the labels came from, so the
+        # warning marks where they were switched on. Area labels ride the
+        # overlaid *line* mark, which is why it is not always the family name.
+        mark_key: str
         if isinstance(chart, ResolvedBarChart):
             if chart.orientation == "horizontal":
                 continue
             labels = chart.style.mark.labels
+            mark_key = "bar"
         elif isinstance(chart, (ResolvedLineChart, ResolvedAreaChart)):
             labels = chart.style.line_mark.labels
+            mark_key = "line"
         else:
             continue
 
@@ -109,6 +115,9 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
             Diagnostic.from_code(
                 WARN_VALUE_LABELS_CROWD_WIDTH,
                 chart=chart_id,
+                # Chart-local style takes no family segment — `style.bar.…` is
+                # the board-level spelling and does not compile on a chart.
+                path=f"charts.{chart_id}.style.marks.{mark_key}.labels",
                 field=label_field,
                 message=WARN_VALUE_LABELS_CROWD_WIDTH.message_template.format(
                     chart_id=chart_id, label_width=widest, slot_width=slot

dataface/core/render/warnings/y_encoding_mostly_null.py

@@ -54,6 +54,7 @@ def detect(ctx: WarningContext) -> list[Diagnostic]:
                     Diagnostic.from_code(
                         WARN_Y_ENCODING_MOSTLY_NULL,
                         chart=chart_id,
+                        path=f"charts.{chart_id}.y",
                         field=y_field,
                         message=WARN_Y_ENCODING_MOSTLY_NULL.message_template.format(
                             chart_id=chart_id,

dataface/core/render_format.py

@@ -0,0 +1,18 @@
+"""The `RenderFormat` type alias, split out of `dataface.core.dashboard`.
+
+`RenderFormat` is pure type metadata with no runtime logic — but `dashboard.py`
+(where it used to live) is the compile+execute+render orchestrator and eagerly
+imports the entire `core.compile` package. CLI/MCP surfaces that need
+`RenderFormat` purely for argument typing (e.g. Typer's `--format` option,
+which needs the real `Literal` object at decoration time, not just an
+annotation) were paying that whole cost just to get this one type. Living
+here, they don't.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+RenderFormat = Literal[
+    "svg", "html", "png", "pdf", "terminal", "json", "text", "yaml", "data"
+]