hatui-kit 0.1.0__py3-none-any.whl

hatui/runtime/defaults.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+from copy import deepcopy
+
+from hatui.providers import (
+    ClockProvider,
+    CommandOutputProvider,
+    ComposeProvider,
+    ConstantProvider,
+    DemoLogsProvider,
+    EnvProvider,
+    EventStreamProvider,
+    FileProvider,
+    FrameProvider,
+    GridHistoryProvider,
+    HostInfoProvider,
+    HttpJsonProvider,
+    NormalizeStateProvider,
+    RandomProvider,
+    RecordsProvider,
+    RollingWindowProvider,
+    BucketProvider,
+    SystemStatsProvider,
+    TemplateProvider,
+    ThresholdProvider,
+    TransformProvider,
+    WaveformProvider,
+)
+from hatui.runtime.registries import ProviderRegistry, WidgetRegistry
+from hatui.widgets import (
+    AlertWidget,
+    AlertStackWidget,
+    BannerWidget,
+    BorderWidget,
+    BoxWidget,
+    CenterWidget,
+    ChartWidget,
+    CodeBlockWidget,
+    ColumnWidget,
+    DividerWidget,
+    DiffViewerWidget,
+    EventFeedWidget,
+    FlowWidget,
+    GaugeWidget,
+    HeatmapWidget,
+    HistogramWidget,
+    HexDumpWidget,
+    InspectorWidget,
+    KVInspectorWidget,
+    LabelWidget,
+    ListWidget,
+    LogWidget,
+    MenuWidget,
+    MetricGridWidget,
+    MiniChartWidget,
+    ModalHostWidget,
+    ModalWidget,
+    ParagraphWidget,
+    ProgressBarWidget,
+    RowWidget,
+    ScrollWidget,
+    SparklineWidget,
+    StatusMatrixWidget,
+    StatusStripWidget,
+    StatWidget,
+    SignalStripWidget,
+    TableWidget,
+    TabsWidget,
+    TextWidget,
+    TimelineWidget,
+    TreeWidget,
+)
+
+GENERIC_WIDGET_KEYS = {"focusable", "selectable", "focus_fg_color", "focus_bg_color", "keybindings"}
+
+
+def _clean(spec: dict, excluded: set[str]) -> dict:
+    return {key: deepcopy(value) for key, value in spec.items() if key not in excluded}
+
+
+def _build_single_child(spec: dict, loader, widget_cls):
+    kwargs = _clean(spec, {"type", "weight", "child", *GENERIC_WIDGET_KEYS})
+    child = loader.build_widget(spec["child"]) if "child" in spec else None
+    return widget_cls(child=child, **kwargs)
+
+
+def _build_center(spec: dict, loader):
+    kwargs = _clean(spec, {"type", "weight", "child", *GENERIC_WIDGET_KEYS})
+    child = loader.build_widget(spec["child"]) if "child" in spec else None
+    children = [child] if child is not None else []
+    return CenterWidget(children=children, **kwargs)
+
+
+def _build_row(spec: dict, loader):
+    children = []
+    for child_spec in spec.get("children", []):
+        child = loader.build_widget(child_spec)
+        children.append((child, child_spec.get("weight", 1)))
+    kwargs = _clean(spec, {"type", "weight", "children", *GENERIC_WIDGET_KEYS})
+    return RowWidget(children=children, **kwargs)
+
+
+def _build_column(spec: dict, loader):
+    children = []
+    for child_spec in spec.get("children", []):
+        child = loader.build_widget(child_spec)
+        children.append((child, child_spec.get("weight", 1)))
+    kwargs = _clean(spec, {"type", "weight", "children", *GENERIC_WIDGET_KEYS})
+    return ColumnWidget(children=children, **kwargs)
+
+
+def _build_tabs(spec: dict, loader):
+    tabs = []
+    for tab_spec in spec.get("tabs", []):
+        title = tab_spec["title"]
+        route = tab_spec.get("route", title.lower())
+        child_spec = tab_spec.get("child") or tab_spec.get("screen")
+        if child_spec is None:
+            raise ValueError("Tab spec requires 'child' or 'screen'")
+        tabs.append((title, loader.build_widget(child_spec), route))
+    kwargs = _clean(spec, {"type", "weight", "tabs", *GENERIC_WIDGET_KEYS})
+    return TabsWidget(tabs=tabs, **kwargs)
+
+
+def _build_modal_host(spec: dict, loader):
+    child_spec = spec.get("child") or spec.get("screen")
+    child = loader.build_widget(child_spec) if child_spec is not None else None
+    modals = []
+    for modal_spec in spec.get("modals", []):
+        route = modal_spec.get("route")
+        child_spec = modal_spec.get("child") or modal_spec.get("screen") or modal_spec.get("modal")
+        if not route or child_spec is None:
+            raise ValueError("Modal host entries require 'route' and 'child'/'screen'/'modal'")
+        modals.append((route, loader.build_widget(child_spec)))
+    kwargs = _clean(spec, {"type", "weight", "child", "screen", "modals", *GENERIC_WIDGET_KEYS})
+    return ModalHostWidget(child=child, modals=modals, **kwargs)
+
+
+def _build_plain(spec: dict, loader, widget_cls):
+    kwargs = _clean(spec, {"type", "weight", *GENERIC_WIDGET_KEYS})
+    return widget_cls(**kwargs)
+
+
+def create_widget_registry() -> WidgetRegistry:
+    registry = WidgetRegistry()
+    registry.register("row", _build_row, widget_cls=RowWidget, allowed_keys={"children"}, required_keys={"children"})
+    registry.register("column", _build_column, widget_cls=ColumnWidget, allowed_keys={"children"}, required_keys={"children"})
+    registry.register("tabs", _build_tabs, widget_cls=TabsWidget, allowed_keys={"tabs"}, required_keys={"tabs"})
+    registry.register("modal_host", _build_modal_host, widget_cls=ModalHostWidget, allowed_keys={"child", "screen", "modals"}, required_keys={"modals"})
+    registry.register("box", lambda spec, loader: _build_single_child(spec, loader, BoxWidget), widget_cls=BoxWidget, allowed_keys={"child"})
+    registry.register("border", lambda spec, loader: _build_single_child(spec, loader, BorderWidget), widget_cls=BorderWidget, allowed_keys={"child"})
+    registry.register("center", _build_center, widget_cls=CenterWidget, allowed_keys={"child"})
+    registry.register("scroll", lambda spec, loader: _build_single_child(spec, loader, ScrollWidget), widget_cls=ScrollWidget, allowed_keys={"child"})
+    registry.register("modal", lambda spec, loader: _build_single_child(spec, loader, ModalWidget), widget_cls=ModalWidget, allowed_keys={"child"})
+
+    registry.register("text", lambda spec, loader: _build_plain(spec, loader, TextWidget), widget_cls=TextWidget)
+    registry.register("label", lambda spec, loader: _build_plain(spec, loader, LabelWidget), widget_cls=LabelWidget)
+    registry.register("list", lambda spec, loader: _build_plain(spec, loader, ListWidget), widget_cls=ListWidget)
+    registry.register("tree", lambda spec, loader: _build_plain(spec, loader, TreeWidget), widget_cls=TreeWidget)
+    registry.register("menu", lambda spec, loader: _build_plain(spec, loader, MenuWidget), widget_cls=ListWidget)
+    registry.register("paragraph", lambda spec, loader: _build_plain(spec, loader, ParagraphWidget), widget_cls=ParagraphWidget)
+    registry.register("banner", lambda spec, loader: _build_plain(spec, loader, BannerWidget), widget_cls=BannerWidget)
+    registry.register("alert", lambda spec, loader: _build_plain(spec, loader, AlertWidget), widget_cls=AlertWidget)
+    registry.register("status_strip", lambda spec, loader: _build_plain(spec, loader, StatusStripWidget), widget_cls=StatusStripWidget)
+    registry.register("signal_strip", lambda spec, loader: _build_plain(spec, loader, SignalStripWidget), widget_cls=SignalStripWidget)
+    registry.register("status_matrix", lambda spec, loader: _build_plain(spec, loader, StatusMatrixWidget), widget_cls=StatusMatrixWidget)
+    registry.register("alert_stack", lambda spec, loader: _build_plain(spec, loader, AlertStackWidget), widget_cls=ListWidget, allowed_keys={"source_width"})
+    registry.register("kv_inspector", lambda spec, loader: _build_plain(spec, loader, KVInspectorWidget), widget_cls=KVInspectorWidget)
+
+    registry.register("stat", lambda spec, loader: _build_plain(spec, loader, StatWidget), widget_cls=StatWidget)
+    registry.register("progress_bar", lambda spec, loader: _build_plain(spec, loader, ProgressBarWidget), widget_cls=ProgressBarWidget)
+    registry.register("sparkline", lambda spec, loader: _build_plain(spec, loader, SparklineWidget), widget_cls=SparklineWidget)
+    registry.register("histogram", lambda spec, loader: _build_plain(spec, loader, HistogramWidget), widget_cls=HistogramWidget)
+    registry.register("mini_chart", lambda spec, loader: _build_plain(spec, loader, MiniChartWidget), widget_cls=MiniChartWidget)
+    registry.register("metric_grid", lambda spec, loader: _build_plain(spec, loader, MetricGridWidget), widget_cls=MetricGridWidget)
+    registry.register("line_chart", lambda spec, loader: _build_plain({**spec, "mode": "line"}, loader, ChartWidget), widget_cls=ChartWidget)
+    registry.register("area_chart", lambda spec, loader: _build_plain({**spec, "mode": "area"}, loader, ChartWidget), widget_cls=ChartWidget)
+    registry.register("bar_chart", lambda spec, loader: _build_plain({**spec, "mode": "bar"}, loader, ChartWidget), widget_cls=ChartWidget)
+    registry.register("gauge", lambda spec, loader: _build_plain(spec, loader, GaugeWidget), widget_cls=GaugeWidget)
+    registry.register("heatmap", lambda spec, loader: _build_plain(spec, loader, HeatmapWidget), widget_cls=HeatmapWidget)
+    registry.register("timeline", lambda spec, loader: _build_plain(spec, loader, TimelineWidget), widget_cls=TimelineWidget)
+    registry.register("event_feed", lambda spec, loader: _build_plain(spec, loader, EventFeedWidget), widget_cls=EventFeedWidget)
+    registry.register("inspector", lambda spec, loader: _build_plain(spec, loader, InspectorWidget), widget_cls=InspectorWidget)
+    registry.register("diff_viewer", lambda spec, loader: _build_plain(spec, loader, DiffViewerWidget), widget_cls=DiffViewerWidget)
+    registry.register("flow", lambda spec, loader: _build_plain(spec, loader, FlowWidget), widget_cls=FlowWidget)
+
+    registry.register("log", lambda spec, loader: _build_plain(spec, loader, LogWidget), widget_cls=LogWidget)
+    registry.register("table", lambda spec, loader: _build_plain(spec, loader, TableWidget), widget_cls=TableWidget)
+    registry.register("code_block", lambda spec, loader: _build_plain(spec, loader, CodeBlockWidget), widget_cls=CodeBlockWidget)
+    registry.register("hex_dump", lambda spec, loader: _build_plain(spec, loader, HexDumpWidget), widget_cls=HexDumpWidget)
+    registry.register("divider", lambda spec, loader: _build_plain(spec, loader, DividerWidget), widget_cls=DividerWidget)
+    return registry
+
+
+def create_provider_registry() -> ProviderRegistry:
+    registry = ProviderRegistry()
+    registry.register("constant", ConstantProvider)
+    registry.register("clock", ClockProvider)
+    registry.register("frame", FrameProvider)
+    registry.register("random", RandomProvider)
+    registry.register("waveform", WaveformProvider)
+    registry.register("demo_logs", DemoLogsProvider)
+    registry.register("env", EnvProvider)
+    registry.register("file", FileProvider)
+    registry.register("host_info", HostInfoProvider)
+    registry.register("system_stats", SystemStatsProvider)
+    registry.register("command_output", CommandOutputProvider)
+    registry.register("http_json", HttpJsonProvider)
+    registry.register("transform", TransformProvider)
+    registry.register("template", TemplateProvider)
+    registry.register("compose", ComposeProvider)
+    registry.register("records", RecordsProvider)
+    registry.register("rolling_window", RollingWindowProvider)
+    registry.register("threshold", ThresholdProvider)
+    registry.register("event_stream", EventStreamProvider)
+    registry.register("grid_history", GridHistoryProvider)
+    registry.register("normalize_state", NormalizeStateProvider)
+    registry.register("bucket", BucketProvider)
+    return registry

