dataface 0.4.1.dev5__py3-none-any.whl → 0.4.1.dev53__py3-none-any.whl

dataface/DATAFACE_SYNTAX.md

@@ -957,6 +957,18 @@ WHERE plan IN ({{ plans | map('tojson') | join(', ') }})
 WHERE {{ filter('plan', plans) }}
 ```
 
+**Numeric arithmetic antipattern** — `{{ n | int }}` and `{{ n | float }}` raise an error on parameterized variables. Jinja's `| int` filter calls `int(value)` internally; on a parameterized variable this would silently return 0, so Dataface rejects it instead. Write SQL arithmetic directly on the variable:
+
+```sql
+-- WRONG: raises ERR-JINJA-ERROR at render time
+INTERVAL -({{ months | int - 1 }}) MONTH
+
+-- CORRECT: {{ months }} emits the bound parameter; the database handles arithmetic
+INTERVAL -({{ months }} - 1) MONTH
+```
+
+In a direct query (no `{{ queries.X }}` references), `{{ n }}` emits a bound parameter (`$1`, `%s`, `?` depending on dialect). In a composed query (one using `{{ queries.X }}`), variables are resolved as literals before the parameterization pass — `{{ n }}` with `n: 3` becomes the literal `3`. In both cases, `{{ n | int }}` and `{{ n | float }}` raise — so adding or removing a `{{ queries.X }}` reference cannot change the value a filter expression produces. Arithmetic, casting, and type coercion belong in the SQL expression around the variable, not in a Jinja filter.
+
 Common mistakes (the validator rejects these — listed here so authors don't hit them):
 
 - `options.values: [...]` → use `options.static: [...]`.

dataface/agent_api/diagnostics.py

@@ -36,9 +36,10 @@ __all__ = [
     "DiagnosticCodeDetail",
     "DiagnosticCodesListResult",
     "DiagnosticCodeDetailResult",
+    "DiagnosticDisplay",
     "list_diagnostic_codes",
     "get_diagnostic_code",
-    "doc_url_map",
+    "display_map",
 ]
 
 # ----- Args types ------------------------------------------------------------
@@ -77,6 +78,20 @@ class DiagnosticCodeSummary(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)
 
 
+class DiagnosticDisplay(BaseModel):
+    """Registry-derived presentation data for one code, shipped per page.
+
+    Both fields are derived DiagnosticCode properties rather than serialized
+    Diagnostic fields, so a display surface resolves them from the code it
+    already has instead of receiving them on every payload.
+    """
+
+    title: str
+    doc_url: str
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+
 class DiagnosticCodeDetail(BaseModel):
     """Full details for a single diagnostic code."""
 
@@ -207,11 +222,14 @@ def get_diagnostic_code(code: str) -> DiagnosticCodeDetailResult:
     )
 
 
-def doc_url_map() -> dict[str, str]:
-    """The registry's code -> doc_url map, built once for embedding alongside a page.
+def display_map() -> dict[str, DiagnosticDisplay]:
+    """The registry's code -> display map, built once for embedding alongside a page.
 
-    doc_url is a derived DiagnosticCode property, never an authored/serialized
-    field — Cloud and Playground each ship this map once rather than
-    re-deriving or hand-formatting a URL per diagnostic.
+    `title` and `doc_url` are derived DiagnosticCode properties, never
+    authored/serialized Diagnostic fields — Cloud and Playground each ship this
+    map once rather than re-deriving a URL or restating a title per diagnostic.
     """
-    return {dc.code: dc.doc_url for dc in REGISTRY.all()}
+    return {
+        dc.code: DiagnosticDisplay(title=dc.title, doc_url=dc.doc_url)
+        for dc in REGISTRY.all()
+    }

dataface/agent_api/docs/yaml-reference.md

@@ -1177,13 +1177,10 @@ Authored overlay for VariablesStyle. Variable controls chrome styling.
 | `label` | [VariablesLabelStyle](#variableslabelstyle) | ✓ | Variable label typography. |
 | `value` | [VariablesValueStyle](#variablesvaluestyle) | ✓ | Variable value typography. |
 | `placeholder` | [VariablesPlaceholderStyle](#variablesplaceholderstyle) | ✓ | Style for unselected/hint text in variable inputs. |
-| `padding` | float | ✓ | Outer padding around the variables panel in pixels. |
 | `container_height` | float | ✓ | Height of the variables panel container in pixels. |
-| `container_padding` | float | ✓ | Inner padding of the variables panel container in pixels. |
 | `border` | [BorderStyle](#borderstyle) | ✓ | Variables panel border style. |
 | `control_gap` | float | ✓ | Gap between label and input within a single control in pixels. |
 | `input` | [InputStyle](#inputstyle) | ✓ | Input control style. |
-| `popover_rail_background` | str | ✓ | Background color for the preset rail (left column) inside the daterange chip's popover. Typically the theme's `surface-subtle` step — gray-50 on white-canvas themes, a cream-toned light on warm-canvas themes. Distinct from the popover card itself, which is always white-equivalent. |
 
 <a id="pagestyle"></a>
 ## PageStyle
@@ -1897,14 +1894,14 @@ Authored overlay for BlockMarginStyle. Top and bottom margin for a prose block r
 
 <a id="textcolumnstyle"></a>
 ## TextColumnStyle
-Authored overlay for TextColumnStyle. Multi-column layout for face body text (CSS column-count/gap/rule/max_chars).
+Authored overlay for TextColumnStyle. Author overrides for the column layout of face body text.
 
 | Field | Type | Optional | Description |
 |-------|------|:--------:|-------------|
-| `number` | int | ✓ | Fixed column count. None = single column. |
-| `gap` | float | ✓ | Gap between columns in pixels. None = use layout gap token. |
+| `number` | int | ✓ | Ceiling on the column count. The renderer may choose fewer when there is not enough text to fill them. None = no ceiling. |
+| `gap` | float | ✓ | Gap between columns in pixels. None = 1.5 line boxes, so the gutter scales with the type it separates. |
 | `rule` | str | ✓ | CSS column-rule shorthand, e.g. '1px solid #e5e7eb'. None = no rule. |
-| `max_chars` | int | ✓ | Target column width as a character count. The pixel width is derived at render time via fonttools OS/2.xAvgCharWidth × max_chars; column count auto-derives as ceil(available / col_width_px). |
+| `max_chars` | int | ✓ | Column width as a character count, overriding the shipped measure. The width is used exactly and the column count follows from it. |
 
 <a id="textcodestyle"></a>
 ## TextCodeStyle
@@ -2076,7 +2073,6 @@ Authored overlay for VariablesValueStyle. Per-value font substyle for variable c
 | Field | Type | Optional | Description |
 |-------|------|:--------:|-------------|
 | `font` | [FontStyle](#fontstyle) | ✓ | Variable value font style overrides. Unset fields fall back to [`style.variables.font`](#variablesstyle). |
-| `numeric_variant` | enum: "normal", "tabular-nums" | ✓ | OpenType numeric feature for value displays ('normal' or 'tabular-nums'). |
 
 <a id="variablesplaceholderstyle"></a>
 ## VariablesPlaceholderStyle
@@ -2339,7 +2335,6 @@ Authored overlay for ScaleContinuousStyle. Continuous-scale-only config: type, d
 | `zero` | bool \| enum: "auto" | ✓ | Force scale zero-baseline: True/False pins it; "auto" runs the Dataface smart-zero heuristic; None passes through to Vega-Lite. |
 | `type` | enum: "linear", "log", "pow", "sqrt", "symlog", "temporal" | ✓ | Scale type override. 'linear'/'log'/'pow'/'sqrt'/'symlog' pass straight through to Vega-Lite's quantitative scale.type. 'temporal' is a Dataface escape hatch for a cartesian x-axis: it forces a continuous temporal scale instead of the auto-inferred ordinal/nominal bucketed type, which is required before an authored ``domain`` of ISO dates can extend the visible range past the data extent. None lets Dataface/Vega-Lite infer from the field type. |
 | `domain` | list[Any] | ✓ | Explicit [low, high] scale domain; None lets Vega-Lite auto-determine from data. Must have exactly 2 elements — Dataface only wires a continuous range override through to Vega-Lite, not an explicit category enumeration. When ``type: temporal`` is set, both elements must be ISO-8601 date/datetime strings. |
-| `domain_strategy` | enum: "stable", "auto" | ✓ | How the numeric domain responds to filter-variable changes when no explicit `domain` is authored. 'stable' (the default when None) pins the domain to the chart query's full unfiltered extent — the same value lands at the same pixel across variable changes. 'auto' rescales the domain to the current filtered subset on every variable change. An explicit `domain` always wins over either strategy. |
 | `log` | [ScaleLogStyle](#scalelogstyle) | ✓ | Log-scale param (base); only meaningful with type: log. |
 | `pow` | [ScalePowStyle](#scalepowstyle) | ✓ | Power-scale param (exponent); only meaningful with type: pow. |
 | `symlog` | [ScaleSymlogStyle](#scalesymlogstyle) | ✓ | Symlog-scale param (constant); only meaningful with type: symlog. |

dataface/ai/skills/dashboard-pack-scaffolding/SKILL.md

@@ -153,7 +153,7 @@ in queries.
 dft serve
 ```
 
