nds-mapviewer 2026.1.4.dev72__tar.gz → 2026.1.4.dev74__tar.gz

{nds_mapviewer-2026.1.4.dev72/src/nds_mapviewer.egg-info → nds_mapviewer-2026.1.4.dev74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.1.4.dev72
+Version: 2026.1.4.dev74
 Summary: CLI to run the NDS MapViewer Docker container for visualizing map data (NDS.Live, GeoJSON, and more)
 Author-email: NDS Association <support@nds-association.org>
 License: Proprietary

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74/src/nds_mapviewer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.1.4.dev72
+Version: 2026.1.4.dev74
 Summary: CLI to run the NDS MapViewer Docker container for visualizing map data (NDS.Live, GeoJSON, and more)
 Author-email: NDS Association <support@nds-association.org>
 License: Proprietary

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/src/ndslive/mapviewer/cli.py

@@ -129,6 +129,7 @@ def cmd_main(args: argparse.Namespace) -> int:
                     bind_address=bind_address,
                     pull_policy=pull_policy,
                     run_config=config,
+                    run_config_path=DEFAULT_CONFIG,
                     run_label="~/.nds/config.yaml",
                 )
                 app.run()
@@ -151,6 +152,7 @@ def cmd_main(args: argparse.Namespace) -> int:
                     bind_address=bind_address,
                     pull_policy=pull_policy,
                     run_config=config,
+                    run_config_path=LEGACY_CONFIG,
                     run_label="~/.nds/mapviewer.yaml",
                 )
                 app.run()
@@ -173,6 +175,7 @@ def cmd_main(args: argparse.Namespace) -> int:
     all_sources: list[dict] = []
     all_http_settings: list[dict] = []
     descriptions: list[str] = []
+    source_config_path: Path | None = None
 
     for source_arg in source_args:
         # Parse optional path:mapId syntax
@@ -208,6 +211,8 @@ def cmd_main(args: argparse.Namespace) -> int:
 
         elif resolved.source_type in ("local_config", "saved_config"):
             config = load_config(resolved.config_path)
+            if len(source_args) == 1:
+                source_config_path = resolved.config_path
             descriptions.append(
                 f"saved: {resolved.config_path.stem}"
                 if resolved.source_type == "saved_config"
@@ -236,6 +241,7 @@ def cmd_main(args: argparse.Namespace) -> int:
         bind_address=bind_address,
         pull_policy=pull_policy,
         run_config=merged,
+        run_config_path=source_config_path,
         run_label=source_desc,
     )
     app.run()

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/src/ndslive/mapviewer/config.py

@@ -19,6 +19,7 @@ NDS_DIR = Path.home() / ".nds"
 CONFIGS_DIR = NDS_DIR / "configs"
 DEFAULT_CONFIG = NDS_DIR / "config.yaml"
 LEGACY_CONFIG = NDS_DIR / "mapviewer.yaml"
+GENERATED_CONFIG_FILE = "mapviewer.yaml"
 
 # Patterns for detecting local paths in URIs
 FILESTORE_PATTERN = re.compile(r"^filestore:(.+)$")
