dataface 0.1.2__py3-none-any.whl

dataface/core/connections.py

@@ -0,0 +1,38 @@
+"""Public dft-core connection API.
+
+Single exported symbol: test_connection(source_config) → (bool, str).
+
+All DB connection machinery lives in execute/adapters/dbt_adapter_factory.py.
+Cloud and other consumers call this, not dbt.adapters directly.
+"""
+
+from typing import Any
+
+
+def test_connection(source_config: dict[str, Any]) -> tuple[bool, str]:
+    """Verify that source_config can reach the database.
+
+    Constructs a fresh adapter, pings with SELECT 1, and lets GC clean up
+    when the local reference drops at function exit. The temp target dir is
+    removed by the weakref.finalize registered in build_adapter.
+
+    Args:
+        source_config: Dict with a 'type' key and warehouse-specific fields.
+            Example: {"type": "duckdb", "path": ":memory:"}
+
+    Returns:
+        (True, "Connection successful") on success.
+        (False, "<error message>") on any failure — driver missing, bad creds,
+        network unreachable, unsupported type, etc.
+    """
+    from dataface.core.execute.adapters.dbt_adapter_factory import build_adapter
+
+    try:
+        adapter = build_adapter(source_config)
+        with adapter.connection_named("test"):
+            adapter.execute("SELECT 1", auto_begin=True, fetch=True)
+        return True, "Connection successful"
+    except (
+        Exception  # noqa: BLE001
+    ) as e:  # broad on purpose — surfaces driver-level errors as messages
+        return False, str(e) or type(e).__name__

dataface/core/dashboard.py