-Visit a landing page (e.g. `http://localhost:8080/zendesk/`) and click one of
+Visit a landing page (e.g. `http://localhost:8001/zendesk/`) and click one of
 the data links. It should redirect to the authored face. If it serves the
 generic system view instead, the alias is not set — check the face file.
 

dataface/cli/_error_format.py

@@ -15,6 +15,7 @@ not from a caller-supplied flag.
 from __future__ import annotations
 
 import json
+import sys
 from pathlib import Path
 
 from rich.markup import escape
@@ -50,25 +51,28 @@ def print_error(message: str) -> None:
         console.print(f"[bold red]Error:[/] {message}")
 
 
+def emit_diagnostics_jsonl(diags: list[Diagnostic]) -> None:
+    """Write diagnostics as JSON Lines to stderr — one compact JSON object per line.
+
+    Callers use this for the ``--diagnostics-json`` path: every diagnostic
+    (error or warning) is emitted to stderr so stdout stays the render payload,
+    and line-delimited JSON survives a truncated read with whole objects intact.
+    """
+    for d in diags:
+        print(json.dumps(d.model_dump(exclude_none=True)), file=sys.stderr)
+
+
 def print_diagnostics(
     diags: list[Diagnostic],
     *,
-    json_output: bool = False,
     path: Path | None = None,
 ) -> None:
-    """Print Diagnostics as Rich panels (stderr) or JSON (stdout).
+    """Print Diagnostics as Rich panels to stderr.
 
     `path` is a fallback "At:" location used only when a diagnostic has no
     `range` of its own (e.g. compile-time warnings that don't carry position
     data yet).
     """
-    if json_output:
-        print(
-            json.dumps(
-                {"errors": [d.model_dump(exclude_none=True) for d in diags]}, indent=2
-            )
-        )
-        return
     console = dft_console(stderr=True)
     for d in diags:
         style = "red" if d.level == "error" else "yellow"

dataface/cli/commands/render.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING
 import typer
 
 from dataface.agent_api import Diagnostic, RenderFormat
-from dataface.cli._error_format import print_diagnostics
+from dataface.cli._error_format import emit_diagnostics_jsonl, print_diagnostics
 from dataface.cli._project import with_project
 from dataface.cli.filesystem_project import FilesystemProject
 
@@ -119,6 +119,7 @@ def _emit_result(
     no_warnings: bool,
     fail_on_chart_errors: bool,
     print0: bool,
+    diagnostics_json: bool = False,
 ) -> str | None:
     """Turn a completed render into terminal/file output, or raise RenderFailed.
 
@@ -136,7 +137,11 @@ def _emit_result(
     if fail_on_chart_errors and result.chart_errors:
         raise RenderFailed(result.chart_errors)
 
-    if not no_warnings:
+    if diagnostics_json:
+        all_diags = list(result.warnings) + list(result.chart_errors)
+        if all_diags:
+            emit_diagnostics_jsonl(all_diags)
+    elif not no_warnings:
         _print_warnings(result.warnings)
 
     if format in ("json", "data"):
@@ -173,6 +178,7 @@ def render_command(
     max_workers: int | None = None,
     print0: bool = False,
     chart: str | None = None,
+    diagnostics_json: bool = False,
     *,
     project: FilesystemProject,
 ) -> str | None:
@@ -258,6 +264,7 @@ def render_command(
         no_warnings=no_warnings,
         fail_on_chart_errors=fail_on_chart_errors,
         print0=print0,
+        diagnostics_json=diagnostics_json,
     )
 
 
@@ -269,7 +276,7 @@ def render_command_from_yaml(
     variables: dict[str, str] | None = None,
     use_cache: bool = True,
     cache_path: Path | None = None,
-    json_errors: bool = False,
+    diagnostics_json: bool = False,
     no_warnings: bool = False,
     ignore_codes: set[str] | None = None,
     fail_on_chart_errors: bool = True,
@@ -296,7 +303,8 @@ def render_command_from_yaml(
             if absent), overriding project config. None (the default) falls
             through to the project's dataface.yml cache: block (path: null
             there means the zero-config in-memory default).
-        json_errors: Emit errors as JSON to stdout instead of Rich panels to stderr
+        diagnostics_json: Emit all diagnostics (errors and warnings) as JSON Lines
+            to stderr. Stdout stays the render payload on success.
         no_warnings: Suppress stderr warning output (warnings still appear in JSON)
         ignore_codes: Warning codes to suppress via the partition seam
         fail_on_chart_errors: Exit 1 when any per-chart runtime error exists
@@ -354,9 +362,14 @@ def render_command_from_yaml(
             no_warnings=no_warnings,
             fail_on_chart_errors=fail_on_chart_errors,
             print0=print0,
+            diagnostics_json=diagnostics_json,
         )
     except RenderFailed as exc:
-        print_diagnostics(exc.errors, json_output=json_errors)
+        if exc.errors:
+            if diagnostics_json:
+                emit_diagnostics_jsonl(exc.errors)
+            else:
+                print_diagnostics(exc.errors)
         raise typer.Exit(1) from exc
 
 
@@ -436,7 +449,7 @@ def render_commands(
     variables: dict[str, str] | None = None,
     use_cache: bool = True,
     cache_path: Path | None = None,
-    json_errors: bool = False,
+    diagnostics_json: bool = False,
     no_warnings: bool = False,
     ignore_codes: set[str] | None = None,
     fail_on_chart_errors: bool = True,
@@ -491,9 +504,14 @@ def render_commands(
                 max_workers=max_workers,
                 print0=print0,
                 chart=chart,
+                diagnostics_json=diagnostics_json,
             )
         except RenderFailed as exc:
-            print_diagnostics(exc.errors, json_output=json_errors)
+            if exc.errors:
+                if diagnostics_json:
+                    emit_diagnostics_jsonl(exc.errors)
+                else:
+                    print_diagnostics(exc.errors)
             has_failure = True
             if fail_fast:
                 raise typer.Exit(1) from exc

dataface/cli/main.py

@@ -718,14 +718,14 @@ def render(
             ),
         ),
     ] = None,