@@ -243,6 +244,7 @@ def _find_common_parent(paths: list[Path]) -> dict[Path, Path]:
 def transform_config(
     config: dict[str, Any],
     base_dir: str | Path | None = None,
+    existing_volumes: list[VolumeMount] | None = None,
 ) -> TransformedConfig:
     """
     Transform a MapViewer config for Docker execution.
@@ -255,6 +257,46 @@ def transform_config(
     import copy
 
     transformed = copy.deepcopy(config)
+    existing_by_host: dict[tuple[Path, str], str] = {}
+    used_container_paths: set[str] = set()
+    for volume in existing_volumes or []:
+        host_path = volume.host_path.expanduser().resolve()
+        root = "/" + volume.container_path.strip("/").split("/", 1)[0]
+        existing_by_host[(host_path, root)] = volume.container_path
+        used_container_paths.add(volume.container_path)
+
+    assigned_by_host: dict[tuple[Path, str], str] = dict(existing_by_host)
+
+    def existing_container_path(host_path: Path, root: str) -> str | None:
+        container_path = assigned_by_host.get((host_path.expanduser().resolve(), root))
+        if container_path == root or (
+            container_path is not None
+            and container_path.startswith(f"{root}/")
+        ):
+            return container_path
+        return None
+
+    def next_container_path(root: str, preferred: str) -> str:
+        candidate = preferred
+        if candidate not in used_container_paths:
+            used_container_paths.add(candidate)
+            return candidate
+
+        index = 0
+        while True:
+            candidate = f"{root}/{index}"
+            if candidate not in used_container_paths:
+                used_container_paths.add(candidate)
+                return candidate
+            index += 1
+
+    def assign_volume(host_path: Path, root: str, preferred: str) -> str:
+        host_path = host_path.expanduser().resolve()
+        container_path = existing_container_path(host_path, root)
+        if container_path is None:
+            container_path = next_container_path(root, preferred)
+        assigned_by_host[(host_path, root)] = container_path
+        return container_path
     local_paths: list[Path] = []
     path_locations: list[tuple[str, int, str, str]] = []  # (section, index, field, original)
 
@@ -289,9 +331,10 @@ def transform_config(
     path_to_mount_parent = _find_common_parent(local_paths)
 
     # Deduplicate mount parents
-    unique_parents = list(set(path_to_mount_parent.values()))
+    unique_parents = sorted(set(path_to_mount_parent.values()), key=lambda p: p.as_posix())
     parent_to_container_path = {
-        parent: f"/data/{idx}" for idx, parent in enumerate(unique_parents)
+        parent: assign_volume(parent, "/data", f"/data/{idx}")
+        for idx, parent in enumerate(unique_parents)
     }
 
     # Create volume mounts
@@ -331,11 +374,18 @@ def transform_config(
         transformed[section][idx][field_name] = new_value
 
     asset_volumes: list[VolumeMount] = []
-
-    def add_asset_volume(host_path: Path, container_path: str) -> None:
-        asset_volumes.append(
-            VolumeMount(host_path=host_path, container_path=container_path)
-        )
+    asset_volume_keys: set[tuple[Path, str]] = set()
+
+    def add_asset_volume(host_path: Path, root: str, preferred: str) -> str:
+        resolved_host_path = host_path.expanduser().resolve()
+        container_path = assign_volume(resolved_host_path, root, preferred)
+        key = (resolved_host_path, container_path)
+        if key not in asset_volume_keys:
+            asset_volume_keys.add(key)
+            asset_volumes.append(
+                VolumeMount(host_path=resolved_host_path, container_path=container_path)
+            )
+        return container_path
 
     style_asset_index = 0
     background_asset_index = 0
@@ -352,17 +402,21 @@ def transform_config(
 
         if url.endswith("/*"):
             host_dir = _resolve_host_asset_path(url[:-2], base_dir)
-            container_dir = f"{CUSTOM_STYLES_ROOT}/{style_asset_index}"
+            container_dir = add_asset_volume(
+                host_dir,
+                CUSTOM_STYLES_ROOT,
+                f"{CUSTOM_STYLES_ROOT}/{style_asset_index}",
+            )
             style_asset_index += 1
-            add_asset_volume(host_dir, container_dir)
             return f"{container_dir}/*"
 
         host_file = _resolve_host_asset_path(url, base_dir)
-        container_path = (
-            f"{CUSTOM_STYLES_ROOT}/{style_asset_index}-{host_file.name}"
+        container_path = add_asset_volume(
+            host_file,
+            CUSTOM_STYLES_ROOT,
+            f"{CUSTOM_STYLES_ROOT}/{style_asset_index}-{host_file.name}",
         )
         style_asset_index += 1
-        add_asset_volume(host_file, container_path)
         return container_path
 
     def transform_background_template(template: str) -> str:
@@ -376,9 +430,12 @@ def transform_config(
             return template
 
         host_root, suffix = _split_background_template(template, base_dir)
-        container_dir = f"{CUSTOM_BACKGROUNDS_ROOT}/{background_asset_index}"
+        container_dir = add_asset_volume(
+            host_root,
+            CUSTOM_BACKGROUNDS_ROOT,
+            f"{CUSTOM_BACKGROUNDS_ROOT}/{background_asset_index}",
+        )
         background_asset_index += 1
-        add_asset_volume(host_root, container_dir)
         if not suffix:
             return container_dir
         return f"{container_dir}/{suffix}"
@@ -422,14 +479,19 @@ def write_config_to_temp(config: dict[str, Any]) -> Path:
     base_temp.mkdir(parents=True, exist_ok=True)
 
     temp_dir = Path(tempfile.mkdtemp(prefix="mapviewer-", dir=base_temp))
-    config_file = temp_dir / "mapviewer.yaml"
+    write_config_file(config, temp_dir / GENERATED_CONFIG_FILE)
+
+    return temp_dir
 
+
+def write_config_file(config: dict[str, Any], config_file: str | Path) -> None:
+    """Write a generated MapViewer config file with restrictive permissions."""
+    config_file = Path(config_file)
+    config_file.parent.mkdir(parents=True, exist_ok=True)
     fd = os.open(str(config_file), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
     with os.fdopen(fd, "w") as f:
         yaml.dump(config, f, default_flow_style=False, sort_keys=False)
 
-    return temp_dir
-
 
 def validate_paths(
     config: dict[str, Any],

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/src/ndslive/mapviewer/docker_client.py

@@ -673,6 +673,13 @@ class ContainerLogStream:
     def close(self, timeout: float = 3.0) -> None:
         if self._proc.poll() is not None:
             return
+        for pipe in (getattr(self._proc, "stdout", None), getattr(self._proc, "stderr", None)):
+            if pipe is None:
+                continue
+            try:
+                pipe.close()
+            except Exception:
+                pass
         self._proc.terminate()
         try:
             self._proc.wait(timeout=timeout)

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/src/ndslive/mapviewer/tui.py

@@ -1140,6 +1140,7 @@ class RunScreen(Screen):
     def __init__(
         self,
         config: dict[str, Any] | None = None,
+        config_path: str | Path | None = None,
         label: str = "",
         connect_name: str | None = None,
         saved_config: str | None = None,
@@ -1148,6 +1149,7 @@ class RunScreen(Screen):
     ) -> None:
         super().__init__()
         self._config = config
+        self._config_path = Path(config_path).expanduser().resolve() if config_path else None
         self._label = label
         self._connect_name = connect_name
         self._saved_config = saved_config
@@ -1158,6 +1160,7 @@ class RunScreen(Screen):
         self._log_buffer: deque[str] = deque(maxlen=500)
         self._alert_buffer: deque[str] = deque(maxlen=200)
         self._filter_index = 0
+        self._quitting = False
 
     def compose(self) -> ComposeResult:
         yield Header()
@@ -1186,7 +1189,7 @@ class RunScreen(Screen):
             self._connect_to_existing()
         elif self._saved_config:
             self._start_from_saved()
-        elif self._config:
+        elif self._config is not None or self._config_path is not None:
             self._start_container()
 
     # -- Log buffer & filtering --
@@ -1306,6 +1309,8 @@ class RunScreen(Screen):
         self.app.push_screen(HelpScreen())
 
     def action_quit_and_stop(self) -> None:
+        if self._quitting:
+            return
         # Confirm before tearing down a running MapViewer; an accidental
         # `q` should not throw away the container the user just started.
         if self._mv is not None and self._running:
@@ -1402,12 +1407,18 @@ class RunScreen(Screen):
 
     @work(thread=True)
     def _do_quit(self) -> None:
+        self._quitting = True
+        if self._mv:
+            try:
+                self._mv._close_log_stream()
+            except Exception:
+                pass
         if self._mv and self._running:
             try:
+                self._running = False
                 self._mv.stop()
             except Exception:
                 pass
-            self._running = False
         self.app.call_from_thread(self.app.exit)
 
     def action_open_docker(self) -> None:
@@ -1444,10 +1455,15 @@ class RunScreen(Screen):
 
         # Re-use _do_start which reads edition/version from TuiState
         config_path = None
-        if self._config and not self._is_demo:
-            config_dir = write_config_to_temp(self._config)
-            config_path = config_dir / "mapviewer.yaml"
-        self._do_start(config_path=config_path)
+        hot_reload = True
+        if not self._is_demo:
+            if self._config_path is not None:
+                config_path = self._config_path
+            elif self._config is not None:
+                config_dir = write_config_to_temp(self._config)
+                config_path = config_dir / "mapviewer.yaml"
+                hot_reload = False
+        self._do_start(config_path=config_path, hot_reload=hot_reload)
 
     # -- Switch saved config --
 
@@ -1491,6 +1507,7 @@ class RunScreen(Screen):
         self._saved_config = config_name
         self._label = f"saved: {config_name}"
         self._is_demo = False
+        self._config_path = config_path
         self._do_start(config_path=config_path)
 
     # -- Connect to existing container --
@@ -1537,6 +1554,7 @@ class RunScreen(Screen):
             )
             return
         self._label = f"saved: {self._saved_config}"
+        self._config_path = config_path
         self.app.call_from_thread(self._set_header, "starting")
         self._do_start(config_path=config_path)
 
@@ -1549,12 +1567,14 @@ class RunScreen(Screen):
 
         if self._is_demo:
             self._do_start(config_path=None)
+        elif self._config_path is not None:
+            self._do_start(config_path=self._config_path)
         else:
             config_dir = write_config_to_temp(self._config)
             config_file = config_dir / "mapviewer.yaml"
-            self._do_start(config_path=config_file)
+            self._do_start(config_path=config_file, hot_reload=False)
 
-    def _do_start(self, config_path: Path | None) -> None:
+    def _do_start(self, config_path: Path | None, hot_reload: bool = True) -> None:
         """Shared start logic — runs inside a worker thread."""
         state: TuiState = self.app.tui_state
         edition = state.edition
@@ -1636,6 +1656,7 @@ class RunScreen(Screen):
                 mv = MapViewer(
                     config=config_path, edition=edition, version=version,
                     port=state.port, bind_address=state.bind_address,
+                    hot_reload=hot_reload,
                 )
             self._mv = mv
             self.app.call_from_thread(
@@ -1731,6 +1752,8 @@ class RunScreen(Screen):
                 if stripped:
                     self.app.call_from_thread(self._log, stripped)
         except Exception:
+            if not getattr(self, "_running", False):
+                return
             self.app.call_from_thread(self._log, "Log stream ended")
 
 
@@ -2501,6 +2524,7 @@ class MapViewerApp(App):
         bind_address: str = "127.0.0.1",
         pull_policy: str = "prompt",
         run_config: dict[str, Any] | None = None,
+        run_config_path: str | Path | None = None,
         run_label: str = "",
         is_demo: bool = False,
     ) -> None:
@@ -2514,13 +2538,15 @@ class MapViewerApp(App):
             pull_policy=pull_policy,
         )
         self._run_config = run_config
+        self._run_config_path = Path(run_config_path).expanduser().resolve() if run_config_path else None
         self._run_label = run_label
         self._is_demo = is_demo
 
     def on_mount(self) -> None:
-        if self._run_config is not None:
+        if self._run_config is not None or self._run_config_path is not None:
             self.push_screen(RunScreen(
                 config=self._run_config,
+                config_path=self._run_config_path,
                 label=self._run_label,
                 exit_on_back=True,
                 is_demo=self._is_demo,

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/src/ndslive/mapviewer/viewer.py

@@ -10,10 +10,13 @@ from typing import Callable, Iterator
 from . import __default_image__ as _default_image
 from . import docker_client
 from .config import (
+    GENERATED_CONFIG_FILE,
     TransformedConfig,
+    VolumeMount,
     load_config,
     transform_config,
     validate_paths,
+    write_config_file,
     write_config_to_temp,
 )
 from .docker_client import ContainerInfo, ContainerLogStream
@@ -85,6 +88,11 @@ class MapViewer:
         instance._original_config = None
         instance._image_tag = info.image or None
         instance._log_stream = None
+        instance._hot_reload = False
+        instance._config_output_file = None
+        instance._config_sync_stop = None
+        instance._config_sync_thread = None
+        instance._config_reload_callback = None
         return instance
 
     def __init__(
@@ -96,6 +104,7 @@ class MapViewer:
         bind_address: str = "127.0.0.1",
         demo: bool = False,
         name: str = docker_client.CONTAINER_NAME,
+        hot_reload: bool = True,
     ):
         """
         Initialize a MapViewer instance.