@@ -0,0 +1,358 @@
+"""Compile + execute + render orchestrator that returns a typed envelope.
+
+Counterpart to `core.render.face_api.render_face`, which raises on failure
+and returns raw output for external integrations (MkDocs, Sphinx). This
+module's `render_dashboard` packages compile errors, chart errors, and
+warnings into a `RenderedDashboard` Pydantic model — the shape the CLI
+render verb, the MCP tool, and the embedded HTTP server all consume.
+
+The agent_api dashboards module re-exports the public names so callers
+reach them via `dataface.agent_api.dashboards` (the typed-verb surface).
+The implementation lives here — top-level under `core` rather than under
+`core/render/` — so `core.serve.server` can call it without inverting the
+layer stack, and so the `dataface.core.render` function-vs-submodule name
+collision doesn't break `mock.patch("dataface.core.X.dashboard.Y")` on
+Python 3.10 (a real CI failure we hit when this module lived at
+`core/render/dashboard.py`).
+"""
+
+from __future__ import annotations
+
+import importlib.util as _importlib_util
+from pathlib import Path
+from typing import Any, Literal, get_args
+
+from pydantic import BaseModel
+
+from dataface.core.compile import compile, compile_file, get_project_warnings_ignore
+from dataface.core.compile.errors import DatafaceError
+from dataface.core.errors import (
+    DF_RENDER_FORMAT_UNSUPPORTED,
+    DF_RENDER_INPUT_INVALID,
+    DF_UNKNOWN_INTERNAL,
+    StructuredError,
+)
+from dataface.core.errors.structured import NextCommand
+from dataface.core.execute import ExecutionError, Executor
+from dataface.core.execute.adapters import AdapterRegistry
+from dataface.core.execute.duckdb_cache import DuckDBCache
+from dataface.core.render.warnings.base import RenderWarning
+from dataface.core.render.warnings.suppression import partition as _partition_warnings
+
+# Probe once at import time: avoids repeated find_spec calls and avoids
+# the `try/except ImportError` antipattern on our own modules.
+_SUPER_SCHEMA_AVAILABLE = _importlib_util.find_spec("dataface_super_schema") is not None
+
+
+def _enrich_fanout_warnings_if_available(result: Any) -> None:
+    """Enrich compiled queries with fanout warnings when private pkg is installed."""
+    if not _SUPER_SCHEMA_AVAILABLE:
+        return
+    from dataface_super_schema.inspect.relationship_warnings import (  # noqa: PLC0415
+        enrich_dashboard_fanout_warnings,
+    )
+
+    enrich_dashboard_fanout_warnings(result)
+
+
+from dataface.core.render import RenderError, render
+from dataface.core.render.board_links import LinkContext
+from dataface.core.scoped_paths import project_root_for, resolve_scoped_path
+
+RenderFormat = Literal["svg", "html", "png", "pdf", "terminal", "json", "text", "yaml"]
+
+
+class RenderedDashboard(BaseModel):
+    success: bool
+    # bytes for binary formats (png/pdf); str for text-based; dict for json.
+    # MCP callers should not request binary formats — `model_dump_json()` /
+    # `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
+    validation_errors: list[StructuredError] = []
+    warnings: list[RenderWarning] = []
+    suppressed_warnings: list[RenderWarning] = []
+    chart_errors: list[StructuredError] = []
+    face_error: StructuredError | None = None
+    url: str | None = None
+
+
+def _view_url(
+    path: Path,
+    variables: dict[str, Any] | None = None,
+    *,
+    port: int | None,
+    project_dir: Path | None = None,
+) -> str | None:
+    if port is None:
+        return None
+    from urllib.parse import urlencode
+
+    route_path = path
+    if path.is_absolute():
+        if project_dir is None:
+            return None
+        root = project_dir.resolve()
+        try:
+            route_path = path.resolve().relative_to(root)
+        except ValueError:
+            return None
+
+    url_path = route_path.with_suffix("").as_posix()
+    if url_path.startswith("faces/"):
+        url_path = url_path.removeprefix("faces/")
+    qs = "?" + urlencode(variables) if variables else ""
+    return f"http://localhost:{port}/{url_path}{qs}"
+
+
+def _stamp_file_commands(
+    errors: list[StructuredError],
+    file_path: Path,
+) -> list[StructuredError]:
+    """Return errors with a 'dft validate <file>' next_command added to each.
+
+    The compile path produces StructuredErrors without file context. When we
+    know the file that was compiled, stamp each error so the serve/HTML layer
+    can render the validate button.
+    """
+    cmd = NextCommand(label="Validate", command=f"dft validate {file_path}")
+    return [
+        (
+            err.model_copy(update={"next_commands": [cmd]})
+            if not err.next_commands
+            else err
+        )
+        for err in errors
+    ]
+
+
+def _input_error(message: str) -> RenderedDashboard:
+    """Build a RenderedDashboard failure from a plain input-validation message.
+
+    Stamped with DF-RENDER-INPUT-INVALID so consumers can distinguish user-supplied
+    bad arguments from internal failures.
+    """
+    return RenderedDashboard(
+        success=False,
+        validation_errors=[
+            DatafaceError.from_code(
+                DF_RENDER_INPUT_INVALID, message=message
+            ).to_structured()
+        ],
+    )
+
+
+def render_dashboard(
+    path: Path | None = None,
+    yaml_content: str | None = None,
+    project_dir: Path | None = None,
+    variables: dict[str, Any] | None = None,
+    *,
+    adapter_registry: AdapterRegistry | None = None,
+    format: str = "json",
+    server_port: int | None = None,
+    use_cache: bool = True,
+    scale: float | None = None,
+    as_link: bool = False,
+    link_context: LinkContext | None = None,
+    duckdb_cache: DuckDBCache | None = None,
+    ignore_codes: set[str] | None = None,
+) -> RenderedDashboard:
+    """Validate, compile, and render a Dataface dashboard."""
+    # as_link=True: compile-only path that returns a preview URL without
+    # executing queries — the cheap counterpart to a full render. Requires
+    # `path` (the URL points at the saved face on disk).
+    if as_link:
+        if not path:
+            return _input_error("as_link=True requires 'path'")
+        try:
+            link_file_path = resolve_scoped_path(path, project_dir)
+        except ValueError as exc:
+            return _input_error(str(exc))
+        if not link_file_path.exists():
+            return _input_error(f"File not found: {path}")
+        result = compile_file(link_file_path)
+        if not result.success:
+            return RenderedDashboard(
+                success=False,
+                validation_errors=_stamp_file_commands(result.errors, link_file_path),
+                warnings=list(result.warnings),
+                suppressed_warnings=list(result.suppressed_warnings),
+            )
+        return RenderedDashboard(
+            success=True,
+            warnings=list(result.warnings),
+            suppressed_warnings=list(result.suppressed_warnings),
+            url=_view_url(
+                link_file_path, variables, port=server_port, project_dir=project_dir
+            ),
+        )
+
+    if adapter_registry is None:
+        return _input_error(
+            "adapter_registry is required for full render "
+            "(or pass as_link=True with a path for link-only)"
+        )
+
+    allowed_formats = frozenset(get_args(RenderFormat))
+    if format not in allowed_formats:
+        return RenderedDashboard(
+            success=False,
+            validation_errors=[
+                DatafaceError.from_code(
+                    DF_RENDER_FORMAT_UNSUPPORTED, format=format
+                ).to_structured()
+            ],
+        )
+    if not path and not yaml_content:
+        return _input_error("Must provide either 'path' or 'yaml_content'")
+    if path and yaml_content:
+        return _input_error("Provide only one of 'path' or 'yaml_content', not both")
+
+    file_path: Path | None = None
+    if path:
+        try:
+            file_path = resolve_scoped_path(path, project_dir)
+        except ValueError as exc:
+            return _input_error(str(exc))
+        if not file_path.exists():
+            # No `file=` — `dft validate <missing-file>` would itself fail; don't
+            # surface that as a next-command suggestion.
+            return _input_error(f"File not found: {path}")
+        result = compile_file(file_path)
+    else:
+        if yaml_content is None:
+            return _input_error("yaml_content is required when no path is provided")
+        resolved_base = project_root_for(project_dir)
+        result = compile(
+            yaml_content,
+            base_dir=resolved_base,
+            project_dir=resolved_base,
+        )
+
+    if not result.success:
+        errs = (
+            _stamp_file_commands(result.errors, file_path)
+            if file_path is not None
+            else list(result.errors)
+        )
+        return RenderedDashboard(
+            success=False,
+            validation_errors=errs,
+            warnings=list(result.warnings),
+            suppressed_warnings=list(result.suppressed_warnings),
+        )
+
+    _enrich_fanout_warnings_if_available(result)
+    face = result.face
+    if face is None:
+        return RenderedDashboard(
+            success=False,
+            face_error=DatafaceError.from_code(
+                DF_UNKNOWN_INTERNAL,
+                message="Compilation did not produce a face",
+            ).to_structured(file=str(file_path) if file_path else None),
+        )
+
+    # Honor DFT_CACHE_PATH unless the caller passed an owned cache.
+    # When `duckdb_cache` is provided, the caller manages its lifecycle
+    # (e.g. dft serve's module-level singleton) — don't close it here.
+    from dataface.core.execute.duckdb_cache import open_cache_from_env
+    from dataface.core.render.render_result import RenderResult as _RenderResult
+
+    own_cache = duckdb_cache is None
+    cache = duckdb_cache if duckdb_cache is not None else open_cache_from_env()
+    render_result: _RenderResult
+    try:
+        executor = Executor(
+            face,
+            adapter_registry=adapter_registry,
+            query_registry=result.query_registry,
+            use_cache=use_cache,
+            duckdb_cache=cache,
+        )
+        render_options: dict[str, Any] = {}
+        if scale is not None:
+            render_options["scale"] = scale
+        if link_context is not None:
+            render_options["link_context"] = link_context
+        render_result = render(
+            face,
+            executor,
+            format=format,
+            variables=variables or {},
+            ignore_codes=ignore_codes,
+            project_dir=project_dir,
+            **render_options,
+        )
+        # Compile-side warnings haven't passed through the render-time partition,
+        # so --ignore-warning / dataface.yml / per-chart codes have no effect on
+        # them yet. Apply the same three-layer partition here for symmetry.
+        compile_active, compile_suppressed = _partition_warnings(
+            list(result.warnings),
+            cli_codes=ignore_codes or set(),
+            project_codes=set(get_project_warnings_ignore(project_dir)),
+            per_chart_codes={
+                chart_id: set(chart.warnings_ignore)
+                for chart_id, chart in face.charts.items()
+                if chart.warnings_ignore
+            },
+        )
+        if render_result.face_error is not None:
+            return RenderedDashboard(
+                success=False,
+                face_error=render_result.face_error,
+                chart_errors=render_result.chart_errors,
+                warnings=[*compile_active, *render_result.render_warnings],
+                suppressed_warnings=[
+                    *result.suppressed_warnings,
+                    *compile_suppressed,
+                    *render_result.suppressed_warnings,
+                ],
+            )
+        rendered_output = render_result.output
+        if rendered_output is None:
+            # face_error guard above returns early; this is unreachable in practice.
+            return RenderedDashboard(
+                success=False,
+                face_error=DatafaceError.from_code(
+                    DF_UNKNOWN_INTERNAL, message="Render produced no output"
+                ).to_structured(),
+            )
+        if format == "json":
+            import json
+
+            data: dict[str, Any] | str | bytes = json.loads(rendered_output)
+        elif isinstance(rendered_output, bytes):
+            # Binary formats (png, pdf) — pass bytes through unchanged.
+            data = rendered_output
+        else:
+            data = rendered_output
+    except (ExecutionError, RenderError) as e:
+        # Executor creation failures and MissingRequiredVariablesError (a RenderError
+        # subclass) reach here — these are face-level fatals, not per-chart errors.
+        return RenderedDashboard(
+            success=False,
+            face_error=e.to_structured(file=str(file_path) if file_path else None),
+        )
+    finally:
+        if own_cache and cache is not None:
+            cache.close()
+
+    url = (
+        _view_url(file_path, variables, port=server_port, project_dir=project_dir)
+        if file_path is not None
+        else None
+    )
+    return RenderedDashboard(
+        success=True,
+        data=data,
+        chart_errors=render_result.chart_errors,
+        warnings=[*compile_active, *render_result.render_warnings],
+        suppressed_warnings=[
+            *result.suppressed_warnings,
+            *compile_suppressed,
+            *render_result.suppressed_warnings,
+        ],
+        url=url,
+    )

