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

dataface/core/{compile/colors.py → colors.py}

@@ -1,6 +1,8 @@
-"""Color utility functions for Dataface renderers.
+"""CSS/SVG color-string validation.
 
-Provides color helpers for use across compile and render layers.
+Lives in core (below compile/execute/render) so both compile (pie-attachment
+table style resolution) and render (KPI/table SVG emission) can validate a
+foreign color string without either reaching into the other's layer.
 """
 
 from __future__ import annotations
@@ -8,11 +10,24 @@ from __future__ import annotations
 import re
 from typing import overload
 
-from dataface.core.compile.errors import CompilationError
+from dataface.core.diagnostics.base import DatafaceError
 
 _CSS_HEX_COLOR_PATTERN = re.compile(r"^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$")
 
 
+class InvalidColorError(DatafaceError):
+    """A color string is neither a valid hex color nor a recognized CSS keyword."""
+
+    def __init__(self, message: str):
+        self.message = message
+        self.fields = {}
+        super().__init__(message)
+        if self.code is None:
+            from dataface.core.diagnostics.codes_unknown import ERR_INTERNAL
+
+            self.code = ERR_INTERNAL
+
+
 def is_sanitizable_color(color: str) -> bool:
     """Return True if ``color`` is accepted by sanitize_color (hex or transparent/none)."""
     return bool(_CSS_HEX_COLOR_PATTERN.match(color)) or color.lower() in {
@@ -39,7 +54,7 @@ def sanitize_color(color: str | None, fallback: str | None = None) -> str | None
     inherited fill).
 
     ``fallback`` is returned when ``color`` is None or empty.  A non-None
-    ``color`` that is not a valid hex or keyword raises ``CompilationError``
+    ``color`` that is not a valid hex or keyword raises ``InvalidColorError``
     immediately — authored colors that are not valid are a configuration error,
     not a case for silent defaulting.
     """
@@ -49,4 +64,4 @@ def sanitize_color(color: str | None, fallback: str | None = None) -> str | None
         return color
     if color.lower() in {"transparent", "none"}:
         return "transparent"
-    raise CompilationError(f"Invalid color value: {color!r}")
+    raise InvalidColorError(f"Invalid color value: {color!r}")

dataface/core/compile/__init__.py