@@ -157,6 +166,11 @@ class MapViewer:
         self._original_config: dict | None = None
         self._image_tag: str | None = None
         self._log_stream: ContainerLogStream | None = None
+        self._hot_reload = hot_reload
+        self._config_output_file: Path | None = None
+        self._config_sync_stop = None
+        self._config_sync_thread = None
+        self._config_reload_callback: Callable[[str], None] | None = None
 
     @property
     def url(self) -> str:
@@ -269,10 +283,12 @@ class MapViewer:
         if self._transformed is not None:
             # Write transformed config to temp directory
             self._temp_config_dir = write_config_to_temp(self._transformed.config)
+            self._config_output_file = self._temp_config_dir / GENERATED_CONFIG_FILE
             volumes = self._transformed.get_volume_args()
         else:
             # Demo mode: no config mount, container uses built-in config
             self._temp_config_dir = None
+            self._config_output_file = None
             volumes = {}
 
         # Ensure image is available
@@ -318,6 +334,8 @@ class MapViewer:
                         f"{hint}"
                     )
 
+        self._start_config_sync(log_callback)
+
     def stop(self, remove: bool = True) -> None:
         """
         Stop the MapViewer container.
@@ -325,6 +343,7 @@ class MapViewer:
         Args:
             remove: Also remove the container after stopping
         """