dataface/core/defaults/default_config.yml

@@ -0,0 +1,101 @@
+# Default Dataface Configuration
+# ==============================
+#
+# STRUCTURE:
+#   style:           Resolved from the base theme (authorable visual config)
+#   [everything else] Engine internals — not per-face authorable
+#
+# All visual/authorable config lives in themes/ files.
+# See: themes/stark.yaml for the structural root style; themes/editorial.yaml is
+# the shipped default and adds editorial voice on top.
+
+# ============================================================================
+# STYLE — resolved from theme files
+# ============================================================================
+# All visual/authorable properties live in themes/.
+# The theme cascade: theme defaults → face style: → chart style:
+
+style:
+  extends: editorial
+
+
+# ============================================================================
+# VEGA-LITE
+# ============================================================================
+# Engine internals for the Vega-Lite output channel. The schema URL is a
+# Python constant (dataface.core.compile.vega_lite.VEGA_LITE_SCHEMA_URL) —
+# bumping it requires code changes, so it is not authorable here.
+
+vega:
+  default_theme: editorial
+
+
+# ============================================================================
+# CHART RENDERING CONSTANTS
+# ============================================================================
+# Algorithm constants for chart layout. Not per-face authorable — these
+# control axis label sizing, tooltip formatting, and rendering heuristics.
+
+chart_rendering:
+  default_width: 600
+  kpi:
+    # Spacing between value baseline and the title block. Title and support
+    # form a fixed 3-line block at one consistent rhythm — see
+    # ``_resolve_kpi_layout`` in ``core/render/chart/kpi.py``. Inner edge
+    # padding (top/bottom/left/right) all derive from
+    # ``style.charts.kpi.content_padding`` for a unified inset.
+    minimum_title_value_gap: 14.0
+  spark_bar:
+    title_height: 24.0
+    title_baseline_y: 16.0
+    more_rows_font_size: 10.0
+    more_rows_offset_y: 12.0
+    more_rows_bottom_padding: 8.0
+    text_baseline_offset: 4.0
+    side_padding: 4.0
+    avg_char_width_px: 7.0
+
+
+# ============================================================================
+# RENDERING / EXPORT DEFAULTS
+# ============================================================================
+
+rendering:
+  timestamp_visible: true
+  timestamp_format: "%Y-%m-%d %H:%M"
+  timestamp:
+    font:
+      size: 11
+      color: "#999999"
+    y: 14
+
+  # Page footer — right-aligned attribution at the bottom of every SVG-rendered
+  # face. Set footer_text to "" to disable. The terminal renderer does not emit
+  # a footer.
+  footer_text: "made with dataface"
+  footer:
+    font:
+      size: 11
+      color: "#999999"
+    y_offset: 14
+    rule:
+      color: "#e5e5e5"
+      stroke_width: 0.5
+
+  svg:
+    preserve_aspect_ratio: "xMidYMid meet"
+    background: null
+
+  png:
+    scale: 1.0
+    background: null
+
+  pdf:
+    background: null
+    page_size: "auto"
+
+  html:
+    background: "#ffffff"
+
+  terminal:
+    background: null