hatui/runtime/engine.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import shutil
+import time
+from dataclasses import dataclass
+
+from hatui.core.input_manager import InputManager
+from hatui.core.screen_buffer import ScreenBuffer
+from hatui.core.terminal_env import TerminalEnvironment
+from hatui.runtime.bindings import set_path
+
+
+@dataclass
+class FrameStats:
+    provider_ms: float = 0.0
+    widget_update_ms: float = 0.0
+    focus_sync_ms: float = 0.0
+    allocate_ms: float = 0.0
+    layout_ms: float = 0.0
+    paint_ms: float = 0.0
+    frame_ms: float = 0.0
+
+    def as_dict(self) -> dict[str, float]:
+        return {
+            "provider_ms": self.provider_ms,
+            "widget_update_ms": self.widget_update_ms,
+            "focus_sync_ms": self.focus_sync_ms,
+            "allocate_ms": self.allocate_ms,
+            "layout_ms": self.layout_ms,
+            "paint_ms": self.paint_ms,
+            "frame_ms": self.frame_ms,
+        }
+
+
+class AppEngine:
+    def __init__(self):
+        width, height = self.get_terminal_size()
+        self.screen_buffer = ScreenBuffer(width=width, height=height)
+        self.environment = TerminalEnvironment()
+        self.input_manager = InputManager()
+        self.stats = FrameStats()
+        self._last_frame_time = time.monotonic()
+        self._start_time = self._last_frame_time
+        self._providers_active = False
+
+    @staticmethod
+    def get_terminal_size() -> tuple[int, int]:
+        size = shutil.get_terminal_size(fallback=(100, 32))
+        return max(size.columns, 1), max(size.lines, 1)
+
+    @property
+    def elapsed_time(self) -> float:
+        return time.monotonic() - self._start_time
+
+    @property
+    def providers_active(self) -> bool:
+        return self._providers_active
+
+    def resize_to_terminal(self) -> None:
+        width, height = self.get_terminal_size()
+        if (width, height) != (self.screen_buffer.width, self.screen_buffer.height):
+            self.screen_buffer.resize(width, height)
+
+    def activate_providers(self, app) -> None:
+        if self._providers_active:
+            return
+        app.provider_manager.setup(app.root_widget.context)
+        self._providers_active = True
+
+    def deactivate_providers(self, app) -> None:
+        if not self._providers_active:
+            return
+        app.provider_manager.teardown(app.root_widget.context)
+        self._providers_active = False
+
+    def dispatch_input(self, app) -> None:
+        key_event = self.input_manager.poll_input(timeout=0.05)
+        if key_event is None:
+            return
+        key, modifiers = key_event
+        app.root_widget.context.last_key = key
+        app.root_widget.context.last_modifiers = list(modifiers)
+        app.root_widget.dispatch_key_event(key, modifiers, app.root_widget.context)
+
+    def render_frame(self, app, *, width: int | None = None, height: int | None = None, flush: bool = False):
+        frame_started = time.perf_counter()
+        if width is not None and height is not None and (width, height) != (self.screen_buffer.width, self.screen_buffer.height):
+            self.screen_buffer.resize(max(width, 1), max(height, 1))
+
+        self._update_runtime(app)
+
+        allocate_started = time.perf_counter()
+        app.root_widget.allocate(self.screen_buffer.width, self.screen_buffer.height)
+        self.stats.allocate_ms = round((time.perf_counter() - allocate_started) * 1000.0, 3)
+
+        layout_started = time.perf_counter()
+        app.root_widget.layout(0, 0, app.root_widget.context)
+        self.stats.layout_ms = round((time.perf_counter() - layout_started) * 1000.0, 3)
+
+        self.screen_buffer.clear()
+        paint_started = time.perf_counter()
+        app.root_widget.paint(self.screen_buffer, app.root_widget.context)
+        self.stats.paint_ms = round((time.perf_counter() - paint_started) * 1000.0, 3)
+        self.stats.frame_ms = round((time.perf_counter() - frame_started) * 1000.0, 3)
+
+        app.root_widget.publish_debug_snapshot(app.root_widget.context)
+        set_path(app.root_widget.context.data, "_debug.stats", app.debug_snapshot())
+
+        if flush:
+            self.screen_buffer.flush()
+        return self.screen_buffer
+
+    def _update_runtime(self, app) -> None:
+        now = time.monotonic()
+        context = app.root_widget.context
+        context.delta_time = now - self._last_frame_time
+        context.elapsed_time = now - self._start_time
+        context.frame += 1
+        context.terminal_width = self.screen_buffer.width
+        context.terminal_height = self.screen_buffer.height
+        context.widget_width = self.screen_buffer.width
+        context.widget_height = self.screen_buffer.height
+
+        provider_started = time.perf_counter()
+        app.provider_manager.update(context.delta_time, context)
+        self.stats.provider_ms = round((time.perf_counter() - provider_started) * 1000.0, 3)
+
+        widget_started = time.perf_counter()
+        app.root_widget.update(context.delta_time, context)
+        self.stats.widget_update_ms = round((time.perf_counter() - widget_started) * 1000.0, 3)
+
+        focus_started = time.perf_counter()
+        app.root_widget.sync_focus(context)
+        self.stats.focus_sync_ms = round((time.perf_counter() - focus_started) * 1000.0, 3)
+        self._last_frame_time = now

