dataface 0.3.0__py3-none-any.whl → 0.3.1.dev22__py3-none-any.whl

dataface/core/compile/introspection.py

@@ -66,6 +66,7 @@ class SchemaField:
     extra_union_types: list[str] = dataclasses.field(
         default_factory=list
     )  # primitive type names alongside models or enums in a union
+    container_mapping_models: list[str] = dataclasses.field(default_factory=list)
     is_extra_key: bool = (
         False  # True for synthetic '<name>' fields from __pydantic_extra__
     )
@@ -328,14 +329,18 @@ def _extra_union_types(annotation: Any) -> list[str]:
 
     Returns the names (e.g. ["str", "bool"]) so the renderer can include
     them in anyOf alongside $ref or enum branches.
-    Only meaningful for bare Union types — list/dict containers return [].
+    Container values recurse because ``list[str | AuthoredChart]`` needs the
+    same scalar branch on its item schema as a bare union does.
     """
     annotation = _unwrap_annotated(annotation)
     origin = get_origin(annotation)
     args = get_args(annotation)
-    if not args or origin in (list, dict):
+    if not args:
         return []
 
+    if origin in (list, dict):
+        return _extra_union_types(args[-1])
+
     result: list[str] = []
     for arg in args:
         # Unwrap per-arm: a validated primitive alias (Duration =
@@ -348,6 +353,9 @@ def _extra_union_types(annotation: Any) -> list[str]:
         if _is_authored_model(arg):
             continue
         arg_origin = get_origin(arg)
+        if arg_origin in (list, dict):
+            result.extend(_extra_union_types(arg))
+            continue
         if arg_origin is Literal:
             continue
         if isinstance(arg, type) and issubclass(arg, Enum):
@@ -358,7 +366,22 @@ def _extra_union_types(annotation: Any) -> list[str]:
             and arg.__name__ in _PRIMITIVE_NAMES
         ):
             result.append(arg.__name__)
-    return result
+    return list(dict.fromkeys(result))
+
+
+def _container_mapping_models(annotation: type) -> list[str]:
+    """Return named-map value models nested in a list item union."""
+    annotation = _unwrap_annotated(annotation)
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+    if origin is dict and len(args) == 2:
+        return _nested_model_names(args[1])
+    if origin is list and args:
+        return _container_mapping_models(args[0])
+    result: list[str] = []
+    for arg in args:
+        result.extend(_container_mapping_models(arg))
+    return list(dict.fromkeys(result))
 
 
 def _build_schema_field(
@@ -383,6 +406,7 @@ def _build_schema_field(
         nested_models=_nested_model_names(annotation),
         container=_get_container(annotation),
         extra_union_types=_extra_union_types(annotation),
+        container_mapping_models=_container_mapping_models(annotation),
         inherit_from=(inherit.from_path,) if inherit is not None else (),
         inherit_slot=inherit_slot.from_path if inherit_slot is not None else None,
     )

dataface/core/compile/models/style/theme/variables.py

@@ -69,7 +69,7 @@ class VariablesStyle(BaseModel):
 
     Note: `input.background` styles the *inputs only*. The variables strip/
     container itself is transparent (no background band) and sits directly on the
-    board canvas — see `render/variable_controls.py`. This matters on dark themes:
+    board canvas — see `render/variables_strip.py`. This matters on dark themes:
     an opaque container bg that differs from the canvas (e.g. neon input bg
     #222222 over canvas #161616) renders as a visible band; a transparent
     container has none, on any theme. The old chart_themes system had a separate

dataface/core/compile/resolve/_resolve.py

@@ -155,6 +155,7 @@ from dataface.core.compile.tick_values import (
     apply_headroom,
     nice_tick_values,
     numeric_domain_bounds,
+    stacked_bar_multi_measure_totals_max,
     stacked_bar_totals_max,
 )
 from dataface.core.compile.typography import resolve_title_font, width_tier
@@ -530,7 +531,7 @@ def _resolve_cartesian_ticks(
 def _resolve_stacked_bar_ticks(
     ay: ResolvedAxisStyle,
     data: list[dict[str, Any]],
-    y_field: str,
+    y_fields: list[str],
     cat_field: str,
 ) -> tuple[float, ...]:
     """Compute nice tick values for a stacked bar using the stacked domain max.