dataface/core/defaults/palettes/categorical/category-10-dark.yml

@@ -0,0 +1,32 @@
+# Categorical palette — category-10-dark
+#
+# Dark companion to category-10. Each stop is the darker counterpart of the
+# same slot in `category-10.yml` — used for direct labels that need higher
+# contrast against light backgrounds (e.g. right-pane endpoint labels on
+# multi-series lines, segment names on stacked bars).
+#
+# Pairing is positional: stop N here is the dark companion of stop N in
+# category-10. Reviewers edit the trio (`category-10`, `category-10-dark`,
+# `category-10-light`) together when the editorial palette changes — the
+# light companion (`category-10-light.yml`) handles de-emphasis fading;
+# this file handles direct-label inking.
+
+name: category-10-dark
+description: |
+  Dark companion to category-10. Ten slots, each darker than the matching
+  category-10 stop. Designed for direct-label color (chart endpoint labels,
+  right-pane segment names) where bright fills need a darker text counterpart
+  against light backgrounds. Pairing is positional: slot N here pairs with
+  slot N in category-10.
+
+colors:
+  - "#235a8a"    # 1 — blue       (companion to #2d74b3)
+  - "#2f9fbd"    # 2 — cyan       (companion to #41c6e7)
+  - "#3d7a5e"    # 3 — green      (companion to #40a97b)
+  - "#684e33"    # 4 — brown      (companion to #7a5531)
+  - "#98772c"    # 5 — gold       (companion to #dea628)
+  - "#82568d"    # 6 — purple     (companion to #a46fb2)
+  - "#ad562d"    # 7 — orange     (companion to #da5a23)
+  - "#526836"    # 8 — moss       (companion to #6f9041)
+  - "#6c7685"    # 9 — gray       (companion to #949daa)
+  - "#404852"    # 10 — charcoal  (companion to #505b6b)

