dataface 0.2.1.dev301__py3-none-any.whl → 0.2.1.dev323__py3-none-any.whl

dataface/ai/llm.py

@@ -35,6 +35,44 @@ def _llm_timeout() -> httpx.Timeout:
     )
 
 
+def _parse_data_uri(uri: str) -> tuple[str, str]:
+    """Split a base64 ``data:`` URI into its media type and payload.
+
+    Raises ``LLMClientError`` on anything that isn't a base64 data URI — the
+    frontend and view already validate the shape, so a miss here is a bug, not
+    user input to tolerate.
+    """
+    prefix, _, data = uri.partition(",")
+    if not (prefix.startswith("data:") and prefix.endswith(";base64") and data):
+        raise LLMClientError(f"Attachment is not a base64 data URI: {uri[:32]!r}...")
+    media_type = prefix[len("data:") : -len(";base64")]
+    return media_type, data
+
+
+def _anthropic_content_block(block: dict[str, Any]) -> dict[str, Any]:
+    """Convert one provider-neutral content block to an Anthropic block."""
+    block_type = block.get("type")
+    if block_type == "text" and isinstance(block.get("text"), str):
+        return {"type": "text", "text": block["text"]}
+    if block_type == "image_url":
+        image_url = block.get("image_url")
+        if isinstance(image_url, dict) and isinstance(image_url.get("url"), str):
+            media_type, data = _parse_data_uri(image_url["url"])
+            return {
+                "type": "image",
+                "source": {"type": "base64", "media_type": media_type, "data": data},
+            }
+    if block_type == "document" and isinstance(block.get("url"), str):
+        media_type, data = _parse_data_uri(block["url"])
+        return {
+            "type": "document",
+            "source": {"type": "base64", "media_type": media_type, "data": data},
+        }
+    raise LLMClientError(
+        f"Unsupported Anthropic message content block: {block_type!r}."
+    )
+
+
 def infer_provider(model: str | None) -> str:
     if model and model.startswith("anthropic:"):
         return "anthropic"
@@ -314,6 +352,19 @@ class OpenAIClient:
                                     }
                                 )
                                 continue
+                            if block_type == "document" and isinstance(
+                                block.get("url"), str
+                            ):
+                                media_type, _ = _parse_data_uri(block["url"])
+                                subtype = media_type.rpartition("/")[2] or "bin"
+                                responses_content.append(
+                                    {
+                                        "type": "input_file",
+                                        "filename": f"attachment.{subtype}",
+                                        "file_data": block["url"],
+                                    }
+                                )
+                                continue
                             raise LLMClientError(
                                 f"Unsupported OpenAI message content block: {block_type!r}."
                             )
@@ -523,9 +574,15 @@ class AnthropicClient:
 
             content = message.get("content")
             if content:
-                converted.append(
-                    {"role": role, "content": [{"type": "text", "text": content}]}
-                )
+                if isinstance(content, list):
+                    if role != "user":
+                        raise LLMClientError(
+                            "Only user messages may contain multimodal content."
+                        )
+                    blocks = [_anthropic_content_block(block) for block in content]
+                else:
+                    blocks = [{"type": "text", "text": content}]
+                converted.append({"role": role, "content": blocks})
 
         flush_tool_results()
         return converted

dataface/core/compile/normalize_variables.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from datetime import date, datetime
 from typing import TYPE_CHECKING, Any
 
 from dataface.core.compile.errors import CompilationError
@@ -28,6 +29,7 @@ from dataface.core.compile.models.variable.authored import (
     Variable,
     VariableInputType,
 )
