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

dataface/cli/main.py

@@ -796,6 +796,16 @@ def render(
             ),
         ),
     ] = False,
+    chart: Annotated[
+        str | None,
+        typer.Option(
+            "--chart",
+            help=(
+                "Render only this chart (by chart id). "
+                "Valid only with a single face argument or stdin."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Render one or more dashboards to SVG, HTML, PNG, PDF, or terminal.
 
@@ -859,6 +869,14 @@ def render(
                 param_hint="--output",
             )
 
+    # --chart is ambiguous with multiple faces: no mapping syntax, no silent fanout.
+    if chart is not None and len(faces) > 1:
+        raise typer.BadParameter(
+            f"--chart is only valid with a single face argument; "
+            f"got {len(faces)} face arguments",
+            param_hint="--chart",
+        )
+
     # Stdin path (single face "-")
     if has_stdin:
         yaml_content = sys.stdin.read()
@@ -879,6 +897,7 @@ def render(
             fail_on_chart_errors=fail_on_chart_errors,
             max_workers=max_workers,
             print0=print0,
+            chart=chart,
         )
         return
 
@@ -897,6 +916,7 @@ def render(
         max_workers=max_workers,
         print0=print0,
         fail_fast=fail_fast,
+        chart=chart,
     )
 
 
@@ -1087,19 +1107,6 @@ def serve(
             ),
         ),
     ] = None,
-    allow_external_access: Annotated[
-        bool,
-        typer.Option(
-            "--allow-external-access",
-            help=(
-                "Allow author SQL to read local files / URLs through DuckDB "
-                "(read_csv, read_json_auto, httpfs). Off by default — serve runs "
-                "strict read-only. Opt in only for local dashboards that must read "
-                "files directly in SQL (e.g. glob analytics not expressible as file "
-                "sources); prefer type: csv/json/parquet sources otherwise."
-            ),
-        ),
-    ] = False,
 ) -> None:
     """Start the dashboard server.
 
@@ -1149,7 +1156,6 @@ def serve(
         max_workers=max_workers,
         no_cache=no_cache,
         cache_path=cache,
-        allow_external_access=allow_external_access,
     )
 
 

dataface/core/aliases.py

@@ -0,0 +1,27 @@
+"""Alias-URL semantics, shared by every host that resolves a face's ``aliases:``.
+
+A leaf module on purpose. An alias is claimed in a face and matched against an
+incoming request path as a *string*, so the two sides must normalize it
+identically or a claim resolves on one host and silently does nothing on the
+other. Hosts that keep their own board index (rather than building an
+``AliasIndex``) need that rule without importing the ``dft serve`` HTTP
+application to get it — ``core/serve/`` sits at the top of the dependency stack.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import unquote
+
+
+def normalize_alias_url(url: str) -> str:
+    """Normalize a URL key: percent-decode, ensure leading /, ensure trailing /."""
+    decoded = unquote(url)
+    if not decoded.startswith("/"):
+        raise ValueError(
+            f"Alias {url!r} is not absolute: aliases must start with a leading /. "
+            "Example: /old-reports/"
+        )
+    # Trailing-slash canonical: add if missing
+    if not decoded.endswith("/"):
+        decoded = decoded + "/"
+    return decoded

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,13 +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,
-    split_external_query_ref,
-)
+from dataface.core.compile.normalize_queries import split_external_query_ref
 from dataface.core.compile.normalize_variables import (
     VariableReferenceErrors,
     synthetic_query_name,
@@ -328,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
@@ -355,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:
@@ -388,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.
@@ -428,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)])
 
@@ -493,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,
@@ -996,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
 