-    json_errors: Annotated[
+    diagnostics_json: Annotated[
         bool,
         typer.Option(
-            "--json-errors",
+            "--diagnostics-json",
             help=(
-                "Emit errors as JSON to stdout instead of formatted panels. "
-                "Only affects the error path; the success-path output is "
-                "still controlled by --format."
+                "Emit all diagnostics (errors and warnings) as JSON Lines to stderr. "
+                "Stdout stays the render payload on success; stderr carries "
+                "one compact JSON object per diagnostic, line-delimited."
             ),
         ),
     ] = False,
@@ -830,7 +830,7 @@ def render(
       dft render faces/sales.yml --format terminal
       dft render faces/sales.yml --no-cache
       dft render faces/sales.yml --cache renders.duckdb
-      dft render faces/sales.yml --json-errors
+      dft render faces/sales.yml --diagnostics-json
       dft render faces/sales.yml --no-warnings
       dft render faces/sales.yml --ignore-warning WARN-REDUNDANT-ENCODING
       dft render faces/sales.yml --allow-chart-errors
@@ -891,7 +891,7 @@ def render(
             variables=variables or None,
             use_cache=use_cache,
             cache_path=cache,
-            json_errors=json_errors,
+            diagnostics_json=diagnostics_json,
             no_warnings=no_warnings,
             ignore_codes=ignore_codes,
             fail_on_chart_errors=fail_on_chart_errors,
@@ -909,7 +909,7 @@ def render(
         variables=variables or None,
         use_cache=use_cache,
         cache_path=cache,
-        json_errors=json_errors,
+        diagnostics_json=diagnostics_json,
         no_warnings=no_warnings,
         ignore_codes=ignore_codes,
         fail_on_chart_errors=fail_on_chart_errors,

dataface/core/compile/chart_focus.py

@@ -42,6 +42,7 @@ from dataface.core.compile.models.face.normalized import (
     Layout,
     LayoutItem,
 )
+from dataface.core.compile.sizing import chart_slot_width
 
 
 def focus_on_chart(face: Face, chart_id: str) -> Face:
@@ -50,6 +51,9 @@ def focus_on_chart(face: Face, chart_id: str) -> Face:
     Creates a new face with:
     - Only the specified chart in the layout
     - Only the variables that chart depends on
+    - The chart pinned at the slot width the dashboard layout assigned it,
+      so the focused render is geometry-identical to the dashboard (WYSIWYG);
+      a chart not placed in the layout keeps its preferred width
     - All sources and queries unchanged (they're lazy-loaded anyway)
 
     This is called automatically when `chart_focus` is set in the YAML.
@@ -88,8 +92,15 @@ def focus_on_chart(face: Face, chart_id: str) -> Face:
         if name in chart.variable_dependencies
     }
 
-    # Create a simple layout with just this chart
-    chart_item = LayoutItem(type="chart", chart=chart)
+    # Pin the dashboard slot width so the focused chart keeps the exact
+    # geometry it had on the board (band widths, axis-label fit). The board
+    # container hugs the pinned width the same way it hugs preferred widths.
+    slot_width = chart_slot_width(face, chart_id)
+    chart_item = LayoutItem(
+        type="chart",
+        chart=chart,
+        user_width=None if slot_width is None else f"{slot_width}px",
+    )
     simple_layout = Layout(type=LayoutType.ROWS, items=[chart_item])
 
     # Create new face with focused content

dataface/core/compile/chart_update.py

@@ -36,13 +36,10 @@ Usage:
     )
 """
 
-import logging
 from typing import Any
 
 import yaml
 
-logger = logging.getLogger(__name__)
-
 
 def update_chart_in_yaml(
     yaml_content: str,
@@ -147,6 +144,25 @@ def update_chart_in_yaml(
         if field in edits and edits[field]:
             chart_def[field] = edits[field]
 
+    # Validate rewritability before any mutation.
+    # A rows/cols source_path must be exactly two segments (layout_key.N) where N
+    # is a digit — that is the only shape _update_layout_reference can rewrite.
+    # Deeper paths (rows.0.cols.1) name a chart inside a nested face; the nested
+    # face's own file must name the chart instead.
+    if source_path and source_path.split(".")[0] in ("rows", "cols"):
+        _segs = source_path.split(".")
+        if len(_segs) != 2:
+            raise ValueError(
+                f"Cannot promote inline chart at '{source_path}': only top-level "
+                "layout positions (rows.N / cols.N) are supported; name the chart "
+                "in the nested face's own file instead"
+            )
+        if not _segs[1].isdigit():
+            raise ValueError(
+                f"Cannot promote inline chart at '{source_path}': "
+                f"'{_segs[1]}' is not a valid integer index"
+            )
+
     # Update the charts section
     # If chart already exists, merge with existing values
     if chart_id in data["charts"]:
@@ -171,31 +187,19 @@ def update_chart_in_yaml(
 def _update_layout_reference(
     data: dict[str, Any], source_path: str, chart_id: str
 ) -> None:
-    """Update a layout position to reference a named chart instead of inline.
+    """Replace an inline chart at a top-level layout position with a named reference.
 
     Args:
         data: Parsed YAML data (modified in place)
-        source_path: Path like "rows.0" or "rows.0.cols.1"
+        source_path: Validated path of the form "rows.N" or "cols.N".
+            Caller guarantees exactly two segments and a digit index.
         chart_id: ID of the chart to reference
     """
-    # Only a top-level position is rewritable here: this replaces an entry in
-    # `data[layout_key]`, and a deeper path (`rows.0.cols.1`) names an entry in a
-    # nested face's own list, which this function never walks into.
-    segments = source_path.split(".")
-    if len(segments) != 2 or segments[0] not in ("rows", "cols"):
-        logger.debug(f"Unrecognized source_path format: {source_path}")
-        return
-    layout_key, raw_index = segments
-    if not raw_index.isdigit():
-        logger.warning(f"Failed to parse index from source_path: {source_path}")
-        return
+    layout_key, raw_index = source_path.split(".")
     index = int(raw_index)
-
-    # Update the layout
     if (
         layout_key in data
         and isinstance(data[layout_key], list)
         and 0 <= index < len(data[layout_key])
     ):
-        # Replace inline chart with named reference
         data[layout_key][index] = chart_id

dataface/core/compile/jinja.py

@@ -48,6 +48,7 @@ from jinja2 import (
 
 from dataface.core.compile._jinja_helpers import _LenientUndefined, _QueryNamespace
 from dataface.core.compile.errors import CompilationError, JinjaError
+from dataface.core.compile.parameterized import _LiteralCollector, _ParameterizedValue
 
 logger = logging.getLogger(__name__)
 
@@ -554,10 +555,25 @@ def resolve_query_sql_with_dependencies(
     # Phase 2: resolve variables via Jinja. filter()/filter_date_range() calls
     # are deferred (left verbatim) so they reach the SQL adapter's parameterized
     # pass instead of the raising compile-time stub — see resolve_jinja_template.
+    #
+    # Variables are wrapped in _ParameterizedValue with a _LiteralCollector so
+    # that {{ n }} still inlines as a literal (the reference-path contract) while
+    # {{ n | int }} / {{ n | float }} raise — matching the direct-path behavior
+    # and preventing silent value changes when {{ queries.X }} refs are added or
+    # removed. Using the same wrapper class as the direct path ensures equality,
+    # membership, and iteration operators delegate correctly to the raw value.
     if target_sql and ("{{" in target_sql or "{%" in target_sql):
-        target_sql = resolve_jinja_template(
-            target_sql, variables=variables, defer_filters=True
-        )
+        _collector = _LiteralCollector()
+        guarded_vars = {
+            name: _ParameterizedValue(name, val, _collector)
+            for name, val in (variables.items() if variables else ())
+        }
+        try:
+            target_sql = resolve_jinja_template(
+                target_sql, variables=guarded_vars, defer_filters=True
+            )
+        except (TypeError, KeyError) as e:
+            raise JinjaError(f"Template error: {e}", target_sql) from e
 
     return target_sql
 

dataface/core/compile/migrations/versions/v0_4_0.py

@@ -8,10 +8,11 @@ leaf move creates its destination container on demand, and the later
 container move must find that destination still empty (or absent) to avoid
 a spurious MigrationConflictError against an unrelated field that also sets
 the old container. See dataface/AGENTS.md's "Two validation boundaries" —
-these are structural moves; categorical_orient (deleted), ticks.interval
-(reinterpreted vocabulary, not renamed), and the band/point/quantize scale
-groups (deleted) are semantic changes with no lossless move and are left to
-raise UnsupportedSchemaError for manual migration.
+these are structural moves; categorical_orient (deleted), the stable-axis
+domain-strategy key (deleted), ticks.interval (reinterpreted vocabulary, not
+renamed), and the band/point/quantize scale groups (deleted) are semantic
+changes with no lossless move and are left to raise UnsupportedSchemaError for
+manual migration.
 """
 
 from __future__ import annotations
@@ -29,7 +30,6 @@ RENAMES: tuple[tuple[YamlKeyPath, YamlKeyPath], ...] = (
     (("scale", "continuous", "domain"), ("scale", "domain")),
     (("scale", "continuous", "zero"), ("scale", "zero")),
     (("scale", "continuous", "type"), ("scale", "type")),
-    (("scale", "continuous", "domain_strategy"), ("scale", "domain_strategy")),
     (("scale", "continuous", "log", "base"), ("scale", "base")),
     (("scale", "continuous", "pow", "exponent"), ("scale", "exponent")),
     (("scale", "continuous", "symlog", "constant"), ("scale", "constant")),

dataface/core/compile/models/chart/authored/__init__.py

@@ -64,7 +64,6 @@ from ._conditional_formatting import (
     ConditionalRule,
     FieldConditionalFormatting,
     _PredicateBase,
-    coerce_numeric,
     match_predicate,
 )
 from ._data_table import (
@@ -211,7 +210,6 @@ __all__ = [
     "FieldConditionalFormatting",
     "_PREDICATE_OPS",
     "_PredicateBase",
-    "coerce_numeric",
     "match_predicate",
     # data_table
     "CHART_DATA_TABLE_SUPPORTED_TYPES",

dataface/core/compile/models/chart/authored/_conditional_formatting.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import math
 from typing import Any, Literal
 
 from pydantic import (
@@ -20,6 +19,7 @@ from dataface.core.compile.models.style.theme import (
     VALID_FONT_WEIGHTS,
     font_weight_as_css,
 )
+from dataface.core.utils import coerce_numeric_cell
 
 
 class _PredicateBase(BaseModel):
@@ -120,22 +120,6 @@ def _validate_exactly_one_predicate(obj: Any) -> None:
         )
 
 
-def coerce_numeric(v: Any) -> float | None:
-    """Return float(v) for finite numeric-compatible values; None otherwise."""
-    if v is None or isinstance(v, bool):
-        return None
-    if isinstance(v, (int, float)):
-        result = float(v)
-        return result if math.isfinite(result) else None
-    if isinstance(v, str):
-        try:
-            result = float(v)
-            return result if math.isfinite(result) else None
-        except (ValueError, TypeError):
-            return None
-    return None
-
-
 def _in_value_matches(candidate: Any, value: Any) -> bool:
     """Equality check for a single ``in`` candidate, with the bool/int guard."""
     if isinstance(value, bool) != isinstance(candidate, bool):
@@ -159,7 +143,7 @@ def match_predicate(rule: _PredicateBase, value: Any) -> bool:
         return value != rule.ne
     if rule.in_ is not None:
         return any(_in_value_matches(candidate, value) for candidate in rule.in_)
-    v_coerced = coerce_numeric(value)
+    v_coerced = coerce_numeric_cell(value)
     if v_coerced is None:
         return False
     v = v_coerced

dataface/core/compile/models/config.py

@@ -162,6 +162,22 @@ class ChartRenderingConfig(ConfigNode):
         footer_rule_gap_px: int
         footer_timestamp_gap_px: int
 
+    class ProseConfig(ConfigNode):
+        target_chars: int
+        single_column_chars: int
+        min_chars: int
+        max_chars: int
+        min_lines_per_column: int
+        max_columns: int
+        gutter_line_boxes: float
+        orphan_penalty: float
+        widow_penalty: float
+        interior_break_penalty: float
+        block_break_penalty: float
+        balance_weight: float
+        balance_scale: float
+        balance_undershoot: float
+
     class DataTableConfig(ConfigNode):
         divider_gap: float
         chart_data_table_max_x_ticks: int
@@ -174,6 +190,7 @@ class ChartRenderingConfig(ConfigNode):
     bar: BarConfig
     type_inference: TypeInferenceConfig
     board: BoardConfig
+    prose: ProseConfig
     data_table: DataTableConfig
     stroke: StrokeConfig
     axis: AxisConfig

dataface/core/compile/models/style/resolved/_base.py

@@ -201,7 +201,6 @@ class ResolvedScaleContinuousStyle(BaseModel):
     zero: bool | Literal["auto"] | None = None
     type: Literal["linear", "log", "pow", "sqrt", "symlog", "temporal"] | None = None
     domain: list[Any] | None = None
-    domain_strategy: Literal["stable", "auto"] | None = None
     log: ResolvedScaleLogStyle | None = None
     pow: ResolvedScalePowStyle | None = None
     symlog: ResolvedScaleSymlogStyle | None = None

dataface/core/compile/models/style/resolved/_cascade.py

@@ -572,7 +572,6 @@ def build_resolved_scale(
                 zero=scale.continuous.zero,
                 type=scale.continuous.type,
                 domain=scale.continuous.domain,
-                domain_strategy=scale.continuous.domain_strategy,
                 log=(
                     ResolvedScaleLogStyle(base=scale.continuous.log.base)
                     if scale.continuous.log is not None

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

@@ -104,7 +104,6 @@ from dataface.core.compile.models.style.theme.board import (
     TitleWidthOffsetsStyle,
     _normalize_overflow_value,
     coerce_gap,
-    compute_text_column_count,
     font_weight_as_css,
 )
 from dataface.core.compile.models.style.theme.callout import (
@@ -414,6 +413,5 @@ __all__ = [
     "_RadialChartStyle",
     "_normalize_overflow_value",
     "coerce_gap",
-    "compute_text_column_count",
     "font_weight_as_css",
 ]

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

@@ -585,17 +585,6 @@ class ScaleContinuousStyle(ScaleDomainValidationMixin):
             "date/datetime strings."
         ),
     )
-    domain_strategy: Literal["stable", "auto"] | None = Field(
-        default=None,
-        description=(
-            "How the numeric domain responds to filter-variable changes when no "
-            "explicit `domain` is authored. 'stable' (the default when None) pins "
-            "the domain to the chart query's full unfiltered extent — the same "
-            "value lands at the same pixel across variable changes. 'auto' "
-            "rescales the domain to the current filtered subset on every variable "
-            "change. An explicit `domain` always wins over either strategy."
-        ),
-    )
     log: ScaleLogStyle | None = Field(
         default=None,
         description="Log-scale param (base); only meaningful with type: log.",