+        self._stop_config_sync()
         self._close_log_stream()
         try:
             docker_client.stop_container(self._name, remove=remove)
@@ -341,6 +360,136 @@ class MapViewer:
             pass
         self._log_stream = None
 
+    def _log_config_reload(self, message: str) -> None:
+        callback = getattr(self, "_config_reload_callback", None)
+        if callback is not None:
+            try:
+                callback(message)
+            except Exception:
+                pass
+
+    @staticmethod
+    def _file_stamp(path: Path) -> tuple[int, int] | None:
+        try:
+            stat = path.stat()
+        except OSError:
+            return None
+        return stat.st_mtime_ns, stat.st_size
+
+    @staticmethod
+    def _volume_key(volume: VolumeMount) -> tuple[Path, str]:
+        return volume.host_path.expanduser().resolve(), volume.container_path
+
+    def _unmounted_volumes(
+        self,
+        volumes: list[VolumeMount],
+        active_volumes: list[VolumeMount],
+    ) -> list[VolumeMount]:
+        active = {self._volume_key(volume) for volume in active_volumes}
+        return [
+            volume for volume in volumes
+            if self._volume_key(volume) not in active
+        ]
+
+    def _start_config_sync(
+        self,
+        log_callback: Callable[[str], None] | None,
+    ) -> None:
+        if (
+            not self._hot_reload
+            or self._demo
+            or self._config_path is None
+            or self._config_output_file is None
+            or self._transformed is None
+        ):
+            return
+
+        import threading
+
+        self._stop_config_sync()
+        self._config_reload_callback = log_callback
+        self._config_sync_stop = threading.Event()
+        self._config_sync_thread = threading.Thread(
+            target=self._config_sync_loop,
+            name=f"{self._name}-config-sync",
+            args=(
+                self._config_path,
+                self._config_output_file,
+                list(self._transformed.volumes),
+                self._config_sync_stop,
+            ),
+            daemon=True,
+        )
+        self._config_sync_thread.start()
+
+    def _stop_config_sync(self) -> None:
+        import threading
+
+        stop_event = getattr(self, "_config_sync_stop", None)
+        thread = getattr(self, "_config_sync_thread", None)
+        if stop_event is not None:
+            stop_event.set()
+        if (
+            thread is not None
+            and thread.is_alive()
+            and thread is not threading.current_thread()
+        ):
+            thread.join(timeout=2.0)
+        self._config_sync_stop = None
+        self._config_sync_thread = None
+        self._config_reload_callback = None
+
+    def _config_sync_loop(
+        self,
+        source_file: Path,
+        output_file: Path,
+        active_volumes: list[VolumeMount],
+        stop_event,
+    ) -> None:
+        last_stamp = self._file_stamp(source_file)
+        while not stop_event.wait(1.0):
+            current_stamp = self._file_stamp(source_file)
+            if current_stamp is None or current_stamp == last_stamp:
+                continue
+            last_stamp = current_stamp
+
+            try:
+                config = load_config(source_file)
+                errors = validate_paths(config, base_dir=source_file.parent)
+                if errors:
+                    self._log_config_reload(
+                        "Config change ignored; missing paths:\n  "
+                        + "\n  ".join(errors)
+                    )
+                    continue
+
+                transformed = transform_config(
+                    config,
+                    base_dir=source_file.parent,
+                    existing_volumes=active_volumes,
+                )
+                missing_mounts = self._unmounted_volumes(
+                    transformed.volumes,
+                    active_volumes,
+                )
+                if missing_mounts:
+                    mounts = ", ".join(
+                        f"{mount.host_path} -> {mount.container_path}"
+                        for mount in missing_mounts
+                    )
+                    self._log_config_reload(
+                        "Config change requires new Docker volume mounts; "
+                        f"restart MapViewer to apply: {mounts}"
+                    )
+                    continue
+
+                write_config_file(transformed.config, output_file)
+                self._original_config = config
+                self._transformed = transformed
+                self._log_config_reload("Reloaded mapviewer config")
+            except Exception as e:
+                self._log_config_reload(f"Config change ignored: {e}")
+
     def restart(self, pull: bool = False, wait: bool = True, timeout: int = 30) -> None:
         """
         Restart the MapViewer container.
@@ -465,6 +614,7 @@ class MapViewer:
 
     def _cleanup(self) -> None:
         """Clean up temporary files."""
+        self._stop_config_sync()
         temp_dir = getattr(self, "_temp_config_dir", None)
         if temp_dir and temp_dir.exists():
             try:
@@ -472,6 +622,7 @@ class MapViewer:
             except OSError:
                 pass
             self._temp_config_dir = None
+            self._config_output_file = None
 
     def __enter__(self) -> MapViewer:
         """Context manager entry."""

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/tests/test_cli.py

@@ -101,6 +101,7 @@ class TestCliLegacyMigration:
         def fake_run(self):
             app_kwargs.update({
                 "run_config": self._run_config,
+                "run_config_path": self._run_config_path,
                 "run_label": self._run_label,
             })
         monkeypatch.setattr(
@@ -128,6 +129,7 @@ class TestCliLegacyMigration:
         assert not new_config.exists()
         # Config was loaded and passed to the app
         assert app_kwargs["run_config"] == {"sources": []}
+        assert app_kwargs["run_config_path"] == legacy.resolve()
         assert "mapviewer.yaml" in app_kwargs["run_label"]
         # Deprecation warning was printed
         captured = capsys.readouterr()

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/tests/test_config.py

@@ -333,7 +333,7 @@ class TestTransformConfig:
             "/custom-backgrounds/0/{z}/{x}/{y}.png"
         )
         assert layers[1]["urlTemplate"][0] == (
-            "/custom-backgrounds/1/tile-{z}-{x}-{y}.png"
+            "/custom-backgrounds/0/tile-{z}-{x}-{y}.png"
         )
         assert layers[1]["urlTemplate"][1] == "https://example.com/{z}/{x}/{y}.png"
         assert layers[1]["urlTemplate"][2] == (
@@ -342,6 +342,62 @@ class TestTransformConfig:
         assert layers[2]["url"] == "service"
         assert any(_same_path(vol.host_path, imagery_dir) for vol in result.volumes)
 
+    def test_existing_volume_mapping_is_reused(self, temp_dir):
+        """Hot reloads keep container paths stable when entries are removed."""
+        first = temp_dir / "first"
+        second = temp_dir / "second"
+        first.mkdir()
+        second.mkdir()
+
+        initial = transform_config({
+            "sources": [
+                {"type": "ClassicFolder", "folder": str(first), "mapId": "A"},
+                {"type": "ClassicFolder", "folder": str(second), "mapId": "B"},
+            ]
+        })
+        initial_mounts = {
+            vol.host_path.resolve(): vol.container_path
+            for vol in initial.volumes
+        }
+
+        reloaded = transform_config(
+            {
+                "sources": [
+                    {
+                        "type": "ClassicFolder",
+                        "folder": str(second),
+                        "mapId": "B",
+                    }
+                ]
+            },
+            existing_volumes=initial.volumes,
+        )
+
+        assert reloaded.config["sources"][0]["folder"] == initial_mounts[second.resolve()]
+
+    def test_existing_asset_mapping_is_reused(self, temp_dir):
+        """Hot reloads keep custom asset URLs stable when entries are reordered."""
+        styles = temp_dir / "styles"
+        styles.mkdir()
+        first = styles / "first.yaml"
+        second = styles / "second.yaml"
+        first.write_text("name: First\n")
+        second.write_text("name: Second\n")
+
+        initial = transform_config(
+            {"erdblick": {"additionalStyles": ["styles/first.yaml", "styles/second.yaml"]}},
+            base_dir=temp_dir,
+        )
+        initial_styles = initial.config["erdblick"]["additionalStyles"]
+
+        reloaded = transform_config(
+            {"erdblick": {"additionalStyles": ["styles/second.yaml"]}},
+            base_dir=temp_dir,
+            existing_volumes=initial.volumes,
+        )
+
+        assert reloaded.config["erdblick"]["additionalStyles"][0] == initial_styles[1]
+
 
 class TestValidatePaths:
     """Tests for validate_paths()."""

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/tests/test_docker_client.py

@@ -392,11 +392,15 @@ class TestContainerLogStream:
     def test_close_terminates_and_waits(self, mocker):
         proc = mocker.MagicMock()
         proc.poll.return_value = None
+        proc.stdout = mocker.MagicMock()
+        proc.stderr = mocker.MagicMock()
         proc.wait.return_value = 0
         stream = dc.ContainerLogStream(proc)
 
         stream.close(timeout=1.5)
 
+        proc.stdout.close.assert_called_once()
+        proc.stderr.close.assert_called_once()
         proc.terminate.assert_called_once()
         proc.wait.assert_called_once_with(timeout=1.5)
         proc.kill.assert_not_called()

{nds_mapviewer-2026.1.4.dev72 → nds_mapviewer-2026.1.4.dev74}/tests/test_viewer.py

@@ -1,10 +1,13 @@
 """Tests for MapViewer class."""
 
 from pathlib import Path
+import time
 
 import pytest
+import yaml
 
 from ndslive.mapviewer import MapViewer, __default_image__
+from ndslive.mapviewer import docker_client
 from ndslive.mapviewer.exceptions import (
     ConfigError,
     ContainerNotFound,
@@ -147,6 +150,72 @@ class TestMapViewerConfigTransformation:
         assert data_dir.resolve() in host_paths
 
 
+class TestMapViewerConfigHotReload:
+    """Tests for syncing edited host configs into the mounted Docker config."""
+
+    def test_start_syncs_config_file_changes(self, temp_dir, mocker):
+        config_path = temp_dir / "config.yaml"
+        config_path.write_text(
+            "sources:\n"
+            "  - type: SmartLayerTileService\n"
+            "    uri: https://example.com/openapi.json\n"
+            "    mapId: Old\n"
+        )
+
+        mocker.patch.object(docker_client, "get_docker_client")
+        mocker.patch.object(docker_client, "ensure_logged_in")
+        mocker.patch.object(docker_client, "image_exists", return_value=True)
+        mocker.patch.object(
+            docker_client,
+            "get_image_tag",
+            return_value="registry/nds-mapviewer:test-amd64",
+        )
+        mocker.patch.object(
+            docker_client,
+            "run_container",
+            return_value=docker_client.ContainerInfo(
+                name="test-viewer",
+                id="abc",
+                status="running",
+                image="registry/nds-mapviewer:test-amd64",
+                host_port=8089,
+            ),
+        )
+        mocker.patch.object(
+            docker_client,
+            "wait_for_container_ready",
+            return_value=True,
+        )
+        mocker.patch.object(docker_client, "stop_container", return_value=True)
+
+        logs: list[str] = []
+        mv = MapViewer(config=config_path, name="test-viewer")
+        mv.start(pull=False, wait=True, log_callback=logs.append)
+
+        try:
+            output_file = mv._config_output_file
+            assert output_file is not None
+            config_path.write_text(
+                "sources:\n"
+                "  - type: SmartLayerTileService\n"
+                "    uri: https://example.com/openapi.json\n"
+                "    mapId: New\n"
+            )
+
+            deadline = time.time() + 4
+            while time.time() < deadline:
+                synced = yaml.safe_load(output_file.read_text())
+                if synced["sources"][0]["mapId"] == "New":
+                    break
+                time.sleep(0.1)
+            else:
+                pytest.fail("transformed config was not updated after host edit")
+
+            assert "Reloaded mapviewer config" in logs
+        finally:
+            mv.stop()
+
+
 class TestMapViewerDemoMode:
     """Tests for demo mode."""