dataface/core/defaults/palettes/categorical/category-10-light.yml

@@ -0,0 +1,43 @@
+# Categorical palette — category-10-light
+#
+# Light de-emphasis companion to category-10. Each stop is the lighter,
+# desaturated counterpart of the same slot in `category-10.yml` — used
+# for fading out-of-focus members of a series so the highlighted member
+# (rendered in its base color) reads forward. The intended use case is
+# editorial highlight-columns / dim-the-chorus emphasis, where typically
+# 1 series is emphasized and 1–2 are de-emphasized; this palette is sized
+# to that case, not to a 10-bar chorus.
+#
+# Pairing is positional: stop N here is the light companion of stop N in
+# category-10. Reviewers edit the trio (`category-10`, `category-10-dark`,
+# `category-10-light`) together when the editorial palette changes.
+#
+# Derivation: option-B uniform OKLCH lift, settled at L=0.86 with chroma
+# multiplied by 0.32 (per-slot hue preserved). Slot 6 (purple) is the
+# calibration anchor — it lands at L=0.861 C=0.037 H=318.8, ~7° off from
+# the source lavender swatch (#d3c8db, L=0.847 C=0.029 H=311.3) but on
+# the same purple axis as base #a46fb2. Slot 10 (charcoal) is held at
+# L=0.74 (main L − 0.12) so it stays visually distinct from slot 9
+# (gray) — without that override the two near-neutral slots collapse
+# into a single value at the uniform target L.
+
+name: category-10-light
+description: |
+  Light de-emphasis companion to category-10. Ten slots, each lighter and
+  more desaturated than the matching category-10 stop. Designed for fading
+  out-of-focus members of a series in highlight-columns / dim-the-chorus
+  emphasis design, where the highlighted member renders in its base color
+  and 1–2 others recede into the same hue at lower visual weight. Pairing
+  is positional: slot N here pairs with slot N in category-10.
+
+colors:
+  - "#bed4ea"    # 1 — blue       (companion to #2d74b3)
+  - "#b6d8e2"    # 2 — cyan       (companion to #41c6e7)
+  - "#bcd9c9"    # 3 — green      (companion to #40a97b)
+  - "#dccec2"    # 4 — brown      (companion to #7a5531)
+  - "#e0cfaf"    # 5 — gold       (companion to #dea628)
+  - "#dccae1"    # 6 — purple     (companion to #a46fb2)
+  - "#f2c6b6"    # 7 — orange     (companion to #da5a23)
+  - "#cad6bd"    # 8 — moss       (companion to #6f9041)
+  - "#ced1d6"    # 9 — gray       (companion to #949daa)
+  - "#a7abb1"    # 10 — charcoal  (companion to #505b6b)

