nds-mapviewer 2026.4.3.dev256__tar.gz → 2026.4.3.dev258__tar.gz

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/CHANGELOG.md

@@ -29,6 +29,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- A `.ndslive` filestore, SmartLayer folder or service URL holding object
+  data is now configured as `SmartLayerObjectService` instead of always
+  `SmartLayerTileService`, which the viewer rejected at startup; detection
+  reads the filestore tables, an `objects/` folder, or the service's OpenAPI
+  spec (falls back to tile when the spec cannot be fetched)
 - Clipboard copy in the Docker screen now uses the native OS clipboard
   (`clip.exe` / `pbcopy` / `wl-copy`/`xclip`/`xsel`) instead of relying on the
   OSC 52 terminal escape, which is unreliable on Windows; warns when a copy

{nds_mapviewer-2026.4.3.dev256/src/nds_mapviewer.egg-info → nds_mapviewer-2026.4.3.dev258}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.4.3.dev256
+Version: 2026.4.3.dev258
 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
@@ -49,7 +49,7 @@ Full documentation: **https://developer.nds.live/tools/mapviewer**
 - **Multiple data formats** — NDS.Live, GeoJSON, NDS.Classic (member edition)
 - **Live style editing** — modify map styles in real time with YAML-based rules
 - **Feature inspection** — click any map feature to explore its attributes and relations
-- **Local and remote data** — view SmartLayer folders, FileStore files, or remote services
+- **Local and remote data** — view SmartLayer folders, FileStore files, or remote services, as tile or object maps
 - **Guided setup** — interactive wizard for creating data source configs
 - **Config management** — save, switch, and delete configs from the RunScreen (`c`)
 