@@ -549,14 +550,20 @@ def _resolve_stacked_bar_ticks(
     """
     if ay.ticks.count is None or not data:
         return ()
-    y_floats = numeric_column_values(data, y_field)
+    y_floats = [
+        value for y_field in y_fields for value in numeric_column_values(data, y_field)
+    ]
     if not y_floats:
         return ()
     authored = numeric_domain_bounds(ay.scale.domain if ay.scale is not None else None)
     if authored is not None:
         tick_min, tick_max = authored
     else:
-        sm = stacked_bar_totals_max(data, cat_field, y_field)
+        if len(y_fields) == 1:
+            sm = stacked_bar_totals_max(data, cat_field, y_fields[0])
+        else:
+            totals = stacked_bar_multi_measure_totals_max(data, cat_field, y_fields)
+            sm = totals[0] if totals else None
         raw_max = sm if sm is not None else max(y_floats)
         tick_max = apply_headroom(raw_max, _axis_headroom(ay))
         tick_min = min(0.0, min(y_floats))  # stacked bars always zero-anchor
@@ -787,15 +794,17 @@ def _edge_or_none(value: str | None) -> Literal["left", "right"] | None:
 def _suppress_legend_for_endpoint_labels(
     channels: dict[str, Any],
     endpoint_labels_visible: bool,
+    *,
+    wide_measure_series: bool = False,
 ) -> bool:
     """Return True when endpoint labels will replace the colour legend.
 
-    Fires when a series colour channel is present AND the author opted in via
-    endpoint_labels.visible.
+    Fires when a series colour channel (or a folded wide area measure series)
+    is present AND the author opted in via endpoint_labels.visible.
     """
     color_ch = channels.get("color")
-    return (
-        color_ch is not None and color_ch.mode == "series" and endpoint_labels_visible
+    return endpoint_labels_visible and (
+        wide_measure_series or (color_ch is not None and color_ch.mode == "series")
     )
 
 
@@ -816,6 +825,8 @@ def _bake_ay_orient(
     ay: AxisStyle,
     channels: dict[str, Any],
     endpoint_labels_visible: bool,
+    *,
+    wide_measure_series: bool = False,
 ) -> AxisStyle:
     """Resolve 'auto' y-axis position for line/area/bar at compile time.
 
@@ -830,7 +841,9 @@ def _bake_ay_orient(
     """
     if ay.position != "auto":
         return ay
-    fires = _suppress_legend_for_endpoint_labels(channels, endpoint_labels_visible)
+    fires = _suppress_legend_for_endpoint_labels(
+        channels, endpoint_labels_visible, wide_measure_series=wide_measure_series
+    )
     return ay.model_copy(update={"position": "left" if fires else "right"})
 
 
@@ -1838,25 +1851,28 @@ def _resolve_bar(
     # 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
     y_field = normalized.y if isinstance(normalized.y, str) else None
+    y_fields = (
+        [y_field] if y_field else normalized.y if isinstance(normalized.y, list) else []
+    )
     x_field = normalized.x if isinstance(normalized.x, str) else None
     bar_domain_max: float | None = None
     bar_domain_min: float | None = None
-    if resolved_stack == "normalize" or not y_field:
+    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, ...] = ()
     elif is_stacked and x_field:
-        tick_values = _resolve_stacked_bar_ticks(ay, data, y_field, x_field)
+        tick_values = _resolve_stacked_bar_ticks(ay, data, y_fields, x_field)
         # stacked domainMax baked separately below; domain_min stays None
     else:
+        bar_y_values = (
+            _shared_y_values(data, y_field, normalized, datasets)
+            if y_field
+            else _numeric_y_values(data, tuple(y_fields))
+        )
         _bar_ticks = _resolve_cartesian_ticks(
             normalized.id,
             ay,
-            _shared_y_values(
-                data,
-                y_field,
-                normalized,
-                datasets,
-            ),
+            bar_y_values,
             zero_anchor=bar_zero,
             authored_ticks_count=_authored_axis_y_ticks_count(normalized.style),
         )
@@ -1878,8 +1894,12 @@ def _resolve_bar(
     # A non-positive total (all-negative stacks) is skipped: domainMax 0 on a
     # zero-anchored scale is a degenerate [0, 0] domain; VL auto-fits instead.
     stacked_domain_max: float | None = None
-    if is_stacked and resolved_stack != "normalize" and y_field and x_field:
-        _raw_stacked_max = stacked_bar_totals_max(data, x_field, y_field)
+    if is_stacked and resolved_stack != "normalize" and y_fields and x_field:
+        if len(y_fields) == 1:
+            _raw_stacked_max = stacked_bar_totals_max(data, x_field, y_fields[0])
+        else:
+            totals = stacked_bar_multi_measure_totals_max(data, x_field, y_fields)
+            _raw_stacked_max = totals[0] if totals else None
         if _raw_stacked_max is not None and _raw_stacked_max > 0:
             stacked_domain_max = apply_headroom(_raw_stacked_max, _axis_headroom(ay))
     style_tail = _cartesian_style_tail(board_rcs, board_style, ax, ay)
@@ -2250,6 +2270,7 @@ def _resolve_area(
     primary = _with_color_tokens(normalized.style, board_style)
     channels = _channels_for(normalized, data)
     _project_cf_channels(normalized, data, channels)
+    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
     # Area semantics fix x=dimension, y=value — unlike bar there is no
@@ -2352,7 +2373,12 @@ def _resolve_area(
     )
     y_field_area = normalized.y if isinstance(normalized.y, str) else None
     _area_floats = _numeric_y_values(data, (y_field_area,)) if y_field_area else []
-    ay_merged = _bake_ay_orient(ay_merged, channels, endpoint_labels.visible)
+    ay_merged = _bake_ay_orient(
+        ay_merged,
+        channels,
+        endpoint_labels.visible,
+        wide_measure_series=wide_measure_series,
+    )
     # Area's x is always a bottom-orient temporal/ordinal 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))
@@ -2415,10 +2441,10 @@ def _resolve_area(
     else:
         zero_anchored_area = True
     x_field_area = normalized.x if isinstance(normalized.x, str) else None
-    if resolved_stack == "normalize" or not y_field_area:
-        # normalize-stack domain is always [0,1]; no y_field means no ticks.
+    if resolved_stack == "normalize":
+        # normalize-stack domain is always [0,1].
         area_ticks = _CartesianTickResolution((), None)
-    elif resolved_stack not in (None, "none") and x_field_area:
+    elif resolved_stack not in (None, "none") and x_field_area and _log_y_fields:
         # Stacked area ladders against the cumulative column total, not the raw
         # per-series range. Without this a chart whose columns sum to 154 labels
         # an axis that stops at 70, leaving two thirds of the plot unlabelled —
@@ -2431,18 +2457,18 @@ def _resolve_area(
         # [0, max_total] and no column exceeds that ceiling — the same
         # zero-anchored domain a plain zero-stack renders on.
         area_ticks = _CartesianTickResolution(
-            _resolve_stacked_bar_ticks(ay, data, y_field_area, x_field_area), None
+            _resolve_stacked_bar_ticks(ay, data, _log_y_fields, x_field_area), None
         )
     else:
+        area_y_values = (
+            _shared_y_values(data, y_field_area, normalized, datasets)
+            if y_field_area
+            else _numeric_y_values(data, tuple(_log_y_fields))
+        )
         area_ticks = _resolve_cartesian_ticks(
             normalized.id,
             ay,
-            _shared_y_values(
-                data,
-                y_field_area,
-                normalized,
-                datasets,
-            ),
+            area_y_values,
             zero_anchor=zero_anchored_area,
             authored_ticks_count=_authored_axis_y_ticks_count(normalized.style),
         )
@@ -2568,7 +2594,9 @@ def _resolve_area(
         _effective_palette(board_rcs, primary),
         requested_alias_palette=_effective_requested_alias_palette(board_rcs, primary),
         suppress_legend=_suppress_legend_for_endpoint_labels(
-            channels, endpoint_labels.visible
+            channels,
+            endpoint_labels.visible,
+            wide_measure_series=wide_measure_series,
         ),
         show_top_legend=show_top_legend,
     )

dataface/core/compile/schema_renderers/json_schema.py

@@ -3,7 +3,7 @@
 Converts an AuthorableSchema IR to a draft-07 JSON Schema dict.
 Callers: IDE schema generation, validation tooling.
 
-Entry point: render_json_schema(schema: AuthorableSchema) -> dict
+Entry point: render_yaml_schema(schema: AuthorableSchema) -> dict
 """
 
 from __future__ import annotations
@@ -64,7 +64,7 @@ def _split_union(s: str) -> list[str]:
 def _ref(model_name: str, root: str) -> dict[str, str]:
     """Build a $ref to a model's $defs entry, or to the document root.
 
-    render_json_schema inlines the root model's properties at the top level and
+    render_yaml_schema inlines the root model's properties at the top level and
     never emits a $defs entry for it. A field that recurses back to the root
     (a nested face) must therefore $ref the document root ("#") rather than a
     "#/$defs/<root>" entry that will never exist.
@@ -95,20 +95,39 @@ def _type_schema(field: SchemaField, root: str) -> dict[str, Any]:
 
     if field.nested_models:
         refs: list[dict[str, Any]] = [_ref(n, root) for n in field.nested_models]
-        inner: dict[str, Any] = refs[0] if len(refs) == 1 else {"anyOf": refs}
+        branches = refs + extra
+        inner: dict[str, Any] = (
+            branches[0] if len(branches) == 1 else {"anyOf": branches}
+        )
         if field.container == "list":
+            if field.container_mapping_models:
+                map_refs = [_ref(n, root) for n in field.container_mapping_models]
+                if len(map_refs) == 1:
+                    item_branches = [
+                        inner,
+                        {"type": "object", "additionalProperties": map_refs[0]},
+                    ]
+                else:
+                    item_branches = [
+                        inner,
+                        {
+                            "type": "object",
+                            "additionalProperties": {"anyOf": map_refs},
+                        },
+                    ]
+                inner = {"anyOf": item_branches}
             arr: dict[str, Any] = {"type": "array", "items": inner}
-            parts: list[dict[str, Any]] = [arr] + extra
+            parts: list[dict[str, Any]] = [arr]
             if nullable:
                 parts.append({"type": "null"})
             return {"anyOf": parts} if len(parts) > 1 else parts[0]
         if field.container == "dict":
             obj: dict[str, Any] = {"type": "object", "additionalProperties": inner}
-            parts = [obj] + extra
+            parts = [obj]
             if nullable:
                 parts.append({"type": "null"})
             return {"anyOf": parts} if len(parts) > 1 else parts[0]
-        all_branches: list[dict[str, Any]] = refs + extra
+        all_branches: list[dict[str, Any]] = branches
         if nullable:
             all_branches.append({"type": "null"})
         return {"anyOf": all_branches} if len(all_branches) > 1 else all_branches[0]
@@ -236,14 +255,18 @@ def _model_to_def(model_name: str, ir: AuthorableSchema) -> dict[str, Any]:
         defn["required"] = required
     if additional_properties is not None:
         defn["additionalProperties"] = additional_properties
+    else:
+        defn["additionalProperties"] = False
     return defn
 
 
-def render_json_schema(schema: AuthorableSchema) -> dict[str, Any]:
-    """Render an AuthorableSchema IR as a draft-07 JSON Schema.
+def render_yaml_schema(schema: AuthorableSchema) -> dict[str, Any]:
+    """Render the strict draft-07 Dataface YAML schema.
 
     Produces a self-contained schema with the root model's properties
-    inlined and all reachable authored models in $defs.
+    inlined and all reachable authored models in $defs. Author-defined model
+    objects are closed; only declared keyed collections use typed additional
+    properties.
     """
     root = _model_to_def(schema.root, schema)
     defs = {
@@ -278,9 +301,13 @@ def render_json_schema(schema: AuthorableSchema) -> dict[str, Any]:
         result["description"] = root["description"]
     result["type"] = "object"
     result["properties"] = root.get("properties", {})
+    result["additionalProperties"] = root["additionalProperties"]
     if root.get("required"):
         result["required"] = root["required"]
     if defs:
         result["$defs"] = defs
 
     return result
+
+
+render_json_schema = render_yaml_schema

dataface/core/compile/schema_renderers/vscode_schema.py

@@ -1,6 +1,6 @@
-"""VS Code JSON Schema renderer — wraps render_json_schema with IDE-specific decoration.
+"""VS Code JSON Schema renderer — decorates the strict Dataface YAML schema.
 
-Calls render_json_schema(ir) for the IR-driven core, then adds the IDE-specific
+Calls render_yaml_schema(ir) for the IR-driven core, then adds the IDE-specific
 extras that have no Pydantic counterpart (fileMatch, layout anyOf constraint,
 theme enum, LayoutItem definition).
 
@@ -12,7 +12,7 @@ from __future__ import annotations
 from typing import Any
 
 from dataface.core.compile.introspection import AuthorableSchema
-from dataface.core.compile.schema_renderers.json_schema import render_json_schema
+from dataface.core.compile.schema_renderers.json_schema import render_yaml_schema
 
 
 def _rename_defs(obj: Any) -> Any:
@@ -253,8 +253,8 @@ def render_vscode_schema(
 ) -> dict[str, Any]:
     """Render an AuthorableSchema as a VS Code draft-07 JSON Schema.
 
-    Calls render_json_schema for the IR-driven core and decorates with
+    Calls render_yaml_schema for the IR-driven core and decorates with
     IDE-specific extras (fileMatch, layout constraints, theme enum, etc.).
     """
-    base = render_json_schema(schema)
+    base = render_yaml_schema(schema)
     return _decorate_for_vscode(base, themes=themes)

dataface/core/compile/schema_renderers/yaml_schema_catalog.py

@@ -0,0 +1,167 @@
+"""Load immutable Dataface YAML schemas packaged with Dataface."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from datetime import date
+from types import NoneType
+from typing import Literal, Protocol, TypeAlias
+
+from importlib_resources import files
+
+JsonValue: TypeAlias = (
+    str
+    | int
+    | float
+    | bool
+    | Literal[None]
+    | list["JsonValue"]
+    | dict[str, "JsonValue"]
+)
+JsonObject: TypeAlias = dict[str, JsonValue]
+
+
+class _SchemaResource(Protocol):
+    def joinpath(self, *_: str) -> _SchemaResource: ...
+
+    def read_bytes(self) -> bytes: ...
+
+    def read_text(self) -> str: ...
+
+
+@dataclass(frozen=True)
+class YamlSchemaEntry:
+    """One immutable face-YAML grammar snapshot."""
+
+    version: str
+    released_at: date
+    filename: str
+    sha256: str
+    predecessor: str | Literal[None]
+
+    @classmethod
+    def from_json(cls, value: JsonObject) -> YamlSchemaEntry:
+        predecessor = value["predecessor"]
+        if not isinstance(predecessor, (str, NoneType)):
+            raise ValueError(
+                "Dataface YAML schema manifest predecessor must be a string or null."
+            )
+        return cls(
+            version=_manifest_string(value, "version"),
+            released_at=_manifest_date(value, "released_at"),
+            filename=_manifest_string(value, "file"),
+            sha256=_manifest_string(value, "sha256"),
+            predecessor=predecessor,
+        )
+
+    def as_json(self) -> JsonObject:
+        return {
+            "version": self.version,
+            "released_at": self.released_at.isoformat(),
+            "file": self.filename,
+            "sha256": self.sha256,
+            "predecessor": self.predecessor,
+        }
+
+
+@dataclass(frozen=True)
+class YamlSchemaCatalog:
+    """Frozen Dataface YAML schemas indexed by version, newest to oldest."""
+
+    entries: tuple[YamlSchemaEntry, ...]
+    _schemas: dict[str, JsonObject]
+
+    @property
+    def latest(self) -> YamlSchemaEntry:
+        return self.entries[0]
+
+    @property
+    def versions(self) -> tuple[str, ...]:
+        return tuple(entry.version for entry in self.entries)
+
+    def schema_for(self, version: str) -> JsonObject:
+        return self._schemas[version]
+
+
+def _manifest_string(value: JsonObject, key: str) -> str:
+    result = value[key]
+    if not isinstance(result, str):
+        raise ValueError(f"Dataface YAML schema manifest {key} must be a string.")
+    return result
+
+
+def _manifest_date(value: JsonObject, key: str) -> date:
+    try:
+        return date.fromisoformat(_manifest_string(value, key))
+    except ValueError as error:
+        raise ValueError(
+            f"Dataface YAML schema manifest {key} must be an ISO date."
+        ) from error
+
+
+def canonical_schema_bytes(schema: JsonObject) -> bytes:
+    """Serialize a schema once so release comparisons are byte-for-byte stable."""
+    return (json.dumps(schema, separators=(",", ":"), sort_keys=True) + "\n").encode()
+
+
+def load_yaml_schema_catalog() -> YamlSchemaCatalog:
+    """Load the package's immutable Dataface YAML schemas."""
+    return load_yaml_schema_catalog_from(
+        files("dataface") / "data" / "schemas" / "yaml"
+    )
+
+
+def load_yaml_schema_catalog_from(
+    directory: _SchemaResource,
+) -> YamlSchemaCatalog:
+    """Load and verify a catalog directory; intended for package data and tests."""
+    manifest: JsonValue = json.loads(directory.joinpath("manifest.json").read_text())
+    if not isinstance(manifest, dict) or "schemas" not in manifest:
+        raise ValueError("Dataface YAML schema manifest has no schemas.")
+    raw_entries = manifest["schemas"]
+    if not isinstance(raw_entries, list):
+        raise ValueError("Dataface YAML schema manifest schemas must be a list.")
+    if not raw_entries:
+        raise ValueError("Dataface YAML schema manifest has no schemas.")
+
+    entries = tuple(
+        YamlSchemaEntry.from_json(value)
+        for value in raw_entries
+        if isinstance(value, dict)
+    )
+    if len(entries) != len(raw_entries):
+        raise ValueError("Dataface YAML schema manifest entries must be objects.")
+    if len({entry.version for entry in entries}) != len(entries):
+        raise ValueError("Dataface YAML schema manifest has duplicate versions.")
+
+    schemas: dict[str, JsonObject] = {}
+    predecessor: str | Literal[None] = None
+    previous_date: date | Literal[None] = None
+    for entry in entries:
+        if entry.predecessor != predecessor:
+            raise ValueError(
+                f"Dataface YAML schema {entry.version} has predecessor "
+                f"{entry.predecessor!r}, expected {predecessor!r}."
+            )
+        if previous_date is not None and entry.released_at < previous_date:
+            raise ValueError(
+                "Dataface YAML schema manifest release dates must be chronological."
+            )
+        contents = directory.joinpath(entry.filename).read_bytes()
+        digest = hashlib.sha256(contents).hexdigest()
+        if digest != entry.sha256:
+            raise ValueError(
+                f"Dataface YAML schema {entry.filename} sha256 does not match its manifest."
+            )
+        schema: JsonValue = json.loads(contents)
+        if not isinstance(schema, dict):
+            raise ValueError(
+                f"Dataface YAML schema {entry.filename} must be an object."
+            )
+        schemas[entry.version] = schema
+        predecessor = entry.version
+        previous_date = entry.released_at
+
+    return YamlSchemaCatalog(tuple(reversed(entries)), schemas)

dataface/core/compile/tick_values.py

@@ -8,8 +8,12 @@ dependency direction.
 from __future__ import annotations
 
 import math
+from collections import defaultdict
+from decimal import Decimal
 from typing import Any
 
+ChartValue = str | int | float | Decimal
+
 
 def nice_tick_values(
     domain_min: float,
@@ -148,3 +152,20 @@ def stacked_bar_totals_max(
             continue
         totals[x] = totals.get(x, 0.0) + max(0.0, float(y))
     return max(totals.values()) if totals else None
+
+
+def stacked_bar_multi_measure_totals_max(
+    data: list[dict[str, ChartValue]],
+    x_field: str,
+    y_fields: list[str],
+) -> tuple[float, ...]:
+    """Return the max positive stacked total for wide-form measures."""
+    totals: defaultdict[str | int | float | Decimal, float] = defaultdict(float)
+    for row in data:
+        x = row.get(x_field)
+        if x is None:
+            continue
+        totals[x] += sum(
+            max(0.0, float(row[y])) for y in y_fields if row.get(y) is not None
+        )
+    return (max(totals.values()),) if totals else ()

dataface/core/dashboard.py

@@ -102,6 +102,10 @@ class RenderedDashboard(BaseModel):
     # `json.dumps()` in the MCP dispatcher will fail on bytes at the wire
     # boundary, which is correct behaviour.
     data: dict[str, Any] | str | bytes | None = None
+    # The interactive variable-control layer, when the caller passed
+    # ``controls=True``. Empty otherwise: a control that cannot re-run its
+    # queries is worse than no control, so hosts opt in (render/controls.py).
+    controls_html: str = ""
     validation_errors: list[Diagnostic] = []
     warnings: list[Diagnostic] = []
     suppressed_warnings: list[Diagnostic] = []
@@ -472,6 +476,7 @@ def render_dashboard(
     return RenderedDashboard(
         status="partial" if render_result.chart_errors else "ok",
         data=data,
+        controls_html=render_result.controls_html,
         chart_errors=render_result.chart_errors,
         warnings=[*compile_active, *render_result.warnings],
         suppressed_warnings=[

dataface/core/render/__init__.py

@@ -30,6 +30,11 @@ from dataface.core.render.chart import (
     render_table_svg,
     slug_to_text,
 )
+from dataface.core.render.controls import (
+    controls_runtime_source,
+    controls_stylesheet,
+    render_controls_layer,
+)
 from dataface.core.render.errors import (
     MissingRequiredVariablesError,
     MissingVariable,
@@ -49,12 +54,7 @@ from dataface.core.render.terminal_charts import (
     render_kpi_terminal,
     render_table_terminal,
 )
-from dataface.core.render.variable_controls import (
-    generate_svg_variable_icons,
-    generate_svg_variable_script,
-    render_interactive_variables_svg,
-    render_variables_svg,
-)
+from dataface.core.render.variables_strip import render_variables_strip_svg
 
 __all__ = [
     # Main functions
@@ -65,11 +65,11 @@ __all__ = [
     "MissingRequiredVariablesError",
     "MissingVariable",
     "RenderError",
-    # Variable controls
-    "render_variables_svg",
-    "render_interactive_variables_svg",
-    "generate_svg_variable_script",
-    "generate_svg_variable_icons",
+    # Variables: read-only strip (artifact) + control layer (hosts)
+    "render_variables_strip_svg",
+    "render_controls_layer",
+    "controls_runtime_source",
+    "controls_stylesheet",
     # Vega-Lite
     "generate_vega_lite_spec",
     "render_table_svg",