dataface 0.1.5.dev215__py3-none-any.whl → 0.1.5.dev237__py3-none-any.whl

dataface/DATAFACE_SYNTAX.md

@@ -206,15 +206,20 @@ chart_focus: revenue_trend     # Render only one chart with its dependent variab
 details: "Click to expand"     # Collapsible section
 expanded_title: "Hide details"
 expanded: false
+
+aliases:                       # Additional URLs that 302-redirect to this face
+  - /old-reports/
+  - /legacy/sales/
 ```
 
-Top-level fields (23 total):
+Top-level fields (24 total):
 
 | Field | Type | Notes |
 |-------|------|-------|
 | `title` | string | Display title |
 | `description` | string | Description text |
 | `tags` | list[string] | Tags for categorization/search |
+| `aliases` | list[string] | See [Aliases](#aliases) below |
 | `text` | string | Markdown body for text-only faces |
 | `source` | string | Default source shorthand (equivalent to `sources.default`) |
 | `sources` | object | `{default: name, <name>: {type: ...}}` |
@@ -238,6 +243,27 @@ Top-level fields (23 total):
 
 `face:` as a top-level key is rejected. Put face properties (title, rows, queries, …) directly at the YAML root.
 
+### Aliases
+
+`aliases:` is a list of absolute URL paths that 302-redirect to this face's canonical file-path URL.  Each entry must start with `/`; trailing slashes are normalized automatically.
+
+```yaml
+aliases:
+  - /old-reports/
+  - /legacy/sales/
+```
+
+Rules:
+- An alias must not collide with a real face file path — the server raises an error at startup if it does.
+- Each alias must be unique across the project — two faces claiming the same alias is a startup error.
+- Aliasing a generated system route (entity or inspector view) is allowed: the redirect takes precedence, letting you override what that URL serves.
+
+There are two ways to override an entity/inspector route for a given path:
+- **Face file at that path** — create `faces/entity/warehouse/schema/table.yml` and the server renders it directly (no redirect).
+- **`aliases:` entry** — any face can declare `/entity/…/` as an alias; the server issues a 302 to the declaring face's canonical URL.
+
+Both approaches work.  A face file wins without a redirect round-trip; an alias lets a face live anywhere and still capture a system-view URL.
+
 ### Board style
 
 `style:` on a face, nested face, or layout section accepts a fixed set of keys — not arbitrary CSS:

dataface/agent_api/__init__.py

@@ -53,8 +53,20 @@ from dataface.agent_api.init import (
 )
 from dataface.agent_api.project import Project as Project
 from dataface.agent_api.query import QueryFaceResult, query_face
+from dataface.agent_api.schema_hints import (
+    SchemaHints as SchemaHints,
+    schema_hints as schema_hints,
+)
 from dataface.agent_api.validate import ValidateDashboardArgs, ValidateResult
+from dataface.agent_api.validate_query import (
+    QueryDiagnostic as QueryDiagnostic,
+    validate_query as validate_query,
+)
 from dataface.core.compile.config import ProjectSourcesConfig as ProjectSourcesConfig
+from dataface.core.errors.structured import StructuredError as StructuredError
+from dataface.core.fonts import get_inter_font_path as get_inter_font_path
+from dataface.core.render.board_links import LinkContext as LinkContext
+from dataface.core.render.errors import RenderError as RenderError
 
 __all__ = [
     "DescribeFaceArgs",
@@ -63,15 +75,23 @@ __all__ = [
     "DocsResult",
     "DocsSearchHit",
     "InitResult",
+    "LinkContext",
     "Project",
     "ProjectSourcesConfig",
+    "QueryDiagnostic",
     "QueryFaceResult",
     "RenderedDashboard",
+    "RenderError",
+    "SchemaHints",
+    "StructuredError",
     "Topic",
     "ValidateDashboardArgs",
     "ValidateResult",
     "describe_face",
+    "get_inter_font_path",
     "init_project",
     "query_face",
     "render_dashboard",
+    "schema_hints",
+    "validate_query",
 ]

dataface/agent_api/docs/yaml-reference.md

@@ -9,6 +9,7 @@ AuthoredFace (dataface) definition from YAML.
 | `title` | str | ✓ | Dashboard title displayed at the top. |
 | `description` | str | ✓ | Description text for the dashboard. |
 | `tags` | list[str] | ✓ | Tags for categorization and search. |
+| `aliases` | list[str] | ✓ | Additional URLs that redirect to this face's canonical file-path URL. Each entry must be absolute (leading /). Requests to these URLs are redirected (302) to the face's real path, query string preserved. Valid on .yml, .yaml, .md, and folder index.* faces. |
 | `docs` | str | ✓ | Relative path under the docs site for the canonical doc page that explains this face. Surfaced as a 'Docs →' link in the playground gallery when DFT_DOCS_URL is set. |
 | `text` | str | ✓ | Markdown text content for text-only sections. |
 | `allow_html` | bool | ✓ | Render the face's body text as raw HTML via foreignObject instead of markdown. TRUSTED-CONTENT ONLY: the HTML (including any Jinja-interpolated values) is rendered as-authored — this is NOT a security sandbox. mdsvg strips <script>/event-handlers as a best-effort guard, not a guarantee. Enable only on first-party faces you fully control. |

dataface/agent_api/entity_paths.py

@@ -0,0 +1,221 @@
+"""Entity URL surfacing and alias typo lint.
+
+Provides:
+- EntityPathInfo: the agent-facing wire shape for a canonical entity URL
+  (url, resolves_to: "generic" | "authored", face)
+- entity_paths_for_source/schema/table: compute entity URLs and check the
+  alias index to determine whether a face overrides the generic system view
+- entity_paths_list: flat list of EntityPathInfo (source + schema + table level)
+  from a SchemaResponse — used for --entity-paths CLI flag and agent discovery
+- validate_entity_aliases: typo lint for /entity/ prefixed aliases — checks
+  source names only (config only, no DB connection required).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from dataface.agent_api.schema import SchemaResponse
+    from dataface.core.serve.alias_index import AliasIndex
+
+
+@dataclass
+class EntityPathInfo:
+    """Canonical entity URL with resolution status.
+
+    Wire shape (pinned by contract test — any change is a breaking API change):
+        {"url": "/entity/src/schema/table/", "resolves_to": "generic"}
+        {"url": "...", "resolves_to": "authored", "face": "/sales/"}
+    """
+
+    url: str
+    resolves_to: Literal["generic", "authored"]
+    face: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to the agent wire shape, omitting face when generic."""
+        d: dict[str, Any] = {"url": self.url, "resolves_to": self.resolves_to}
+        if self.face is not None:
+            d["face"] = self.face
+        return d
+
+
+def entity_paths_for_source(
+    source: str,
+    *,
+    alias_index: AliasIndex,
+) -> EntityPathInfo:
+    """Return the entity URL info for a source.
+
+    The canonical URL is /entity/<source>/. When a face aliases it the
+    resolves_to is 'authored' and face is the canonical face URL.
+    """
+    url = f"/entity/{source}/"
+    face = alias_index.lookup(url)
+    if face is not None:
+        return EntityPathInfo(url=url, resolves_to="authored", face=face)
+    return EntityPathInfo(url=url, resolves_to="generic")
+
+
+def entity_paths_for_schema(
+    source: str,
+    schema: str,
+    *,
+    alias_index: AliasIndex,
+) -> EntityPathInfo:
+    """Return the entity URL info for a schema.
+
+    The canonical URL is /entity/<source>/<schema>/. When a face aliases it
+    the resolves_to is 'authored' and face is the canonical face URL.
+    """
+    url = f"/entity/{source}/{schema}/"
+    face = alias_index.lookup(url)
+    if face is not None:
+        return EntityPathInfo(url=url, resolves_to="authored", face=face)
+    return EntityPathInfo(url=url, resolves_to="generic")
+
+
+def entity_paths_for_table(
+    source: str,
+    schema: str,
+    table: str,
+    *,
+    alias_index: AliasIndex,
+) -> EntityPathInfo:
+    """Return the entity URL info for a table.
+
+    The canonical URL is /entity/<source>/<schema>/<table>/. When a face
+    aliases it the resolves_to is 'authored' and face is the canonical face URL.
+    """
+    url = f"/entity/{source}/{schema}/{table}/"
+    face = alias_index.lookup(url)
+    if face is not None:
+        return EntityPathInfo(url=url, resolves_to="authored", face=face)
+    return EntityPathInfo(url=url, resolves_to="generic")
+
+
+def validate_entity_aliases(
+    aliases: list[str],
+    *,
+    source_names: frozenset[str],
+) -> list[str]:
+    """Lint /entity/ prefixed aliases against configured source names.
+
+    Called at dft-validate time (connection-free). Checks that every
+    /entity/ URL references a known source, and errors with available
+    sources as a hint when not.
+
+    Returns a list of error message strings (empty = all valid).
+    Aliases not prefixed with /entity/ are silently skipped.
+    """
+    errors: list[str] = []
+    for raw_alias in aliases:
+        # Normalize: trailing-slash canonical, strip percent-encoding
+        from urllib.parse import unquote
+
+        alias = unquote(raw_alias)
+        if not alias.endswith("/"):
+            alias = alias + "/"
+
+        if not alias.startswith("/entity/"):
+            continue
+
+        # Strip leading "/entity/" and trailing "/" to get segments
+        inner = alias[len("/entity/") :]
+        if inner.endswith("/"):
+            inner = inner[:-1]
+        segments = [s for s in inner.split("/") if s]
+
+        if not segments:
+            # Bare /entity/ — no validation needed
+            continue
+
+        # Segment 0: source
+        source = segments[0]
+        if source not in source_names:
+            available = sorted(source_names)
+            hint = (
+                f"available sources: {', '.join(available)}"
+                if available
+                else "no sources configured"
+            )
+            errors.append(
+                f"Entity alias {raw_alias!r} references unknown source {source!r}. "
+                f"Did you mean one of: {hint}"
+            )
+
+    return errors
+
+
+def entity_paths_list(
+    schema_response: SchemaResponse,
+    *,
+    alias_index: AliasIndex,
+) -> list[EntityPathInfo]:
+    """Build a flat list of EntityPathInfo from a SchemaResponse.
+
+    Iterates all sources → schemas → tables in the response and returns one
+    EntityPathInfo per source, per schema, and per table, checking the alias
+    index for author overrides at each level.
+    """
+    result: list[EntityPathInfo] = []
+    for source_name, source_data in schema_response.sources.items():
+        result.append(entity_paths_for_source(source_name, alias_index=alias_index))
+        for schema_name, schema_data in (source_data.get("schemas") or {}).items():
+            result.append(
+                entity_paths_for_schema(
+                    source_name, schema_name, alias_index=alias_index
+                )
+            )
+            for table_name in schema_data.get("tables") or {}:
+                result.append(
+                    entity_paths_for_table(
+                        source_name,
+                        schema_name,
+                        table_name,
+                        alias_index=alias_index,
+                    )
+                )
+    return result
+
+
+def build_alias_index_for_project(project_dir: Path) -> AliasIndex:
+    """Build an AliasIndex from a project directory.
+
+    Uses the same faces_at_root detection logic as the server. Intended for
+    CLI commands (dft schema --entity-paths) that need alias lookup without
+    starting a server.
+    """
+    from dataface.core.serve.alias_index import AliasIndex
+
+    faces_dir = project_dir / "faces"
+    faces_at_root = faces_dir.is_dir()
+    return AliasIndex.build(
+        project_dir=project_dir,
+        faces_dir=faces_dir,
+        faces_at_root=faces_at_root,
+    )
+
+
+def entity_alias_errors_for_file(
+    face_file: Path,
+    source_names: frozenset[str],
+) -> list[str]:
+    """Read aliases from a face file and lint any /entity/ prefixed ones.
+
+    Source-name check only — no DB connection, no resolver. Called from the
+    validate path which must stay connection-free.
+
+    Returns a list of error message strings; empty means no entity alias issues.
+    Silently returns [] when the file cannot be parsed (compile catches that).
+    """
+    from dataface.core.serve.alias_index import _read_aliases_from_file
+
+    try:
+        aliases = _read_aliases_from_file(face_file)
+    except ValueError:
+        return []  # compile path reports alias parse errors with better context
+    return validate_entity_aliases(aliases, source_names=source_names)

dataface/agent_api/project.py

@@ -28,8 +28,8 @@ from dataface.agent_api.validate import (
 )
 from dataface.core.compile.config import (
     ProjectSourcesConfig,
-    get_project_sources,
     get_project_warnings_ignore,
+    load_project_sources,
 )
 from dataface.core.execute.adapters.adapter_registry import (
     AdapterRegistry,
@@ -40,6 +40,7 @@ from dataface.core.execute.duckdb_cache import DuckDBCache
 if TYPE_CHECKING:
     from dataface.core.dashboard import RenderedDashboard, RenderFormat
     from dataface.core.execute.source_resolver import SourceResolver
+    from dataface.core.render.board_links import LinkContext
 
 
 @dataclass(init=False)
@@ -72,6 +73,7 @@ class Project:
         project_root: Path,
         cache: DuckDBCache | None = None,
         adapter_registry: AdapterRegistry | None = None,
+        read_only: bool = True,
     ) -> None:
         self.project_root = project_root
         self.cache = cache
@@ -82,7 +84,7 @@ class Project:
             # cached_property stores in __dict__; pre-populating makes the descriptor
             # short-circuit the build on first access.
             self.__dict__["adapter_registry"] = adapter_registry
-        self._read_only = True
+        self._read_only = read_only
         self._dbt_project_path = None
         self._connection_string = None
         self._dialect = "duckdb"
@@ -90,7 +92,7 @@ class Project:
         self._duckdb_config = None
         self._allow_external_access_in_readonly = False
         self._resolver = None
-        self._sources = get_project_sources(self.project_root)
+        self._sources = load_project_sources(self.project_root)
         self._warnings_ignore = get_project_warnings_ignore(self.project_root)
 
     @classmethod
@@ -119,8 +121,9 @@ class Project:
         Call ``refresh()`` to close the current registry and force a rebuild on the
         next access.
         """
-        project = cls(project_root=Path(project_dir).resolve(), cache=cache)
-        project._read_only = read_only
+        project = cls(
+            project_root=Path(project_dir).resolve(), cache=cache, read_only=read_only
+        )
         project._dbt_project_path = dbt_project_path
         project._connection_string = connection_string
         project._dialect = dialect
@@ -170,7 +173,7 @@ class Project:
         if self._owns_registry and "adapter_registry" in self.__dict__:
             self.adapter_registry.close()
             del self.__dict__["adapter_registry"]
-        self._sources = get_project_sources(self.project_root)
+        self._sources = load_project_sources(self.project_root)
         self._warnings_ignore = get_project_warnings_ignore(self.project_root)
 
     def close(self) -> None:
@@ -191,10 +194,20 @@ class Project:
     # ── Verb forwarders ──────────────────────────────────────────────────────
 
     def validate(self, face_path: Path) -> ValidateResult:
-        return _validate.validate(face_path, project_dir=self.project_root)
+        result = _validate.validate(face_path, project_dir=self.project_root)
+        annotated = _validate.annotate_with_entity_lint([result], project=self)
+        return annotated[0]
 
     def validate_paths(self, paths: list[Path] | None) -> list[ValidateResult]:
-        return _validate.validate_paths(paths, project_dir=self.project_root)
+        results = _validate.validate_paths(paths, project_dir=self.project_root)
+        return _validate.annotate_with_entity_lint(results, project=self)
+
+    def _source_names(self) -> frozenset[str]:
+        """Return the configured source names for entity alias validation.
+
+        Reads from the project config file — no adapter registry or DB connection needed.
+        """
+        return frozenset(self._sources.sources.keys())
 
     def describe_face(self, path: Path) -> _describe.DescribeFaceResult:
         return _describe.describe_face(path, project_dir=self.project_root)
@@ -288,6 +301,7 @@ class Project:
         scale: float | None = None,
         ignore_codes: set[str] | None = None,
         max_workers: int | None = None,
+        link_context: LinkContext | None = None,
     ) -> RenderedDashboard:
         return _dashboards.render_dashboard(
             path=path,
@@ -305,4 +319,5 @@ class Project:
             ignore_codes=ignore_codes,
             max_workers=max_workers,
             warnings_ignore=self.warnings_ignore,
+            link_context=link_context,
         )

dataface/agent_api/schema_hints.py

@@ -0,0 +1,49 @@
+"""Stateless view of compile-time schema constants for authoring agents."""
+
+from __future__ import annotations
+
+import typing
+
+from pydantic import BaseModel
+
+from dataface.core.compile.config import list_built_in_themes
+from dataface.core.compile.models.chart.authored import (
+    _INTERNAL_CHART_TYPES,
+    CHART_TYPE_DISPLAY,
+    ChartType,
+)
+from dataface.core.compile.models.variable.authored import VariableInputType
+
+
+class ChartTypeDisplay(BaseModel):
+    label: str
+    icon: str
+
+
+class SchemaHints(BaseModel):
+    chart_types: list[str]
+    input_types: list[str]
+    theme_names: list[str]
+    chart_type_display: dict[str, ChartTypeDisplay]
+
+
+def schema_hints() -> SchemaHints:
+    """Return compile-time schema constants for Dataface authoring agents.
+
+    Takes no arguments and reads no process state. Two consecutive calls
+    return equal results.
+    """
+    public_chart_types = [t for t in ChartType if t not in _INTERNAL_CHART_TYPES]
+    return SchemaHints(
+        chart_types=[t.value for t in public_chart_types],
+        input_types=list(typing.get_args(VariableInputType)),
+        theme_names=list_built_in_themes(),
+        chart_type_display={
+            t.value: ChartTypeDisplay(
+                label=CHART_TYPE_DISPLAY[t]["label"],
+                icon=CHART_TYPE_DISPLAY[t]["icon"],
+            )
+            for t in public_chart_types
+            if t in CHART_TYPE_DISPLAY
+        },
+    )

dataface/agent_api/validate.py

@@ -6,6 +6,7 @@ No warehouse connection, no query execution.
 from __future__ import annotations
 
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, Field
 
@@ -18,6 +19,9 @@ from dataface.core.compile.errors import DatafaceError
 from dataface.core.errors import DF_UNKNOWN_INTERNAL, StructuredError
 from dataface.core.render.warnings.base import RenderWarning
 
+if TYPE_CHECKING:
+    from dataface.agent_api.project import Project
+
 
 class ValidateDashboardArgs(BaseModel):
     """Validate a face YAML file without executing queries.
@@ -178,3 +182,47 @@ def validate(path: Path, *, project_dir: Path) -> ValidateResult:
         errors=errors,
         warnings=list(result.warnings),
     )
+
+
+def annotate_with_entity_lint(
+    results: list[ValidateResult],
+    *,
+    project: Project,
+) -> list[ValidateResult]:
+    """Augment validate results with entity alias typo lint.
+
+    For each result that compiled successfully, reads its aliases and checks
+    any /entity/ prefixed ones against the configured source names (config only,
+    no DB connection). Appends StructuredErrors to results in place and updates
+    success=False when errors are found.
+    """
+    from dataface.agent_api.entity_paths import entity_alias_errors_for_file
+
+    source_names = project._source_names()
+
+    annotated: list[ValidateResult] = []
+    for result in results:
+        if not result.path.exists() or not result.path.is_file():
+            annotated.append(result)
+            continue
+        alias_msgs = entity_alias_errors_for_file(
+            result.path, source_names=source_names
+        )
+        if not alias_msgs:
+            annotated.append(result)
+            continue
+        new_errors = list(result.errors) + [
+            DatafaceError.from_code(DF_UNKNOWN_INTERNAL, message=msg).to_structured(
+                file=str(result.path)
+            )
+            for msg in alias_msgs
+        ]
+        annotated.append(
+            ValidateResult(
+                success=False,
+                path=result.path,
+                errors=new_errors,
+                warnings=result.warnings,
+            )
+        )
+    return annotated

dataface/agent_api/validate_query.py

@@ -1,84 +1,62 @@
-"""validate_query verb — static SQL lint without warehouse access."""
+"""validate_query verb — stateless SQL lint, returns typed QueryDiagnostic list."""
 
 from __future__ import annotations
 
-import importlib.util
-from typing import Any
-
-from pydantic import BaseModel, Field
+from typing import Literal, overload
 
 from dataface.core.inspect.query_validator import (
-    RelationshipContext,
+    QueryDiagnostic,
     validate_query as _core_validate,
 )
 
-_SUPER_SCHEMA_AVAILABLE = importlib.util.find_spec("dataface_super_schema") is not None
-
+__all__ = ["QueryDiagnostic", "validate_query"]
 
-def _load_relationship_context() -> RelationshipContext | None:
-    """Load relationship context from the private package when available."""
-    if not _SUPER_SCHEMA_AVAILABLE:
-        return None
-    from dataface_super_schema.inspect.relationship_context import (  # noqa: PLC0415
-        load_relationship_context,
-    )
 
-    return load_relationship_context()
+@overload
+def validate_query(
+    sql: str,
+    *,
+    dialect: str | None = ...,
+    suppress: set[str] | None = ...,
+    return_suppressed: Literal[False] = ...,
+) -> list[QueryDiagnostic]: ...
 
 
-class ValidateQueryResult(BaseModel):
-    has_errors: bool = Field(
-        False,
-        description="True when any active diagnostic has severity == 'error'.",
-    )
-    diagnostics: list[dict[str, Any]] = Field(
-        default_factory=list,
-        description="Active diagnostic messages (non-suppressed).",
-    )
-    suppressed: list[dict[str, Any]] | None = Field(
-        None,
-        description="Suppressed diagnostics (only present when return_suppressed=True).",
-    )
+@overload
+def validate_query(
+    sql: str,
+    *,
+    dialect: str | None = ...,
+    suppress: set[str] | None = ...,
+    return_suppressed: Literal[True],
+) -> tuple[list[QueryDiagnostic], list[QueryDiagnostic]]: ...
 
 
 def validate_query(
     sql: str,
     *,
     dialect: str | None = None,
+    suppress: set[str] | None = None,
     return_suppressed: bool = False,
-    relationship_context: RelationshipContext | None = None,
-) -> ValidateQueryResult:
-    """Run static SQL validation and return a typed result.
-
-    Loads relationship context from the inspection cache automatically (same
-    as the CLI command). Pass relationship_context explicitly to override.
+) -> list[QueryDiagnostic] | tuple[list[QueryDiagnostic], list[QueryDiagnostic]]:
+    """Run static SQL validation and return typed diagnostics.
+
+    Stateless — requires no project, adapter, or warehouse connection.
+
+    Args:
+        sql: SQL query string to validate.
+        dialect: Optional SQLGlot dialect name (e.g. "duckdb", "bigquery").
+        suppress: Optional set of diagnostic codes to suppress from the active list.
+        return_suppressed: If True, return (active, suppressed) tuple instead of
+            just the active list. Used by CLI --show-suppressed.
+
+    Returns:
+        list[QueryDiagnostic] — active diagnostics (default).
+        tuple[list[QueryDiagnostic], list[QueryDiagnostic]] — (active, suppressed)
+            when return_suppressed=True.
     """
-    if relationship_context is None:
-        relationship_context = _load_relationship_context()
-
     if return_suppressed:
-        diags, suppressed = _core_validate(
-            sql,
-            dialect=dialect,
-            relationship_context=relationship_context,
-            return_suppressed=True,
+        return _core_validate(
+            sql, dialect=dialect, suppress=suppress, return_suppressed=True
         )
-        suppressed_dicts: list[dict[str, Any]] | None = [
-            d.to_dict() for d in suppressed
-        ]
-    else:
-        diags = _core_validate(
-            sql,
-            dialect=dialect,
-            relationship_context=relationship_context,
-        )
-        suppressed_dicts = None
-
-    diag_dicts = [d.to_dict() for d in diags]
-    has_errors = any(d.get("severity") == "error" for d in diag_dicts)
-
-    return ValidateQueryResult(
-        has_errors=has_errors,
-        diagnostics=diag_dicts,
-        suppressed=suppressed_dicts,
-    )
+    return _core_validate(sql, dialect=dialect, suppress=suppress)

dataface/ai/mcp/server.py

@@ -257,8 +257,8 @@ async def run_server() -> None:
         ) from e
 
     from dataface.agent_api import Project
+    from dataface.agent_api.cache import open_cache_from_env
     from dataface.core.execute.adapters import LOCAL_AUTHORING_REGISTRY_KWARGS
-    from dataface.core.execute.duckdb_cache import open_cache_from_env
     from dataface.core.serve.embedded import build_embedded_server
 
     http_server, resolved_http_port = build_embedded_server()