@@ -1070,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).
     """
@@ -1088,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
@@ -1099,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):
@@ -1148,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.
 
@@ -1265,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`.
 
@@ -1410,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,
@@ -1464,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
     )
 
@@ -1472,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,
@@ -1550,10 +1538,13 @@ def _is_lexically_scoped_query_name(value: str) -> bool:
 
 def _read_queries_section(
     file_dir: ProjectDirectory, target_file_str: str, ref: str, chart_ref: str
-) -> tuple[ProjectPath, dict[str, YamlValue]]:
+) -> 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.
@@ -1577,12 +1568,16 @@ def _read_queries_section(
     # 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.")
-    target_queries = target_content.get("queries") if target_content else None
+    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
+    return target_path, target_queries, target_content
 
 
 def _resolve_cross_face_query(
@@ -1595,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,
@@ -1639,7 +1635,7 @@ 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"
-        target_path, target_queries = _read_queries_section(
+        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(
@@ -1651,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,
@@ -1676,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,
@@ -1697,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,
@@ -1746,6 +1745,7 @@ 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()
 
@@ -1769,12 +1769,13 @@ def _load_chart_ref_with_lexical_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 = _read_queries_section(
+        target_path, target_queries, target_content = _read_queries_section(
             file_dir, target_file_str, stripped, chart_ref.ref
         )
         return _resolve_cross_face_query(
@@ -1786,6 +1787,7 @@ def _load_chart_ref_with_lexical_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/introspection.py

@@ -27,8 +27,6 @@ from dataface.core.compile.models.factories import _PatchBase
 from dataface.core.compile.models.query.authored import (
     AuthoredCompactValuesQuery,
     AuthoredHttpQuery,
-    AuthoredLookmlMergeQuery,
-    AuthoredLookmlQuery,
     AuthoredMetricflowQuery,
     AuthoredQuery,
     AuthoredSchemaQuery,
@@ -42,7 +40,6 @@ from dataface.core.compile.models.source import (
     DuckDBSourceConfig,
     HttpSourceConfig,
     JsonSourceConfig,
-    LookMLModelConfig,
     MySQLSourceConfig,
     ParquetSourceConfig,
     PostgresSourceConfig,
@@ -133,9 +130,7 @@ def _is_authored_model(cls: Any) -> bool:
     """Return True if cls should be included in the IR.
 
     Includes authored.* models, primitives, _PatchBase subclasses, compiled