dataface/core/defaults/palettes/categorical/category-10.yml

@@ -0,0 +1,31 @@
+# Categorical palette — category-10
+#
+# Migrated from dataface/core/defaults/chart_defaults.yml > palettes > category-10
+# Categorical palettes have no LUT, no surface variants, no interpolation.
+# Stops are what you get — exactly as authored.
+#
+# Companions (positional pairing — slot N of the companion pairs with slot N
+# here; reviewers edit the trio together when the editorial palette changes):
+#   - `category-10-dark.yml`  — darker twin, used to ink direct labels (e.g.
+#     endpoint labels on multi-series lines) so the label sits a notch
+#     darker than its line.
+#   - `category-10-light.yml` — lighter, desaturated twin, used to fade
+#     out-of-focus members in highlight-columns / dim-the-chorus emphasis.
+
+name: category-10
+description: |
+  Default 10-color categorical palette for qualitative data encoding.
+  Blue-first; calm editorial posture; earth-and-neutral expansion after
+  the first five hues. Pre-M2 palette, retained unchanged.
+
+colors:
+  - "#2d74b3"    # 1 — blue (default single-series)
+  - "#41c6e7"    # 2 — cyan
+  - "#40a97b"    # 3 — green
+  - "#7a5531"    # 4 — brown
+  - "#dea628"    # 5 — gold
+  - "#a46fb2"    # 6 — purple
+  - "#da5a23"    # 7 — orange
+  - "#6f9041"    # 8 — moss
+  - "#949daa"    # 9 — gray
+  - "#505b6b"    # 10 — charcoal

dataface/core/defaults/palettes/categorical/category-6-tonal-blue.yml