hatui/runtime/formatters.py

@@ -0,0 +1,65 @@
+from typing import Any, Callable
+
+
+def _format_percent(value: Any, precision: int = 0) -> str:
+    return f"{float(value) * 100:.{precision}f}%"
+
+
+def _format_fixed(value: Any, precision: int = 2) -> str:
+    return f"{float(value):.{precision}f}"
+
+
+def _format_upper(value: Any) -> str:
+    return str(value).upper()
+
+
+def _format_lower(value: Any) -> str:
+    return str(value).lower()
+
+
+def _format_join(value: Any, separator: str = ", ") -> str:
+    if not isinstance(value, list):
+        return str(value)
+    return separator.join(str(item) for item in value)
+
+
+def _format_bytes(value: Any) -> str:
+    size = float(value)
+    units = ["B", "KB", "MB", "GB", "TB"]
+    unit = units[0]
+    for unit in units:
+        if abs(size) < 1024 or unit == units[-1]:
+            break
+        size /= 1024
+    return f"{size:.1f} {unit}"
+
+
+FORMATTERS: dict[str, Callable[..., str]] = {
+    "str": lambda value, **_: str(value),
+    "upper": lambda value, **_: _format_upper(value),
+    "lower": lambda value, **_: _format_lower(value),
+    "percent": lambda value, precision=0, **_: _format_percent(value, precision=precision),
+    "fixed": lambda value, precision=2, **_: _format_fixed(value, precision=precision),
+    "join": lambda value, separator=", ", **_: _format_join(value, separator=separator),
+    "bytes": lambda value, **_: _format_bytes(value),
+}
+
+
+def apply_formatter(value: Any, spec: str | dict | None = None) -> Any:
+    if spec is None:
+        return value
+    if isinstance(spec, str):
+        formatter = FORMATTERS.get(spec)
+        return formatter(value) if formatter else value
+
+    formatter = FORMATTERS.get(spec.get("name", ""))
+    if formatter is None:
+        return value
+    kwargs = {key: item for key, item in spec.items() if key != "name"}
+    return formatter(value, **kwargs)
+
+
+def apply_template(value: Any, template: str | None = None) -> Any:
+    if template is None:
+        return value
+    return template.format(value=value)