-    style models from style/theme/, LookMLModelConfig so
-    dict[str, LookMLModelConfig] fields emit additionalProperties refs in JSON
-    Schema, and *Patch models from models.cache (CachePatch is the authored
+    style models from style/theme/, and *Patch models from models.cache (CachePatch is the authored
     overlay for the cache block — same role as *StylePatch, different module).
     """
     if not (isinstance(cls, type) and issubclass(cls, BaseModel)):
@@ -148,7 +143,6 @@ def _is_authored_model(cls: Any) -> bool:
         or module.endswith("primitives")
         or module.endswith("style.theme")
         or ".style.theme." in module
-        or issubclass(cls, LookMLModelConfig)
         or (module.endswith(".models.cache") and cls.__name__.endswith("Patch"))
     )
 
@@ -576,8 +570,6 @@ def introspect() -> AuthorableSchema:
         AuthoredValuesQuery,
         AuthoredCompactValuesQuery,
         AuthoredSchemaQuery,
-        AuthoredLookmlQuery,
-        AuthoredLookmlMergeQuery,
         PaginationConfig,
         PostgresSourceConfig,
         SnowflakeSourceConfig,
@@ -591,7 +583,6 @@ def introspect() -> AuthorableSchema:
         JsonSourceConfig,
         HttpSourceConfig,
         DbtProfileSourceConfig,
-        LookMLModelConfig,
         # Compiled style root — walks style/theme/ types so inherit-chain metadata
         # (Inherit/InheritSlot markers) is visible in the schema IR.
         Style,
@@ -623,8 +614,6 @@ def introspect() -> AuthorableSchema:
         "AuthoredValuesQuery",
         "AuthoredCompactValuesQuery",
         "AuthoredSchemaQuery",
-        "AuthoredLookmlQuery",
-        "AuthoredLookmlMergeQuery",
     )
     if all(name in collected for name in query_variants):
         collected["AuthoredQuery"] = AuthorableModel(
@@ -632,7 +621,7 @@ def introspect() -> AuthorableSchema:
             doc=(
                 "Union of per-type authored query shapes. "
                 "type: is inferred from key presence when omitted (bare SQL string, "
-                "sql: -> sql; metrics: -> metricflow; explore:/merge: -> lookml; "
+                "sql: -> sql; metrics: -> metricflow; "
                 "url: -> http; rows:/values: -> values)."
             ),
             fields=[],

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

@@ -168,7 +168,7 @@ class _BaseChartFields(BaseModel):
         str | None,
         Field(
             default=None,
-            description="Semantic-layer entry point, two dot-joined names: 'model.explore' for a LookML source, or 'source.semantic_model' for a dbt_profile (MetricFlow) source. Channel fields name the model's fields directly; roles are inferred from the LookML catalog / dbt semantic manifest. Mutually exclusive with `query:`.",
+            description="Semantic-layer entry point, two dot-joined names: 'source.semantic_model' for a dbt_profile (MetricFlow) source. Channel fields name the model's fields directly; roles are inferred from the dbt semantic manifest. Mutually exclusive with `query:`.",
         ),
     ]
 

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

@@ -30,6 +30,7 @@ from pydantic import Discriminator
 
 from ._base import (
     NON_ASPECT_RATIO_TYPES,
+    PAINTS_MARKS,
     SVG_LAYOUT_PADDED_TYPES,
     ChartDependencies,
     _BaseChartFields,
@@ -75,6 +76,7 @@ model. Each variant's ``type:`` Literal is the discriminator key.
 __all__ = [
     # constants and helpers
     "NON_ASPECT_RATIO_TYPES",
+    "PAINTS_MARKS",
     "SVG_LAYOUT_PADDED_TYPES",
     "ChartDependencies",
     # discriminated union

dataface/core/compile/models/chart/normalized/_base.py

@@ -189,6 +189,32 @@ __all__ = [
 NON_ASPECT_RATIO_TYPES = frozenset({"table", "kpi", "spark_bar", "callout"})
 SVG_LAYOUT_PADDED_TYPES = frozenset({"table", "kpi", "spark_bar"})
 
+# Chart-type strings dispatched through get_emitter() (render/chart/emitters/__init__.py)
+# — the families that emit Vega-Lite marks. The complement (table, kpi, spark_bar,
+# callout) never paints a mark; it is drawn by a hand-crafted SVG renderer instead.
+# This is a different fact from SVG_LAYOUT_PADDED_TYPES above (that one is about
+# layout padding, not mark-painting) even though their complements happen to
+# coincide today — don't fold them into one set.
+#
+# These are RESOLVED-stage chart_type strings (ResolvedChart.chart_type), not
+# normalized-stage ones. The normalized `.type` vocabulary also contains
+# `donut`, `map`, and `bubble_map` — they collapse to `pie`/`geoshape`/
+# `point_map` only at resolve. Applying this set to a normalized `.type` would
+# silently misclassify those three as non-painting.
+PAINTS_MARKS = frozenset(
+    {
+        "bar",
+        "histogram",
+        "line",
+        "area",
+        "scatter",
+        "heatmap",
+        "pie",
+        "geoshape",
+        "point_map",
+    }
+)
+
 
 @dataclass(frozen=True)
 class ChartDependencies:

dataface/core/compile/models/config.py

@@ -217,6 +217,11 @@ class ExecutionConfig(ConfigNode):
     max_query_duration_seconds: int = Field(
         gt=0, description="Maximum seconds a single query may run (must be > 0)."
     )
+    # Hard cap on files matched per glob pattern in file sources. Error is raised
+    # before any file is read so a runaway glob fails fast. Override in dataface.yml.
+    max_glob_file_count: int = Field(
+        gt=0, description="Maximum files a single glob may match (must be > 0)."
+    )
     # sqlglot uses different dialect names than Dataface's public-facing dialect strings.
     # This mapping normalizes Dataface names to sqlglot equivalents before parsing.
     dialect_aliases: dict[str, str]