@@ -0,0 +1,22 @@
+# Categorical palette — category-6-tonal-blue
+#
+# Single-hue categorical palette anchored on category-10 slot 0 (blue, H≈248.8°
+# in OKLCH). Strict-safe core of 4 stops (color-alone CVD-safe under Leonardo
+# ΔE ≥ 11) plus 2 extended stops that REQUIRE redundant form encoding
+# (dash/marker/pattern) past slot 4. See docs/docs/guides/tonal-categorical-palette.md.
+
+name: category-6-tonal-blue
+description: |
+  Tonal monochromatic blue palette. 6 stops at fixed hue (H≈248.8°), all in
+  the blue family. Use for editorial / brand-restrained dashboards that want
+  one hue throughout. Strict-safe core: slots 0-3 (Leonardo ΔE ≥ 11 pairwise).
+  Extended: slots 4-5 (require dash, marker, or pattern redundancy past slot 4).
+  See docs/docs/guides/tonal-categorical-palette.md.
+
+colors:
+  - "#0375c4"    # 0 — bluish (anchor / default single-series)
+  - "#81b3e5"    # 1 — carolina blue (light tint)
+  - "#004a7f"    # 2 — prussian blue (dark saturated)
+  - "#002341"    # 3 — marine (very dark)
+  - "#6f89a3"    # 4 — blue/grey (extended; form-redundant)
+  - "#c2d3e4"    # 5 — light blue grey (extended; form-redundant)

dataface/core/defaults/palettes/categorical/category-6-tonal-brown.yml

@@ -0,0 +1,29 @@
+# Categorical palette — category-6-tonal-brown
+#
+# Single-hue categorical palette anchored on category-10 slot 3 (brown, H≈64°
+# in OKLCH). Variant of the F template with a hue-wobble in extended slots
+# (4-5) toward H≈78° to land in dft-creams territory — i.e., the lightest
+# extended stops visually bridge into the cream theme's chrome.
+
+name: category-6-tonal-brown
+description: |
+  Tonal monochromatic brown palette. 6 stops in the brown family, designed
+  to bridge into the dft-creams scaffold for cream-themed dashboards.
+  Slots 0-3 are saturated browns at H≈64° (sepia, mushroom, brown, dark brown);
+  slots 4-5 wobble +14° to H≈78° to land between cream-30 and cream-60 in
+  perceptual space — the extended stops feel continuous with the cream-theme
+  chrome rather than as separate "near-neutrals."
+
+  Strict-safe core: slots 0-3 (Leonardo ΔE ≥ 11 pairwise).
+  Extended: slots 4-5 (require form redundancy past slot 4; live in cream
+  territory and may have low contrast against cream-025 / cream-theme
+  backgrounds — that's the bridge, not a bug).
+  See docs/docs/guides/tonal-categorical-palette.md.
+
+colors:
+  - "#9a642b"    # 0 — sepia (anchor)
+  - "#c9a687"    # 1 — mushroom (light tan tint)
+  - "#683b01"    # 2 — brown (dark saturated)
+  - "#321c04"    # 3 — dark brown (very dark)
+  - "#908472"    # 4 — brown grey (extended; cream-bridge)
+  - "#d8d0c3"    # 5 — light grey (extended; cream-bridge)

dataface/core/defaults/palettes/categorical/category-6-tonal-green.yml

@@ -0,0 +1,20 @@
+# Categorical palette — category-6-tonal-green
+#
+# Single-hue categorical palette anchored on category-10 slot 2 (green, H≈161.3°
+# in OKLCH). Same architecture as category-6-tonal-blue.
+
+name: category-6-tonal-green
+description: |
+  Tonal monochromatic green palette. 6 stops at fixed hue (H≈161.3°), all in
+  the green family. Use for editorial / brand-restrained dashboards that want
+  one hue throughout. Strict-safe core: slots 0-3 (Leonardo ΔE ≥ 11 pairwise).
+  Extended: slots 4-5 (require dash, marker, or pattern redundancy past slot 4).
+  See docs/docs/guides/tonal-categorical-palette.md.
+
+colors:
+  - "#00875a"    # 0 — dark sea green (anchor)
+  - "#78c09c"    # 1 — pale teal (light tint)
+  - "#005638"    # 2 — spruce (dark saturated)
+  - "#002a19"    # 3 — dark forest green (very dark)
+  - "#6c907d"    # 4 — slate green (extended; form-redundant)
+  - "#c1d7cb"    # 5 — light grey (extended; form-redundant)