@@ -71,7 +71,7 @@ Either Docker or [Podman](https://podman.io) works as the container runtime —
 ```bash
 mapviewer                         # HomeScreen (or auto-loads ~/.nds/config.yaml)
 
-mapviewer /path/to/data.ndslive   # View a local FileStore
+mapviewer /path/to/data.ndslive   # View a local FileStore (tile or object map)
 mapviewer /path/to/folder         # View a local SmartLayer folder
 mapviewer /path/to/geojson/       # View a GeoJSON folder
 mapviewer https://host/openapi.json  # Connect to a remote service (unauthenticated)
@@ -87,10 +87,19 @@ mapviewer --demo --network host   # Run the container on the host network
 
 All commands accept `-e community|member` and `-i VERSION`.
 
+### Tile and object maps
+
+Local sources are detected as tile or object maps: a `.ndslive` filestore with an
+`objectTable`, or a SmartLayer folder with an `objects/` directory, becomes a
+`SmartLayerObjectService`; everything else a `SmartLayerTileService`. Object maps
+need MapViewer image 2026.4.2 or newer.
+
 ### Remote service URLs
 
 A source can be an http(s) service URL (e.g. `mapviewer https://my-host/openapi.json`),
-which is turned into a `SmartLayerTileService`. The bare-URL form configures **no
+which is turned into a `SmartLayerTileService`, or a `SmartLayerObjectService` when its
+OpenAPI spec offers `getObjectByReference`. If the spec cannot be fetched, the tile
+service is assumed. The bare-URL form configures **no
 authentication** — for protected services, proxy them through `ndslive-server` or
 declare the service in a `config.yaml` with an `http-settings` block (api-key, basic,
 bearer, OAuth2, proxy).

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/README.md

@@ -16,7 +16,7 @@ Full documentation: **https://developer.nds.live/tools/mapviewer**
 - **Multiple data formats** — NDS.Live, GeoJSON, NDS.Classic (member edition)
 - **Live style editing** — modify map styles in real time with YAML-based rules
 - **Feature inspection** — click any map feature to explore its attributes and relations
-- **Local and remote data** — view SmartLayer folders, FileStore files, or remote services
+- **Local and remote data** — view SmartLayer folders, FileStore files, or remote services, as tile or object maps
 - **Guided setup** — interactive wizard for creating data source configs
 - **Config management** — save, switch, and delete configs from the RunScreen (`c`)
 
@@ -38,7 +38,7 @@ Either Docker or [Podman](https://podman.io) works as the container runtime —
 ```bash
 mapviewer                         # HomeScreen (or auto-loads ~/.nds/config.yaml)
 
-mapviewer /path/to/data.ndslive   # View a local FileStore
+mapviewer /path/to/data.ndslive   # View a local FileStore (tile or object map)
 mapviewer /path/to/folder         # View a local SmartLayer folder
 mapviewer /path/to/geojson/       # View a GeoJSON folder
 mapviewer https://host/openapi.json  # Connect to a remote service (unauthenticated)
@@ -54,10 +54,19 @@ mapviewer --demo --network host   # Run the container on the host network
 
 All commands accept `-e community|member` and `-i VERSION`.
 
+### Tile and object maps
+
+Local sources are detected as tile or object maps: a `.ndslive` filestore with an
+`objectTable`, or a SmartLayer folder with an `objects/` directory, becomes a
+`SmartLayerObjectService`; everything else a `SmartLayerTileService`. Object maps
+need MapViewer image 2026.4.2 or newer.
+
 ### Remote service URLs
 
 A source can be an http(s) service URL (e.g. `mapviewer https://my-host/openapi.json`),
-which is turned into a `SmartLayerTileService`. The bare-URL form configures **no
+which is turned into a `SmartLayerTileService`, or a `SmartLayerObjectService` when its
+OpenAPI spec offers `getObjectByReference`. If the spec cannot be fetched, the tile
+service is assumed. The bare-URL form configures **no
 authentication** — for protected services, proxy them through `ndslive-server` or
 declare the service in a `config.yaml` with an `http-settings` block (api-key, basic,
 bearer, OAuth2, proxy).

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258/src/nds_mapviewer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nds-mapviewer
-Version: 2026.4.3.dev256
+Version: 2026.4.3.dev258
 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
@@ -49,7 +49,7 @@ Full documentation: **https://developer.nds.live/tools/mapviewer**
 - **Multiple data formats** — NDS.Live, GeoJSON, NDS.Classic (member edition)
 - **Live style editing** — modify map styles in real time with YAML-based rules
 - **Feature inspection** — click any map feature to explore its attributes and relations
-- **Local and remote data** — view SmartLayer folders, FileStore files, or remote services
+- **Local and remote data** — view SmartLayer folders, FileStore files, or remote services, as tile or object maps
 - **Guided setup** — interactive wizard for creating data source configs
 - **Config management** — save, switch, and delete configs from the RunScreen (`c`)
 
@@ -71,7 +71,7 @@ Either Docker or [Podman](https://podman.io) works as the container runtime —
 ```bash
 mapviewer                         # HomeScreen (or auto-loads ~/.nds/config.yaml)
 
-mapviewer /path/to/data.ndslive   # View a local FileStore
+mapviewer /path/to/data.ndslive   # View a local FileStore (tile or object map)
 mapviewer /path/to/folder         # View a local SmartLayer folder
 mapviewer /path/to/geojson/       # View a GeoJSON folder
 mapviewer https://host/openapi.json  # Connect to a remote service (unauthenticated)
@@ -87,10 +87,19 @@ mapviewer --demo --network host   # Run the container on the host network
 
 All commands accept `-e community|member` and `-i VERSION`.
 
+### Tile and object maps
+
+Local sources are detected as tile or object maps: a `.ndslive` filestore with an
+`objectTable`, or a SmartLayer folder with an `objects/` directory, becomes a
+`SmartLayerObjectService`; everything else a `SmartLayerTileService`. Object maps
+need MapViewer image 2026.4.2 or newer.
+
 ### Remote service URLs
 
 A source can be an http(s) service URL (e.g. `mapviewer https://my-host/openapi.json`),
-which is turned into a `SmartLayerTileService`. The bare-URL form configures **no
+which is turned into a `SmartLayerTileService`, or a `SmartLayerObjectService` when its
+OpenAPI spec offers `getObjectByReference`. If the spec cannot be fetched, the tile
+service is assumed. The bare-URL form configures **no
 authentication** — for protected services, proxy them through `ndslive-server` or
 declare the service in a `config.yaml` with an `http-settings` block (api-key, basic,
 bearer, OAuth2, proxy).

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/src/ndslive/mapviewer/cli.py

@@ -118,7 +118,9 @@ def cmd_main(args: argparse.Namespace) -> int:
         create_geojson_config,
         create_classic_config,
         create_service_config,
+        detect_service_type,
         get_demo_config,
+        SMART_TILE_SERVICE,
     )
     from .tui import MapViewerApp
 
@@ -220,13 +222,21 @@ def cmd_main(args: argparse.Namespace) -> int:
     source_config_path: Path | None = None
 
     for source_arg in source_args:
-        # Remote service: an http(s) URL is turned into a SmartLayerTileService
-        # source directly. Checked before the path:mapId split below because
-        # URLs contain colons. No auth is configured for the bare-URL form —
-        # use ndslive-server as a proxy or a config.yaml for authenticated
+        # Remote service: an http(s) URL is turned into a SmartLayer tile or
+        # object service source directly, depending on its OpenAPI spec.
+        # Checked before the path:mapId split below because URLs contain
+        # colons. No auth is configured for the bare-URL form — use
+        # ndslive-server as a proxy or a config.yaml for authenticated
         # services.
         if source_arg.startswith(("http://", "https://")):
-            config = create_service_config(source_arg)
+            service_type = detect_service_type(source_arg)
+            if service_type is None:
+                service_type = SMART_TILE_SERVICE
+                console.print(
+                    f"[yellow]Note:[/yellow] could not read the service spec of "
+                    f"{source_arg}, assuming {SMART_TILE_SERVICE}"
+                )
+            config = create_service_config(source_arg, service_type=service_type)
             descriptions.append(f"service: {source_arg}")
             all_sources.extend(config.get("sources", []))
             all_http_settings.extend(config.get("http-settings", []))
@@ -320,7 +330,7 @@ Examples:
   # Interactive HomeScreen
   mapviewer
 
-  # Quick start with local data
+  # Quick start with local data (tile or object maps are detected)
   mapviewer /path/to/data.ndslive
   mapviewer /path/to/smartlayer/folder
   mapviewer /path/to/geojson/folder

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/src/ndslive/mapviewer/config.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 import os
 import re
+import sqlite3
 import tempfile
+import urllib.request
 from dataclasses import dataclass, field
 from pathlib import Path, PurePath
 from typing import Any
@@ -29,6 +31,12 @@ CUSTOM_STYLES_ROOT = "/custom-styles"
 CUSTOM_BACKGROUNDS_ROOT = "/custom-backgrounds"
 COORDINATE_LEGAL_TERMS_ROOT = "/coordinates-legal-terms"
 
+# NDS.Live SmartLayer datasource types; the viewer rejects a source whose
+# type does not match the data's addressing mode.
+SMART_TILE_SERVICE = "SmartLayerTileService"
+SMART_OBJECT_SERVICE = "SmartLayerObjectService"
+SERVICE_SPEC_TIMEOUT_S = 5
+
 # Default config for demo mode
 DEFAULT_DEMO_CONFIG = {
     "http-settings": [
@@ -688,6 +696,61 @@ def detect_directory_type(path: Path) -> str:
     return "folder"
 
 
+# --- SmartLayer kind detection ---
+
+def detect_filestore_type(filestore_path: str | Path) -> str:
+    """Return the SmartLayer datasource type for a ``.ndslive`` filestore.
+
+    Object filestores carry an ``objectTable``, tile filestores a
+    ``tileTable``. Unreadable files fall back to the tile type and leave the
+    error reporting to the viewer.
+    """
+    uri = f"{Path(filestore_path).resolve().as_uri()}?mode=ro"
+    try:
+        conn = sqlite3.connect(uri, uri=True)
+        try:
+            row = conn.execute(
+                "SELECT 1 FROM sqlite_master WHERE type='table' AND name='objectTable'"
+            ).fetchone()
+        finally:
+            conn.close()
+    except sqlite3.Error:
+        return SMART_TILE_SERVICE
+    return SMART_OBJECT_SERVICE if row else SMART_TILE_SERVICE
+
+
+def detect_folder_type(folder_path: str | Path) -> str:
+    """Return the SmartLayer datasource type for an unpacked SmartLayer folder.
+
+    Object folders keep their records in an ``objects/`` subdirectory.
+    """
+    if (Path(folder_path) / "objects").is_dir():
+        return SMART_OBJECT_SERVICE
+    return SMART_TILE_SERVICE
+
+
+def _fetch_service_spec(url: str) -> str | None:
+    """Fetch a service's OpenAPI spec as text, or ``None`` if unreachable."""
+    try:
+        with urllib.request.urlopen(url, timeout=SERVICE_SPEC_TIMEOUT_S) as response:
+            return response.read().decode("utf-8", errors="replace")
+    except (OSError, ValueError):
+        return None
+
+
+def detect_service_type(url: str) -> str | None:
+    """Return the SmartLayer datasource type for a remote service URL.
+
+    Object services expose ``getObjectByReference`` in their OpenAPI spec.
+    Returns ``None`` when the spec cannot be fetched (e.g. it requires auth),
+    so the caller can choose a fallback.
+    """
+    spec = _fetch_service_spec(url)
+    if spec is None:
+        return None
+    return SMART_OBJECT_SERVICE if "getObjectByReference" in spec else SMART_TILE_SERVICE
+
+
 # --- Config generation functions ---
 
 def create_geojson_config(folder_path: str | Path) -> dict[str, Any]:
@@ -718,12 +781,12 @@ def create_classic_config(
 def create_folder_config(
     folder_path: str | Path, map_id: str | None = None,
 ) -> dict[str, Any]:
-    """Create a config dict for a SmartLayer folder."""
+    """Create a config dict for a SmartLayer folder (tile or object)."""
     folder_path = Path(folder_path)
     return {
         "sources": [
             {
-                "type": "SmartLayerTileService",
+                "type": detect_folder_type(folder_path),
                 "uri": f"folder:{folder_path}",
                 "mapId": map_id or folder_path.name,
             }
@@ -734,12 +797,12 @@ def create_folder_config(
 def create_filestore_config(
     filestore_path: str | Path, map_id: str | None = None,
 ) -> dict[str, Any]:
-    """Create a config dict for a FileStore."""
+    """Create a config dict for a FileStore (tile or object)."""
     filestore_path = Path(filestore_path)
     return {
         "sources": [
             {
-                "type": "SmartLayerTileService",
+                "type": detect_filestore_type(filestore_path),
                 "uri": f"filestore:{filestore_path}",
                 "mapId": map_id or filestore_path.stem,
             }
@@ -764,11 +827,13 @@ def create_service_config(
     proxy_port: int | None = None,
     proxy_user: str | None = None,
     proxy_password: str | None = None,
+    service_type: str = SMART_TILE_SERVICE,
 ) -> dict[str, Any]:
     """Create a config dict for connecting to a remote service.
 
     Args:
         url: Service URL (e.g., https://api.example.com/openapi.json)
+        service_type: SmartLayer datasource type, see ``detect_service_type``
         auth_method: One of "none", "apiKey", "queryParam", "basic", "bearer", "oauth2"
         api_key: API key value (for auth_method="apiKey")
         query_params: List of {"key": k, "value": v} dicts (for auth_method="queryParam")
@@ -794,7 +859,7 @@ def create_service_config(
     config: dict[str, Any] = {
         "sources": [
             {
-                "type": "SmartLayerTileService",
+                "type": service_type,
                 "uri": url,
                 "mapId": parsed.netloc.replace(".", "-"),
             }

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/src/ndslive/mapviewer/tui.py

@@ -33,6 +33,7 @@ from . import docker_client
 from .config import (
     CONFIGS_DIR,
     DEFAULT_CONFIG,
+    SMART_TILE_SERVICE,
     create_classic_config,
     create_filestore_config,
     create_folder_config,
@@ -40,6 +41,7 @@ from .config import (
     create_service_config,
     delete_config,
     detect_directory_type,
+    detect_service_type,
     get_demo_config,
     list_saved_configs,
     load_config,
@@ -712,6 +714,7 @@ class WizardScreen(Screen):
                 url=self._service_url,
                 **auth_kwargs,
                 **proxy_kwargs,
+                service_type=detect_service_type(self._service_url) or SMART_TILE_SERVICE,
             )
         elif self._source_type == "demo":
             self._config = get_demo_config()

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/tests/conftest.py

@@ -37,6 +37,30 @@ def edition():
     return DEFAULT_EDITION
 
 
+@pytest.fixture(autouse=True)
+def offline_service_spec(monkeypatch):
+    """Keep tests offline: service spec fetches fail unless a test stubs them."""
+    monkeypatch.setattr(
+        "ndslive.mapviewer.config._fetch_service_spec", lambda url: None,
+    )
+
+
+@pytest.fixture
+def make_filestore():
+    """Factory for minimal SQLite ``.ndslive`` filestores with given tables."""
+    import sqlite3
+
+    def make(path, *tables):
+        conn = sqlite3.connect(path)
+        with conn:
+            for table in tables:
+                conn.execute(f"CREATE TABLE {table} (id INTEGER)")
+        conn.close()
+        return path
+
+    return make
+
+
 @pytest.fixture
 def temp_dir():
     """Create a temporary directory for test files."""

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/tests/test_cli.py

@@ -177,6 +177,42 @@ class TestCliUrlSource:
             assert rc == 0
             assert cap["config"]["sources"][0]["uri"] == url
 
+    def test_object_service_url(self, monkeypatch):
+        monkeypatch.setattr(
+            "ndslive.mapviewer.config._fetch_service_spec",
+            lambda url: '{"paths": {"/getObjectByReference": {}}}',
+        )
+        rc, cap = self._run_cmd_main(monkeypatch, ["https://my-host/openapi.json"])
+        assert rc == 0
+        assert cap["config"]["sources"][0]["type"] == "SmartLayerObjectService"
+
+    def test_unreadable_spec_falls_back_to_tile_with_note(self, monkeypatch, capsys):
+        rc, cap = self._run_cmd_main(monkeypatch, ["https://my-host/openapi.json"])
+        assert rc == 0
+        assert cap["config"]["sources"][0]["type"] == "SmartLayerTileService"
+        assert "could not read the service spec" in capsys.readouterr().out
+
+
+class TestCliObjectSources:
+    """Tests for detecting SmartLayer object sources from local paths."""
+
+    def test_mixed_tile_and_object_sources(self, monkeypatch, tmp_path, make_filestore):
+        tiles = make_filestore(tmp_path / "tiles.ndslive", "metadataTable", "tileTable")
+        objects = make_filestore(tmp_path / "objects.ndslive", "metadataTable", "objectTable")
+        folder = tmp_path / "objfolder"
+        (folder / "objects").mkdir(parents=True)
+
+        rc, cap = TestCliUrlSource()._run_cmd_main(
+            monkeypatch, [str(tiles), str(objects), str(folder)],
+        )
+        assert rc == 0
+        types = {s["mapId"]: s["type"] for s in cap["config"]["sources"]}
+        assert types == {
+            "tiles": "SmartLayerTileService",
+            "objects": "SmartLayerObjectService",
+            "objfolder": "SmartLayerObjectService",
+        }
+
 
 class TestCliLegacyMigration:
     """Tests for legacy mapviewer.yaml migration hint."""

{nds_mapviewer-2026.4.3.dev256 → nds_mapviewer-2026.4.3.dev258}/tests/test_config.py

@@ -7,6 +7,8 @@ import yaml
 
 from ndslive.mapviewer.config import (
     CONFIGS_DIR,
+    SMART_OBJECT_SERVICE,
+    SMART_TILE_SERVICE,
     _extract_local_path,
     _is_localhost,
     _join_container_path,
@@ -19,6 +21,9 @@ from ndslive.mapviewer.config import (
     create_service_config,
     delete_config,
     detect_directory_type,
+    detect_filestore_type,
+    detect_folder_type,
+    detect_service_type,
     list_saved_configs,
     load_config,
     resolve_config_source,
@@ -798,16 +803,29 @@ class TestCreateClassicConfig:
 
 
 class TestCreateFolderConfig:
-    """Tests for create_folder_config() custom mapId."""
+    """Tests for create_folder_config()."""
 
     def test_custom_map_id(self, temp_dir):
         """Custom mapId overrides the default."""
         config = create_folder_config(temp_dir, map_id="CustomFolder")
         assert config["sources"][0]["mapId"] == "CustomFolder"
 
+    def test_tile_folder(self, temp_dir):
+        """A folder without objects/ is a tile service."""
+        (temp_dir / "tiles").mkdir()
+        config = create_folder_config(temp_dir)
+        assert config["sources"][0]["type"] == SMART_TILE_SERVICE
+
+    def test_object_folder(self, temp_dir):
+        """A folder with objects/ is an object service."""
+        (temp_dir / "objects").mkdir()
+        config = create_folder_config(temp_dir)
+        assert config["sources"][0]["type"] == SMART_OBJECT_SERVICE
+        assert config["sources"][0]["uri"] == f"folder:{temp_dir}"
+
 
 class TestCreateFilestoreConfig:
-    """Tests for create_filestore_config() custom mapId."""
+    """Tests for create_filestore_config()."""
 
     def test_custom_map_id(self, temp_dir):
         """Custom mapId overrides the default."""
@@ -816,6 +834,66 @@ class TestCreateFilestoreConfig:
         config = create_filestore_config(store, map_id="CustomStore")
         assert config["sources"][0]["mapId"] == "CustomStore"
 
+    def test_tile_filestore(self, temp_dir, make_filestore):
+        """A filestore with a tileTable is a tile service."""
+        store = make_filestore(temp_dir / "tiles.ndslive", "metadataTable", "tileTable")
+        config = create_filestore_config(store)
+        assert config["sources"][0]["type"] == SMART_TILE_SERVICE
+
+    def test_object_filestore(self, temp_dir, make_filestore):
+        """A filestore with an objectTable is an object service."""
+        store = make_filestore(
+            temp_dir / "objects.ndslive",
+            "metadataTable", "objectTable", "tileObjectAssociationTable",
+        )
+        config = create_filestore_config(store)
+        source = config["sources"][0]
+        assert source["type"] == SMART_OBJECT_SERVICE
+        assert source["uri"] == f"filestore:{store}"
+        assert source["mapId"] == "objects"
+
+
+class TestDetectSmartLayerType:
+    """Tests for the SmartLayer tile/object detection helpers."""
+
+    def test_unreadable_filestore_falls_back_to_tile(self, temp_dir):
+        """A file that is not SQLite is left to the viewer to reject."""
+        store = temp_dir / "broken.ndslive"
+        store.write_text("not a database")
+        assert detect_filestore_type(store) == SMART_TILE_SERVICE
+
+    def test_filestore_detection_leaves_file_unchanged(self, temp_dir, make_filestore):
+        """Detection opens the filestore read-only."""
+        store = make_filestore(temp_dir / "objects.ndslive", "objectTable")
+        before = store.read_bytes()
+        assert detect_filestore_type(store) == SMART_OBJECT_SERVICE
+        assert store.read_bytes() == before
+
+    def test_folder_with_objects_file_is_tile(self, temp_dir):
+        """Only an objects/ directory marks an object folder."""
+        (temp_dir / "objects").touch()
+        assert detect_folder_type(temp_dir) == SMART_TILE_SERVICE
+
+    def test_object_service_spec(self, monkeypatch):
+        """A spec with getObjectByReference is an object service."""
+        monkeypatch.setattr(
+            "ndslive.mapviewer.config._fetch_service_spec",
+            lambda url: '{"paths": {"/getObjectByReference": {}}}',
+        )
+        assert detect_service_type("https://h/openapi.json") == SMART_OBJECT_SERVICE
+
+    def test_tile_service_spec(self, monkeypatch):
+        """A spec without object methods is a tile service."""
+        monkeypatch.setattr(
+            "ndslive.mapviewer.config._fetch_service_spec",
+            lambda url: '{"paths": {"/getSmartLayerTile": {}}}',
+        )
+        assert detect_service_type("https://h/openapi.json") == SMART_TILE_SERVICE
+
+    def test_unreachable_spec_is_unknown(self):
+        """An unreachable spec leaves the choice to the caller."""
+        assert detect_service_type("https://h/openapi.json") is None
+
 
 class TestResolveConfigSourceDetection:
     """Tests for resolve_config_source() directory type detection."""
@@ -852,6 +930,13 @@ class TestCreateServiceConfig:
         assert config["sources"][0]["uri"] == "https://api.example.com/openapi.json"
         assert "http-settings" not in config
 
+    def test_object_service_type(self):
+        """The given service type is written to the source."""
+        config = create_service_config(
+            "https://api.example.com/openapi.json", service_type=SMART_OBJECT_SERVICE,
+        )
+        assert config["sources"][0]["type"] == SMART_OBJECT_SERVICE
+
     def test_api_key_auth(self):
         """API key auth populates http-settings with api-key."""
         config = create_service_config(