+from dataface.core.compile.variables import parse_iso_date
 from dataface.core.errors.codes_compile import (
     DF_COMPILE_SOURCE_REQUIRED,
     DF_COMPILE_UNKNOWN_VARIABLE,
@@ -505,11 +507,24 @@ _TYPE_VALIDATORS: dict[str, tuple[type | tuple[type, ...], str]] = {
     "range": ((int, float), "a number"),
     "checkbox": (bool, "a boolean"),
     "multiselect": (list, "a list"),
-    "date": (str, "a string"),
-    "datepicker": (str, "a string"),
+    # A date default may be an ISO string ("2024-01-01") or a native date object
+    # (unquoted YAML `2024-01-01`, which safe_load types as datetime.date).
+    "date": ((str, date), "a string or ISO date"),
+    "datepicker": ((str, date), "a string or ISO date"),
 }
 
 
+def _validate_date_string(var_name: str, label: str, value: str) -> None:
+    """Raise CompilationError if *value* is not a parseable ISO date."""
+    try:
+        parse_iso_date(value)
+    except ValueError:
+        raise CompilationError(
+            f"Variable '{var_name}': {label} must be an ISO date (YYYY-MM-DD), "
+            f"got {value!r}"
+        ) from None
+
+
 def validate_variable_value(var_name: str, var: Variable, value: Any) -> None:
     """Validate a variable value against its input type.
 
@@ -537,11 +552,21 @@ def validate_variable_value(var_name: str, var: Variable, value: Any) -> None:
                 f"got {type(value).__name__}"
             )
         for i, v in enumerate(value):
-            if v is not None and not isinstance(v, str):
+            if v is None:
+                continue
+            if isinstance(v, datetime):
+                raise CompilationError(
+                    f"Variable '{var_name}': daterange[{i}] must be a calendar date, "
+                    f"not a datetime, got {v!r}"
+                )
+            if isinstance(v, date):
+                continue
+            if not isinstance(v, str):
                 raise CompilationError(
                     f"Variable '{var_name}': daterange[{i}] must be string, "
                     f"got {type(v).__name__}"
                 )
+            _validate_date_string(var_name, f"daterange[{i}]", v)
         return
 
     # Standard type validation from dict
@@ -564,6 +589,20 @@ def validate_variable_value(var_name: str, var: Variable, value: Any) -> None:
                 f"Variable '{var_name}': {input_type} default {value} > max {var.max}"
             )
 
+    # date/datepicker defaults: reject a datetime (a date must not carry a time),
+    # and parse-validate string forms as ISO so a bad default fails at `dft validate`
+    # instead of at query-execution time. Placed after the slider check so the
+    # isinstance narrowing here cannot leak into that numeric comparison (date and
+    # slider inputs are disjoint).
+    if input_type in ("date", "datepicker"):
+        if isinstance(value, datetime):
+            raise CompilationError(
+                f"Variable '{var_name}': {input_type} default must be a calendar "
+                f"date, not a datetime, got {value!r}"
+            )
+        if isinstance(value, str) and value.strip():
+            _validate_date_string(var_name, f"{input_type} default", value)
+
 
 def compute_variable_dependencies(
     variables: dict[str, Variable],

dataface/core/compile/resolve/_resolve.py

@@ -1167,7 +1167,7 @@ def _build_resolved_area_line(merged: AreaLineStyle) -> ResolvedAreaLineStyle:
 
 def _resolve_one_layer(
     layer: CartesianLayer,
-    board_rcs: ResolvedChartsStyle,
+    board_style: ResolvedStyle,
     base_type: str,
     base_family_style: Any,
     base_query_name: str | None,
@@ -1191,11 +1191,19 @@ def _resolve_one_layer(
     base chart's query, so this is never an ambiguous ``None`` at render
     time (barring the rare inline-unnamed-query chart, whose own
     ``query_name`` is itself None).
+
+    The layer's own ``style`` patch is run through ``_with_color_tokens``
+    exactly like the chart-root style patch — otherwise a palette token
+    authored on a per-layer style (e.g. ``layers[].style.marks.line.stroke.
+    color``) leaks through to the renderer as a literal token string instead
+    of the resolved hex value.
     """
+    board_rcs = board_style.charts
     axis_y = layer.axis_y if layer.axis_y is not None else LayerAxisYStyle()
     query_name = layer.query if layer.query is not None else base_query_name
+    layer_style = _with_color_tokens(layer.style, board_style)
     if isinstance(layer, LineLayer):
-        line_marks = layer.style.marks if layer.style is not None else None
+        line_marks = layer_style.marks if layer_style is not None else None
         line_parent = base_family_style if base_type == "line" else board_rcs.line
         return ResolvedLineLayer(
             type="line",
@@ -1217,7 +1225,7 @@ def _resolve_one_layer(
             query_name=query_name,
         )
     if isinstance(layer, AreaLayer):
-        area_marks = layer.style.marks if layer.style is not None else None
+        area_marks = layer_style.marks if layer_style is not None else None
         area_parent = base_family_style if base_type == "area" else board_rcs.area
         return ResolvedAreaLayer(
             type="area",
@@ -1245,7 +1253,7 @@ def _resolve_one_layer(
             query_name=query_name,
         )
     if isinstance(layer, BarLayer):
-        bar_marks = layer.style.marks if layer.style is not None else None
+        bar_marks = layer_style.marks if layer_style is not None else None
         bar_parent = base_family_style if base_type == "bar" else board_rcs.bar
         return ResolvedBarLayer(
             type="bar",
@@ -1261,7 +1269,7 @@ def _resolve_one_layer(
             query_name=query_name,
         )
     # ScatterLayer
-    scatter_marks = layer.style.marks if layer.style is not None else None
+    scatter_marks = layer_style.marks if layer_style is not None else None
     scatter_parent = base_family_style if base_type == "scatter" else board_rcs.scatter
     return ResolvedScatterLayer(
         type="scatter",
@@ -1307,7 +1315,7 @@ def _check_layers_y_domain(
 
 def _resolve_layer_list(
     layers: list[CartesianLayer],
-    board_rcs: ResolvedChartsStyle,
+    board_style: ResolvedStyle,
     base_type: str,
     base_family_style: Any,
     base_query_name: str | None,
@@ -1323,7 +1331,7 @@ def _resolve_layer_list(
         return ()
     return tuple(
         _resolve_one_layer(
-            layer, board_rcs, base_type, base_family_style, base_query_name
+            layer, board_style, base_type, base_family_style, base_query_name
         )
         for layer in layers
     )
@@ -1475,7 +1483,7 @@ def _resolve_bar(
         ),
     )
     resolved_layers = _resolve_layer_list(
-        normalized.layers, board_rcs, "bar", bar, normalized.query_name
+        normalized.layers, board_style, "bar", bar, normalized.query_name
     )
     _check_layers_y_domain(normalized.id, resolved_layers, ay)
     # Value labels track the effective measure format (bar_user_fmt), not just the
@@ -1699,7 +1707,7 @@ def _resolve_line(
         ),
     )
     resolved_layers = _resolve_layer_list(
-        normalized.layers, board_rcs, "line", line, normalized.query_name
+        normalized.layers, board_style, "line", line, normalized.query_name
     )
     _check_layers_y_domain(normalized.id, resolved_layers, ay)
     return ResolvedLineChart(
@@ -1941,7 +1949,7 @@ def _resolve_area(
         ),
     )
     resolved_layers = _resolve_layer_list(
-        normalized.layers, board_rcs, "area", area, normalized.query_name
+        normalized.layers, board_style, "area", area, normalized.query_name
     )
     _check_layers_y_domain(normalized.id, resolved_layers, ay)
     return ResolvedAreaChart(
@@ -2034,7 +2042,7 @@ def _resolve_scatter(
     style_tail = _cartesian_style_tail(board_rcs, board_style, ax, ay)
     style_tail["tooltip_format"] = tooltip_fmt
     resolved_layers = _resolve_layer_list(
-        normalized.layers, board_rcs, "scatter", scatter, normalized.query_name
+        normalized.layers, board_style, "scatter", scatter, normalized.query_name
     )
     _check_layers_y_domain(normalized.id, resolved_layers, ay)
     _s = normalized.style

dataface/core/compile/variables.py

@@ -8,9 +8,13 @@ by both the execute and render stages.
 """
 
 import json
+import math
+from datetime import date, datetime
 from typing import Any
 
 from dataface.core.compile.models.face.normalized import VariableValues
+from dataface.core.compile.models.variable.authored import Variable
+from dataface.core.errors.execution import ExecutionError
 
 
 def parse_variable_json_strings(variables: VariableValues) -> VariableValues:
@@ -50,4 +54,173 @@ def parse_variable_json_strings(variables: VariableValues) -> VariableValues:
     return parsed
 
 
-__all__ = ["parse_variable_json_strings"]
+# Input kinds that carry a non-string SQL type. Everything else (text, select,
+# multiselect, radio, …) stays a string/list and needs no coercion.
+_DATE_INPUTS = frozenset({"date", "datepicker"})
+_NUMBER_INPUTS = frozenset({"number", "slider", "range"})
+# Scalar typed inputs where an empty string means "unset" (→ None), like the
+# renderer's absent-check. daterange is excluded — it handles endpoints itself.
+_SCALAR_TYPED_INPUTS = _DATE_INPUTS | _NUMBER_INPUTS | frozenset({"checkbox"})
+_BOOL_TRUE = frozenset({"true", "1", "yes", "on"})
+_BOOL_FALSE = frozenset({"false", "0", "no", "off"})
+
+# The scalar runtime domain a single-value coercer may receive. Spelled out (never
+# `Any`/`object`/`| None`) so the coercers stay typed for mypy without tripping the
+# dataface/core type-state freeze gate; broad enough that every isinstance below is
+# meaningful and the trailing type-error raise stays reachable. Container inputs
+# (daterange lists) are dispatched inline in the loop, not through these helpers.
+_Coercible = str | int | float | bool | date
+
+
+def parse_iso_date(value: str) -> date:
+    """Parse an ISO ``YYYY-MM-DD`` string to a ``date``, raising ``ValueError``.
+
+    The shared date parser for both boundaries: the compile-time default check
+    (wraps ValueError as CompilationError) and runtime coercion (wraps it as
+    ExecutionError). Keeping one parser means both agree on what a date is.
+    """
+    return date.fromisoformat(value.strip())
+
+
+def coerce_variable_values(
+    values: VariableValues, registry: dict[str, Variable]
+) -> VariableValues:
+    """Coerce runtime variable values to their declared semantic Python types.
+
+    Runs at the runtime boundary (query execution), after defaults and user
+    values have merged. URL params, CLI, and API values arrive as strings; a
+    ``date`` variable's ``"2024-01-01"`` must reach SQL as a ``date`` object so
+    strict engines get ``DATE '2024-01-01'`` (inline path) or a typed bound
+    parameter — not a varchar that Trino/BigQuery refuse to compare to a date
+    column. The semantic type comes from the variable's ``input`` kind; values
+    that don't match it raise ``ExecutionError`` (fail fast, no silent fixups).
+
+    Names absent from ``registry`` (builtins, dir-navigation context) have no
+    declared type and pass through untouched. An empty string is treated as
+    unset (``None``), matching the renderer's absent-check.
+    """
+    result: VariableValues = {}
+    for name, value in values.items():
+        var = registry.get(name)
+        if var is None or value is None:
+            result[name] = value
+            continue
+        kind = var.input
+        if (
+            isinstance(value, str)
+            and not value.strip()
+            and kind in _SCALAR_TYPED_INPUTS
+        ):
+            result[name] = None  # empty scalar typed input = unset
+        elif kind in _DATE_INPUTS:
+            result[name] = _coerce_date(name, value)
+        elif kind == "daterange":
+            if not isinstance(value, (list, tuple)) or len(value) != 2:
+                raise ExecutionError(
+                    f"Variable '{name}': daterange value must be [start, end], "
+                    f"got {value!r}"
+                )
+            # Each endpoint is None or an empty string (both unset), or a
+            # date/ISO-string. Inlined so the None-carrying list needs no written
+            # ``| None`` annotation (type-state freeze gate); the element type is
+            # inferred from the comprehension.
+            result[name] = [
+                (
+                    None
+                    if endpoint is None
+                    or (isinstance(endpoint, str) and not endpoint.strip())
+                    else _coerce_date(name, endpoint)
+                )
+                for endpoint in value
+            ]
+        elif kind in _NUMBER_INPUTS:
+            result[name] = _coerce_number(name, value)
+        elif kind == "checkbox":
+            result[name] = _coerce_bool(name, value)
+        else:
+            result[name] = value
+    return result
+
+
+def _coerce_date(name: str, value: _Coercible) -> date:
+    """Narrow one date/datepicker (or daterange endpoint) value to a ``date``.
+
+    Accepts what the runtime boundary produces — an ISO string or a native
+    ``date`` (from a compile default) — and rejects everything else, notably a
+    ``datetime``: it is a ``date`` subclass, so ``_to_sql_literal`` would emit
+    ``TIMESTAMP`` for it, the exact varchar↔date mismatch this coercion prevents.
+    Callers handle the empty-string-is-unset case before reaching here.
+    """
+    if isinstance(value, datetime):
+        raise ExecutionError(
+            f"Variable '{name}': date value must be a calendar date, not a "
+            f"datetime with a time component, got {value!r}"
+        )
+    if isinstance(value, date):
+        return value
+    if isinstance(value, str):
+        try:
+            return parse_iso_date(value)
+        except ValueError:
+            raise ExecutionError(
+                f"Variable '{name}': date value must be an ISO date "
+                f"(YYYY-MM-DD), got {value!r}"
+            ) from None
+    raise ExecutionError(
+        f"Variable '{name}': date value must be a string, got {type(value).__name__}"
+    )
+
+
+def _coerce_number(name: str, value: _Coercible) -> int | float:
+    if isinstance(value, bool):
+        raise ExecutionError(
+            f"Variable '{name}': number value must be numeric, got a boolean"
+        )
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return _require_finite(name, value)
+    if isinstance(value, str):
+        return _parse_number(name, value.strip())
+    raise ExecutionError(
+        f"Variable '{name}': number value must be numeric, got {type(value).__name__}"
+    )
+
+
+def _parse_number(name: str, text: str) -> int | float:
+    try:
+        return int(text)
+    except ValueError:
+        pass
+    try:
+        parsed = float(text)
+    except ValueError:
+        raise ExecutionError(
+            f"Variable '{name}': number value must be numeric, got {text!r}"
+        ) from None
+    return _require_finite(name, parsed)
+
+
+def _require_finite(name: str, value: float) -> float:
+    if not math.isfinite(value):
+        raise ExecutionError(
+            f"Variable '{name}': number value must be finite, got {value!r}"
+        )
+    return value
+
+
+def _coerce_bool(name: str, value: _Coercible) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        text = value.strip().lower()
+        if text in _BOOL_TRUE:
+            return True
+        if text in _BOOL_FALSE:
+            return False
+    raise ExecutionError(
+        f"Variable '{name}': checkbox value must be a boolean, got {value!r}"
+    )
+
+
+__all__ = ["coerce_variable_values", "parse_iso_date", "parse_variable_json_strings"]

dataface/core/execute/executor.py

@@ -56,7 +56,10 @@ from dataface.core.compile.models.query.normalized import (
     SqlQuery,
     is_sql_query,
 )
-from dataface.core.compile.variables import parse_variable_json_strings
+from dataface.core.compile.variables import (
+    coerce_variable_values,
+    parse_variable_json_strings,
+)
 from dataface.core.errors.execution import ExecutionError, QueryError
 from dataface.core.execute.duckdb_cache import (
     compute_cache_key,
@@ -515,6 +518,14 @@ class Executor:
                 "Please use a different variable name."
             )
 
+        # Runtime boundary: coerce to declared semantic types, same as the
+        # per-query path (_prepare_call), so batch-bound params are typed too.
+        registry = self.face.variable_registry
+        if registry and variables:
+            variables = coerce_variable_values(
+                parse_variable_json_strings(variables), registry
+            )
+
         # Generate batch execution plan
         plan = create_batch_execution_plan(self.face)
 
@@ -754,6 +765,12 @@ class Executor:
         all_variables.update(self.face.variable_defaults)
         parsed_variables = parse_variable_json_strings(variables or {})
         merged = {**all_variables, **parsed_variables}
+        # Runtime boundary: turn string inputs into their declared semantic types
+        # (date/number/bool) so the SQL layer binds typed literals/params. This is
+        # the per-query boundary execute_query and is_cached both funnel through, so
+        # the coerced values also key the cache identically (execute_face_batch
+        # coerces at its own entry).
+        merged = coerce_variable_values(merged, variable_registry)
         return query_name, self._get_query(query_name), merged
 
     def _lookup_cached(

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

@@ -123,44 +123,6 @@ def _resolve_overlap_fraction(
     return float(overlap)
 
 
-def _grouped_bar_chrome_px(chart: ResolvedBarChart) -> float:
-    """Estimate pixels consumed by chrome along the horizontal bar's category axis.
-
-    Used only for horizontal overlap pixel-size computation. Approximates axis
-    labels + optional title/subtitle + legend rows so we can estimate the plot box.
-    The estimate is intentionally rough — forgiving for 2-series thick bars.
-    """
-    chrome = chart.style.axis_x.label.font.size * 2.2  # axis labels + ticks
-    legend = chart.legend
-    if legend.visible is not False and legend.position in ("top", "bottom"):
-        chrome += legend.label.font.size * 2.8
-    return chrome
-
-
-def _grouped_bar_slot_px(
-    extent: float,
-    chrome_px: float,
-    n_categories: int,
-    n_series: int,
-    padding_inner: float,
-    padding_outer: float,
-) -> float:
-    """Per-series pixel slot within a category group for horizontal overlap.
-
-    Mirrors Vega's band-scale step math, then divides evenly across series.
-    Returns 0.0 when inputs can't yield a positive slot.
-    """
-    if extent <= 0 or n_categories <= 0 or n_series <= 0:
-        return 0.0
-    usable = extent - chrome_px
-    if usable <= 0:
-        return 0.0
-    step = usable / (n_categories - padding_inner + 2 * padding_outer)
-    bandwidth = step * (1.0 - padding_inner)
-    slot = bandwidth / n_series
-    return slot if slot > 0 else 0.0
-
-
 def _data_order_expression(color_field: str, data: list[VLDict]) -> str:
     """Build a VL calculate expression assigning each color value its first-encounter index.
 
@@ -186,8 +148,6 @@ def apply_grouped_bar_overlap(
     mark_props: VLDict,
     encoding: VLDict,
     data: list[VLDict],
-    *,
-    height: float | None = None,
 ) -> None:
     """Apply within-group bar spacing for grouped bars.
 
@@ -196,9 +156,11 @@ def apply_grouped_bar_overlap(
     * Full (≥1): drop the offset channel so series coincide.
     * Positive overlap (0 < f < 1): restricted to exactly 2 series.
       - Vertical: ``width: {band: 1+f}`` — band > 1 overflows in Vega.
-      - Horizontal: explicit pixel ``size`` — Vega clamps height band > 1, so
-        pixels are the only way to achieve true overlap. Falls back to band
-        (touching) when no panel height is available.
+      - Horizontal: ``size: {expr: "(1+f) * bandwidth('yOffset')"}`` — the
+        ``band`` shorthand clamps height at 1 so it can't overlap, but the
+        ``bandwidth(scaleName)`` expression form isn't clamped and is
+        resolved by Vega at its own layout time, so it needs no panel
+        dimension and no chrome estimate.
     """
     is_horizontal = chart.orientation == "horizontal"
     offset_ch = "yOffset" if is_horizontal else "xOffset"
@@ -233,32 +195,13 @@ def apply_grouped_bar_overlap(
         mark_props["width"] = {"band": 1.0 + fraction}
         return
 
-    # Horizontal: band clamps, so size in pixels from the estimated slot.
-    chrome_px = _grouped_bar_chrome_px(chart)
-    n_categories = (
-        len({row[chart.x] for row in data if chart.x in row}) if chart.x else 0
-    )
-    slot = (
-        _grouped_bar_slot_px(
-            height,
-            chrome_px,
-            n_categories,
-            n_series,
-            GROUPED_BAR_PADDING_INNER,
-            GROUPED_BAR_PADDING_OUTER,
-        )
-        if height is not None
-        else 0.0
-    )
-    if slot <= 0:
-        # No panel dimension (CLI/test callers) — best-effort band (→ touching).
-        mark_props["height"] = {"band": 1.0 + fraction}
-        return
-    # Clamp so the group footprint can't exceed the category step (no spill).
-    max_size = slot * (
-        1.0 + GROUPED_BAR_PADDING_INNER / (1.0 - GROUPED_BAR_PADDING_INNER) * n_series
-    )
-    mark_props["size"] = min(slot * (1.0 + fraction), max_size)
+    # Horizontal: band clamps, so size comes from Vega's own resolved
+    # per-series offset-scale width. paddingInner=0 on the offset scale
+    # (set above) makes bandwidth('yOffset') == total_step / n_series, and
+    # fraction < 1 here keeps (1+fraction)*bandwidth under 2*bandwidth ==
+    # total_step — the group footprint can't spill into a neighboring
+    # category by construction, no clamp needed.
+    mark_props["size"] = {"expr": f"{1.0 + fraction} * bandwidth('yOffset')"}
     # Drop the band-relative height (from bar_mark_to_vl / theme band_width) so
     # the explicit pixel size is the sole height control — band and size conflict.
     mark_props.pop("height", None)

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

@@ -26,7 +26,8 @@ class GroupedBarOverlapFeature:
 
     The emitter sets up the offset encoding; this feature:
     1. Sets the outer categorical axis paddingInner/paddingOuter (group gaps).
-    2. Applies mark sizing using box.height from the render-time slot geometry.
+    2. Applies mark sizing (band shorthand, or a bandwidth() expression for
+       the horizontal-overlap case — resolved by Vega itself, not box geometry).
     """
 
     def applies_to(self, chart: ResolvedChart) -> bool:
@@ -64,6 +65,5 @@ class GroupedBarOverlapFeature:
             spec.mark_props,
             spec.encoding,
             chart_rows(chart, datasets),
-            height=box.height,
         )
         return spec

dataface/core/render/chart/vega_lite.py

@@ -172,7 +172,13 @@ def _render_vl_artifact(
             vl["$df_target_height"] = effective_height
             if len(vl["hconcat"]) > 1:
                 vl["hconcat"][1]["height"] = effective_height
-    apply_title_overflow_to_spec(size_target, resolved_style.charts.title)
+    if "hconcat" not in vl:
+        # hconcat's title wrap is deferred to render_vega_spec: vl-convert
+        # ignores autosize:fit on concat children, so pane[0].width here is
+        # still the full column width — wrapping against it now overstates
+        # the room the title actually has. render_vega_spec wraps it after
+        # _correct_concat_overshoot shrinks pane[0] to its real width.
+        apply_title_overflow_to_spec(size_target, resolved_style.charts.title)
     _trace_vl_spec(resolved.id, "v2", vl)
     return RenderArtifact(kind="vega_spec", payload=vl)