@@ -80,8 +80,6 @@ from dataface.core.compile.models.face.normalized import (
 from dataface.core.compile.models.query.authored import (
     AuthoredCompactValuesQuery,
     AuthoredHttpQuery,
-    AuthoredLookmlMergeQuery,
-    AuthoredLookmlQuery,
     AuthoredMetricflowQuery,
     AuthoredQuery,
     AuthoredSchemaQuery,
@@ -104,8 +102,6 @@ from dataface.core.compile.models.source import (
     DuckDBSourceConfig,
     HttpSourceConfig,
     JsonSourceConfig,
-    LookMLModelConfig,
-    LookMLModelsMixin,
     MySQLSourceConfig,
     ParquetSourceConfig,
     PostgresSourceConfig,
@@ -162,8 +158,6 @@ __all__ = [
     "SparkBarChart",
     "AuthoredCompactValuesQuery",
     "AuthoredHttpQuery",
-    "AuthoredLookmlQuery",
-    "AuthoredLookmlMergeQuery",
     "AuthoredMetricflowQuery",
     "AuthoredQuery",
     "AuthoredSchemaQuery",
@@ -196,8 +190,6 @@ __all__ = [
     "JsonSourceConfig",
     "HttpSourceConfig",
     "DbtProfileSourceConfig",
-    "LookMLModelConfig",
-    "LookMLModelsMixin",
     "VALID_SOURCE_TYPES",
     "parse_source_config",
     "is_database_source",

dataface/core/compile/channel.py

@@ -10,7 +10,6 @@ block (indexed by column name), not per-channel. See ``types.py`` for
 
 from __future__ import annotations
 
-import re
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from typing import Any, Protocol, runtime_checkable
@@ -72,8 +71,6 @@ class ConditionalFormattingChart(Protocol):
         ...
 
 
-_DOTTED_LOOKML_REF = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$")
-
 # Chart types whose color channel is a paintable mark fill — conditional_
 # formatting rules targeting `background` lower into their `color` channel.
 _MARK_FILL_CHART_TYPES: frozenset[str] = frozenset(
@@ -91,16 +88,6 @@ _MARK_FILL_CHART_TYPES: frozenset[str] = frozenset(
 )
 
 
-def is_dotted_lookml_ref(value: str) -> bool:
-    """True if `value` has the shape of a LookML `view.field` ref.
-
-    Exactly one dot, both sides valid identifiers, no spaces. Used by the
-    Surface B collect pass to find channel values that name LookML fields
-    rather than already-resolved column names.
-    """
-    return bool(_DOTTED_LOOKML_REF.match(value))
-
-
 def parse_style_channel(
     raw: _RawStyleChannel,
     channel_name: str,

dataface/core/compile/compiler.py

@@ -66,12 +66,10 @@ from dataface.core.compile.models.chart.authored import _BaseChartFields
 from dataface.core.compile.models.config import ProjectCacheConfig
 from dataface.core.compile.models.face.authored import (
     AuthoredFace,
-    ForeachItem,
     QueryOrRef,
 )
 from dataface.core.compile.models.face.normalized import Face
 from dataface.core.compile.models.query.authored import (
-    AuthoredLookmlQuery,
     AuthoredMetricflowQuery,
 )
 from dataface.core.compile.models.query.normalized import AnyQuery, is_sql_query
@@ -83,10 +81,9 @@ from dataface.core.compile.models.refs import (
 )
 from dataface.core.compile.models.variable.authored import Variable
 from dataface.core.compile.normalize_charts import (
-    collect_lookml_channel_refs,
     collect_metricflow_channel_refs,
 )
-from dataface.core.compile.normalize_queries import find_lookml_model_source
+from dataface.core.compile.normalize_queries import split_external_query_ref
 from dataface.core.compile.normalize_variables import (
     VariableReferenceErrors,
     synthetic_query_name,
@@ -100,6 +97,7 @@ from dataface.core.compile.parser import (
 )
 from dataface.core.compile.source_map import (
     LiteralBlock,
+    build_container_paths,
     build_literal_blocks,
     build_source_map,
     stamp_diagnostics,
@@ -163,6 +161,12 @@ class CompileResult:
             diagnostics (chart-render errors, render warnings, query
             diagnostics) reuse this same map via ``stamp_diagnostics`` instead
             of each doing its own position resolution.
+        container_paths: Dotted paths addressing a mapping/sequence rather
+            than a scalar, built alongside ``source_map``. Lets the stamping
+            pass collapse a container's whole-body range to its key line, so a
+            diagnostic about a chart marks the line naming it instead of every
+            line inside. Carried on the result for the same reason as
+            ``sql_blocks``: render-side stamping reuses it without recompiling.
         sql_blocks: Dotted-path -> LiteralBlock for every literal (``|``)
             block scalar, built alongside ``source_map``. Render-side
             diagnostics pass this to ``stamp_diagnostics`` too, so a query
@@ -188,6 +192,7 @@ class CompileResult:
     meta_lint: MetaLintConfig | None = None
     source_map: dict[str, SourceRange] = field(default_factory=dict)
     sql_blocks: dict[str, LiteralBlock] = field(default_factory=dict)
+    container_paths: frozenset[str] = frozenset()
 
     @property
     def success(self) -> bool:
@@ -211,11 +216,13 @@ def _stamp_compile_result(
         return result
     source_map = build_source_map(yaml_content, file)
     sql_blocks = build_literal_blocks(yaml_content)
+    containers = build_container_paths(yaml_content)
     result.source_map = source_map
     result.sql_blocks = sql_blocks
-    stamp_diagnostics(result.errors, source_map, sql_blocks)
-    stamp_diagnostics(result.warnings, source_map, sql_blocks)
-    stamp_diagnostics(result.suppressed_warnings, source_map, sql_blocks)
+    result.container_paths = containers
+    stamp_diagnostics(result.errors, source_map, sql_blocks, containers)
+    stamp_diagnostics(result.warnings, source_map, sql_blocks, containers)
+    stamp_diagnostics(result.suppressed_warnings, source_map, sql_blocks, containers)
     return result
 
 
@@ -315,7 +322,7 @@ def compile_authored_face(
     # ════════════════════════════════════════════════════════════════════
     # STEP 3b: Build Chart Registry (moved ahead of queries — Surface B's
     # collect pass below needs charts to find dotted-ref channel bindings
-    # before lookml queries lower to SQL).
+    # before semantic queries lower to SQL).
     # ════════════════════════════════════════════════════════════════════
     # Pool that imported charts' own query chains resolve into, lexically
     # scoped to each chart's source face (compile/AGENTS.md's "Cross-face
@@ -342,11 +349,10 @@ def compile_authored_face(
     # ════════════════════════════════════════════════════════════════════
     # STEP 3b.5: Desugar chart-level `model:` sugar into a synthesized named
     # query, before Surface B channel collection (below) so the synthesized
-    # query is visible to that pass. `model: model.explore` on a LookML source
-    # becomes a lookml query; `model: source.semantic_model` on a dbt_profile
-    # source becomes a metricflow query (roles inferred from the manifest in
-    # STEP 3c). Runs unconditionally so an unknown/ambiguous `model:` name still
-    # raises a clear error.
+    # query is visible to that pass. `model: source.semantic_model` on a
+    # dbt_profile source becomes a metricflow query (roles inferred from the
+    # manifest in STEP 3c). Runs unconditionally so an unknown/ambiguous
+    # `model:` name still raises a clear error.
     # ════════════════════════════════════════════════════════════════════
     metricflow_model_by_query: dict[str, str] = {}
     try:
@@ -375,33 +381,22 @@ def compile_authored_face(
             if len(_parts) != 2 or not all(_parts):
                 raise CompilationError(
                     f"chart '{_chart_key}' has `model: {_model_value!r}` — expected "
-                    "`model.explore` (a LookML model name and explore name "
-                    "joined by a dot)."
+                    "`source.semantic_model` (a dbt_profile source name and "
+                    "semantic model name joined by a dot)."
                 )
-            _model_name, _explore_name = _parts
-            _lookml_source = find_lookml_model_source(_model_name, sources_registry)
-            _source_cfg = sources_registry.get(_model_name)
-            _is_metricflow = (
-                _lookml_source is None
-                and isinstance(_source_cfg, dict)
+            _source_name, _semantic_model_name = _parts
+            _source_cfg = sources_registry.get(_source_name)
+            if not (
+                isinstance(_source_cfg, dict)
                 and _source_cfg.get("type") == "dbt_profile"
-            )
-            if _lookml_source is None and not _is_metricflow:
+            ):
                 raise CompilationError(
                     f"chart '{_chart_key}' has `model: {_model_value}` naming "
-                    f"unknown model '{_model_name}' — no source declares it in its "
-                    "'models:' map, and it is not a dbt_profile source."
+                    f"unknown source '{_source_name}' — it is not a dbt_profile source."
                 )
             _synth_name = synthetic_query_name("model_query", _chart_key)
-            if _is_metricflow:
-                authored.queries[_synth_name] = AuthoredMetricflowQuery(
-                    source=_model_name
-                )
-                metricflow_model_by_query[_synth_name] = _explore_name
-            else:
-                authored.queries[_synth_name] = AuthoredLookmlQuery(
-                    source=_model_name, explore=_explore_name
-                )
+            authored.queries[_synth_name] = AuthoredMetricflowQuery(source=_source_name)
+            metricflow_model_by_query[_synth_name] = _semantic_model_name
             # Mutate in place: _BaseChartFields declares query + model; plain
             # dicts use key assignment. Non-_BaseChartFields BaseModels (e.g.
             # CalloutChart) have no `model:` field and are skipped above.
@@ -415,31 +410,21 @@ def compile_authored_face(
         return CompileResult(errors=[e.to_diagnostic(file=file)])
 
     # ════════════════════════════════════════════════════════════════════
-    # STEP 3c: Collect dotted-ref (lookml) / bare-field (metricflow) chart
-    # channels into their synthesized queries, before query normalization
-    # lowers them. LookML collects `view.field` refs into a fields-less query;
-    # MetricFlow classifies bare fields against the manifest into
+    # STEP 3c: Collect bare-field (metricflow) chart channels into their
+    # synthesized queries, before query normalization lowers them. MetricFlow
+    # classifies bare fields against the manifest into
     # metrics/dimensions/time_grain.
     # ════════════════════════════════════════════════════════════════════
-    lookml_model_names: set[str] = set()
-    for _cfg in sources_registry.values():
-        if isinstance(_cfg, dict) and isinstance(_cfg.get("models"), dict):
-            lookml_model_names.update(_cfg["models"].keys())
-    if lookml_model_names or metricflow_model_by_query:
+    if metricflow_model_by_query:
         try:
             raw_queries: dict[str, QueryOrRef] = {}
             _collect_raw_queries(authored, raw_queries)
-            if lookml_model_names:
-                collect_lookml_channel_refs(
-                    collectible_charts, raw_queries, lookml_model_names
-                )
-            if metricflow_model_by_query:
-                collect_metricflow_channel_refs(
-                    collectible_charts,
-                    raw_queries,
-                    metricflow_model_by_query,
-                    base_dir,
-                )
+            collect_metricflow_channel_refs(
+                collectible_charts,
+                raw_queries,
+                metricflow_model_by_query,
+                base_dir,
+            )
         except CompilationError as e:
             return CompileResult(errors=[e.to_diagnostic(file=file)])
 
@@ -480,7 +465,7 @@ def compile_authored_face(
             # host-supplied fallback) so inline chart queries synthesized during
             # normalization inherit it too — not just the named queries built above.
             # `sources` (board-global named source configs) rides alongside so an
-            # inline lookml/metricflow query on a chart resolves its model just
+            # inline metricflow query on a chart resolves its model just
             # like an up-top query.
             parent_context={
                 "default_source": default_source,
@@ -983,11 +968,6 @@ def _extract_nested_faces(face: AuthoredFace) -> list[AuthoredFace]:
                 tabs=item.tabs,
             )
             nested_faces.append(tab_face)
-        elif isinstance(item, ForeachItem):
-            # Recurse into foreach items to find any nested faces
-            for foreach_subitem in item.foreach.items:
-                if isinstance(foreach_subitem, AuthoredFace):
-                    nested_faces.append(foreach_subitem)
 
     return nested_faces
 
@@ -1057,7 +1037,7 @@ def _collect_raw_queries(face: AuthoredFace, registry: dict[str, QueryOrRef]) ->
 
     Unlike `build_query_registry`, entries stay as authored AuthoredQuery/
     QueryRef instances — used by the Surface B collect pass, which must
-    mutate a lookml query's `fields` before `normalize_query` lowers it.
+    mutate a semantic query's fields before `normalize_query` lowers it.
     Cross-file QueryRef entries are included by reference but not resolved
     (a ref's own file already ran its own collect pass at its own compile).
     """
@@ -1075,7 +1055,7 @@ def _collect_inline_layout_charts(face: AuthoredFace, registry: dict[str, Any])
     `build_chart_registry` only sees top-level named `charts:` — a chart authored
     directly inline in `rows:`/`cols:`/`grid:`/`tabs:` (a bare AuthoredChart patch,
     or `dict[str, AuthoredChart]`) never gets a registry entry. The Surface B
-    collect pass (`collect_lookml_channel_refs`) needs to see and mutate those
+    collect pass (`collect_metricflow_channel_refs`) needs to see and mutate those
     authored chart objects in place before normalization re-serializes them.
 
     Keys are Python object ids (`id(chart_obj)`) — guaranteed unique per live
@@ -1086,7 +1066,7 @@ def _collect_inline_layout_charts(face: AuthoredFace, registry: dict[str, Any])
     def register(item: object) -> None:
         # Handles both the bare-patch form (`- type: bar, ...`) and the named-dict
         # form (`- my_chart: {type: bar, ...}`). Anything else (chart-name string,
-        # nested face, foreach) is not an inline chart and is skipped here.
+        # nested face, swatch strip) is not an inline chart and is skipped here.
         # str(id(item)) is unique per live Python object — safer key than a
         # position-only path, which collides when sibling nested faces share indices.
         if isinstance(item, _BaseChartFields):
@@ -1135,7 +1115,7 @@ def _process_queries_for_registry(
         registry: Registry to add queries to
         base_dir: ProjectDirectory anchor for the face file (used to resolve sub-file refs).
         default_source: Default source to apply to queries without explicit source
-        sources: Named source config dicts. Consulted by lookml queries at normalize time.
+        sources: Named source config dicts. Consulted by metricflow queries at normalize time.
         face_cache: The face-scope cache layer already folded down the nesting
             chain by the caller.
 
@@ -1252,7 +1232,7 @@ def build_query_registry(
         registry: Existing registry to add to
         default_source: Default source to apply to queries without explicit source
         sources: Named source config dicts (project + face level). Consulted by
-            lookml queries, which resolve their source at normalize time.
+            metricflow queries, which resolve their source at normalize time.
         face_cache: The cache layer this face inherits from the faces it is
             nested in; its own `cache:` folds over it inside `_build_registry`.
 
@@ -1397,6 +1377,26 @@ def _resolve_ref_item(
     return section[item_name], item_name, resolved_path, content
 
 
+def _face_level_default_source(
+    content: dict[str, YamlValue], file_label: str
+) -> str | None:
+    """Validated face-level `source:` of a raw source-file mapping.
+
+    Cross-face-pulled queries inherit the declaring file's default source. The
+    source file's content is a raw mapping here (never parsed into
+    AuthoredFace), so the string-ness the model would enforce is checked here.
+    """
+    source = content.get("source")
+    if source is None:
+        return None
+    if not isinstance(source, str):
+        raise CompilationError(
+            f"Invalid face-level `source:` in {file_label}: "
+            f"expected a source name string, got {type(source).__name__}"
+        )
+    return source
+
+
 def load_from_reference(
     reference: VariableRef | QueryRef | ChartRef,
     base_dir: ProjectDirectory | None = None,
@@ -1451,7 +1451,7 @@ def load_from_reference(
     else:
         section_name = "charts"
 
-    item_def, item_name, resolved_path, _content = _resolve_ref_item(
+    item_def, item_name, resolved_path, source_file_content = _resolve_ref_item(
         reference.ref, section_name, base_dir, yaml_path
     )
 
@@ -1459,6 +1459,7 @@ def load_from_reference(
         return normalize_query(
             item_name,
             item_def,
+            _face_level_default_source(source_file_content, str(resolved_path.relpath)),
             base_dir=base_dir,
             sources=sources,
             cache_root=cache_root,
@@ -1523,20 +1524,60 @@ def pull_cross_face_query_chain(
 
 
 def _is_lexically_scoped_query_name(value: str) -> bool:
-    """True when a chart's `query:`/`layers[].query` string is a bare name
-    that should resolve against the source face's own `queries:` section,
-    rather than: inline SQL (self-contained), a `#`-external ref (separate,
-    pre-existing mechanism — resolving it correctly for imported charts is a
-    tracked follow-up, not this task), or a full `<file>.queries.<name>`
-    cross-file ref written directly on the chart itself (an already-
-    ambiguous, unrelated edge case for local charts too — left untouched).
+    """True when a chart's `query:`/`layers[].query` string must resolve
+    against the *source* face rather than the importer: a bare name declared
+    in the source face's own `queries:` section, or a `<file>#<name>`
+    external ref anchored at the source face's own directory. Excluded is
+    inline SQL (self-contained) and a full `<file>.queries.<name>` cross-file
+    ref written directly on the chart itself (an already-ambiguous, unrelated
+    edge case for local charts too — left untouched).
     """
     stripped = value.strip()
-    return (
-        "#" not in stripped
-        and ".queries." not in stripped
-        and not looks_like_sql(stripped)
-    )
+    return ".queries." not in stripped and not looks_like_sql(stripped)
+
+
+def _read_queries_section(
+    file_dir: ProjectDirectory, target_file_str: str, ref: str, chart_ref: str
+) -> tuple[ProjectPath, dict[str, YamlValue], dict[str, YamlValue]]:
+    """The `queries:` section of `target_file_str`, resolved relative to
+    `file_dir` — the *declaring* file's own directory, never the importer's.
+
+    Also returns the file's full parsed mapping, so callers can read its
+    face-level `source:` default for the queries declared in it.
+
+    `ref` is the authored ref string this file part came from and `chart_ref`
+    the chart import that pulled it in; both are named in every failure, since
+    the author is looking at neither file when the resolution breaks.
+    """
+    where = f"Chart ref '{chart_ref}' requires '{ref}'"
+    try:
+        target_path = file_dir / target_file_str
+    except ValueError as e:
+        raise CompilationError(f"{where}: {e}") from e
+    if not target_path.exists():
+        raise CompilationError(
+            f"{where}, but {target_file_str} does not exist "
+            f"(resolved relative to {file_dir.relpath})."
+        )
+    try:
+        target_content = target_path.read_yaml()
+    except (OSError, yaml.YAMLError) as e:
+        raise CompilationError(f"{where}: failed to load {target_file_str}: {e}") from e
+    # read_yaml is -> Any: a file whose top level is a list or scalar parses
+    # fine and would only fail at the .get below, as an AttributeError escaping
+    # compile() rather than a diagnostic.
+    if target_content is not None and not isinstance(target_content, dict):
+        raise CompilationError(f"{where}, but {target_file_str} is not a YAML mapping.")
+    if target_content is None:
+        raise CompilationError(
+            f"{where}, but {target_file_str} has no queries: section."
+        )
+    target_queries = target_content.get("queries")
+    if not isinstance(target_queries, dict):
+        raise CompilationError(
+            f"{where}, but {target_file_str} has no queries: section."
+        )
+    return target_path, target_queries, target_content
 
 
 def _resolve_cross_face_query(
@@ -1549,6 +1590,7 @@ def _resolve_cross_face_query(
     resolving: set[tuple[str, str]],
     chart_ref: str,
     *,
+    default_source: str | None,
     sources: dict[str, Any],
     cache_root: CachePatch | None,
     face_cache: CachePatch,
@@ -1593,19 +1635,9 @@ def _resolve_cross_face_query(
         target_file_str, target_name = raw_def["ref"].rsplit(".queries.", 1)
         if not (target_file_str.endswith(".yml") or target_file_str.endswith(".yaml")):
             target_file_str += ".yml"
-        try:
-            target_path = file_dir / target_file_str
-        except ValueError as e:
-            raise CompilationError(str(e)) from e
-        if not target_path.exists():
-            raise CompilationError(f"Referenced file not found: {target_file_str}")
-        try:
-            target_content = target_path.read_yaml()
-        except (OSError, yaml.YAMLError) as e:
-            raise CompilationError(f"Failed to load {target_file_str}: {e}") from e
-        target_queries = target_content.get("queries") if target_content else None
-        if not isinstance(target_queries, dict):
-            raise CompilationError(f"No queries found in {target_file_str}")
+        target_path, target_queries, target_content = _read_queries_section(
+            file_dir, target_file_str, raw_def["ref"], chart_ref
+        )
         target_key = _resolve_cross_face_query(
             target_name,
             target_path.parent,
@@ -1615,6 +1647,7 @@ def _resolve_cross_face_query(
             key_cache,
             resolving,
             chart_ref,
+            default_source=_face_level_default_source(target_content, target_file_str),
             sources=sources,
             cache_root=cache_root,
             face_cache=face_cache,
@@ -1640,6 +1673,7 @@ def _resolve_cross_face_query(
                 key_cache,
                 resolving,
                 chart_ref,
+                default_source=default_source,
                 sources=sources,
                 cache_root=cache_root,
                 face_cache=face_cache,
@@ -1661,6 +1695,7 @@ def _resolve_cross_face_query(
     pool[qualified_key] = normalize_query(
         qualified_key,
         raw_def,
+        default_source,
         base_dir=file_dir,
         sources=sources,
         cache_root=cache_root,
@@ -1710,19 +1745,49 @@ def _load_chart_ref_with_lexical_queries(
         queries_section = {}
     file_dir = resolved_path.parent
     file_relpath = resolved_path.relpath
+    source_default = _face_level_default_source(content, str(file_relpath))
     key_cache: dict[tuple[str, str], str] = {}
     resolving: set[tuple[str, str]] = set()
 
-    def resolve_name(bare_name: str) -> str:
+    def resolve_name(name: str) -> str:
+        """A bare name resolves in the source face's own `queries:`; a
+        `<file>#<name>` external ref resolves in that file's, reached relative
+        to the source face's directory. Either way the resulting query lands
+        in `cross_face_queries` under a key qualified by the file it was
+        actually declared in — so an importer `#`-ref spelled identically to
+        the imported chart's, but pointing at a different file, stays its own
+        query.
+        """
+        stripped = name.strip()
+        if "#" not in stripped:
+            return _resolve_cross_face_query(
+                stripped,
+                file_dir,
+                file_relpath,
+                queries_section,
+                cross_face_queries,
+                key_cache,
+                resolving,
+                chart_ref.ref,
+                default_source=source_default,
+                sources=sources,
+                cache_root=cache_root,
+                face_cache=face_cache,
+            )
+        target_file_str, target_name = split_external_query_ref(stripped)
+        target_path, target_queries, target_content = _read_queries_section(
+            file_dir, target_file_str, stripped, chart_ref.ref
+        )
         return _resolve_cross_face_query(
-            bare_name.strip(),
-            file_dir,
-            file_relpath,
-            queries_section,
+            target_name,
+            target_path.parent,
+            target_path.relpath,
+            target_queries,
             cross_face_queries,
             key_cache,
             resolving,
             chart_ref.ref,
+            default_source=_face_level_default_source(target_content, target_file_str),
             sources=sources,
             cache_root=cache_root,
             face_cache=face_cache,

dataface/core/compile/data_table.py

@@ -53,11 +53,16 @@ def axis_offset(charts_style: ResolvedChartsStyle, style: DataTableStyle) -> flo
     # Visibility is read from the fully-merged cascade (includes Layer-6 authored-
     # label flips) so both label and title heights reflect the actual rendered state.
     merged = resolved_axis_style(charts_style, "axis_x", "band")
+    # labels.padding is always required by build_resolved_axis (the shared
+    # ResolvedAxisElementStyle dataclass types it Optional only to let title
+    # leave it unset — see AxisTitleStyle).
+    assert merged.labels.padding is not None, "axis_x.labels.padding unset"
     label_h = (
-        merged.label.padding + merged.label.font.size * style.label_max_lines
-        if merged.label.visible is not False and merged.label.font.size > 0
+        merged.labels.padding + merged.labels.font.size * style.label_max_lines
+        if merged.labels.visible is not False and merged.labels.font.size > 0
         else 0.0
     )
+    assert merged.title.padding is not None, "axis_x.title.padding unset"
     title_h = (
         merged.title.padding + merged.title.font.size
         if merged.title.visible is not False and merged.title.font.size > 0