hatui/runtime/loader.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from hatui.core.style import Theme, build_theme
+from hatui.runtime.registries import ProviderRegistry, WidgetRegistry
+from hatui.runtime.validation import SpecValidator
+
+
+class ScreenSpecLoader:
+    def __init__(self, widget_registry: WidgetRegistry, provider_registry: ProviderRegistry):
+        self.widget_registry = widget_registry
+        self.provider_registry = provider_registry
+        self.validator = SpecValidator(widget_registry, provider_registry)
+        self.last_loaded_files: list[Path] = []
+
+    def load_spec(self, spec_path: str | Path) -> dict[str, Any]:
+        path = Path(spec_path).resolve()
+        spec = self._load_yaml(path)
+        loaded_files = {path}
+        resolved = self._resolve_includes(spec, path.parent, chain=(path,), loaded_files=loaded_files)
+        if not isinstance(resolved, dict):
+            raise ValueError("Top-level spec must resolve to an object")
+        self.validator.raise_for_errors(resolved, spec_path=path)
+        self.last_loaded_files = sorted(loaded_files)
+        return resolved
+
+    def validate_spec(self, spec_path: str | Path) -> list:
+        path = Path(spec_path).resolve()
+        spec = self._load_yaml(path)
+        loaded_files = {path}
+        resolved = self._resolve_includes(spec, path.parent, chain=(path,), loaded_files=loaded_files)
+        self.last_loaded_files = sorted(loaded_files)
+        return self.validator.validate(resolved, spec_path=path)
+
+    def load_theme(self, spec: dict[str, Any]) -> Theme:
+        theme_spec = spec.get("theme", {})
+        return build_theme(theme_spec)
+
+    def load_state(self, spec: dict[str, Any]) -> dict[str, Any]:
+        state = spec.get("state", {})
+        if not isinstance(state, dict):
+            raise ValueError("Top-level 'state' must be an object")
+        return state
+
+    def load_router(self, spec: dict[str, Any]) -> dict[str, Any]:
+        router = spec.get("router", {})
+        if router is None:
+            return {}
+        if not isinstance(router, dict):
+            raise ValueError("Top-level 'router' must be an object")
+        return router
+
+    def load_dev(self, spec: dict[str, Any]) -> dict[str, Any]:
+        dev = spec.get("dev", {})
+        if dev is None:
+            return {}
+        if not isinstance(dev, dict):
+            raise ValueError("Top-level 'dev' must be an object")
+        return dev
+
+    def load_providers(self, spec: dict[str, Any]) -> list[Any]:
+        providers = []
+        for provider_spec in spec.get("providers", []):
+            provider_type = provider_spec.get("type")
+            if not provider_type:
+                raise ValueError("Provider spec missing 'type'")
+            providers.append(self.provider_registry.create(provider_type, provider_spec))
+        return providers
+
+    def load_screen(self, spec: dict[str, Any]):
+        screen_spec = spec.get("screen")
+        if not isinstance(screen_spec, dict):
+            raise ValueError("Spec missing top-level 'screen' object")
+        return self.build_widget(screen_spec)
+
+    def build_widget(self, spec: dict[str, Any]):
+        widget_type = spec.get("type")
+        if not widget_type:
+            raise ValueError("Widget spec missing 'type'")
+        widget = self.widget_registry.create(widget_type, spec, self)
+        widget.configure_interaction(spec)
+        weight = spec.get("weight")
+        if weight is not None:
+            widget.set_layout_weight(weight)
+        return widget
+
+    def _load_yaml(self, path: Path) -> Any:
+        with path.open("r", encoding="utf-8") as handle:
+            return yaml.safe_load(handle) or {}
+
+    def _resolve_includes(self, node: Any, base_dir: Path, *, chain: tuple[Path, ...], loaded_files: set[Path]) -> Any:
+        if isinstance(node, list):
+            resolved_items = []
+            for item in node:
+                resolved = self._resolve_includes(item, base_dir, chain=chain, loaded_files=loaded_files)
+                if isinstance(resolved, list):
+                    resolved_items.extend(resolved)
+                else:
+                    resolved_items.append(resolved)
+            return resolved_items
+
+        if not isinstance(node, dict):
+            return node
+
+        include_path = node.get("include")
+        if include_path is not None:
+            include_file = (base_dir / include_path).resolve()
+            if include_file in chain:
+                joined = " -> ".join(str(path) for path in (*chain, include_file))
+                raise ValueError(f"Circular include detected: {joined}")
+
+            loaded_files.add(include_file)
+            included = self._load_yaml(include_file)
+            included = self._resolve_includes(
+                included,
+                include_file.parent,
+                chain=(*chain, include_file),
+                loaded_files=loaded_files,
+            )
+
+            overrides = {key: value for key, value in node.items() if key != "include"}
+            if not overrides:
+                return deepcopy(included)
+            if not isinstance(included, dict):
+                raise ValueError(f"Include overrides require an object include: {include_file}")
+
+            merged = deepcopy(included)
+            for key, value in overrides.items():
+                merged[key] = self._resolve_includes(value, base_dir, chain=chain, loaded_files=loaded_files)
+            return merged
+
+        return {
+            key: self._resolve_includes(value, base_dir, chain=chain, loaded_files=loaded_files)
+            for key, value in node.items()
+        }