fix(downloads): close routing gaps and map CivitAI ModelType.UNet to the checkpoint branch

Cross-checked both baseModel lists against CivitAI's official
baseModelRecords (packages/civitai-shared src/basemodel.constants.ts):

- CHECKPOINT_BASE_MODELS gains SD 2.0/2.1 768, SD 2.1 Unclip, SDXL 0.9 /
  1.0 LCM / Turbo / Distilled, Playground v2 and Stable Cascade
  (unCLIP-style but CheckpointLoader-loaded).
- DIFFUSION_MODEL_BASE_MODELS gains SVD XT, LTXV 2.5, Flux 3 Video,
  Wan Image 2.7, Wan Video 2.7 / 3.0, HiDream-O1, Boogu and the Ming
  Image Design families. API-only (Kling/Sora/Veo/Imagen...), 3D and
  audio baseModels are intentionally skipped.
- Pony V7 exclusion now backed by live-API evidence (model 1901521 is
  AuraFlow-architecture shipping .gguf variants).

CivitAI has no model-level diffusion ModelType: DiT models are uploaded
as "Checkpoint" or "UNet", with only uploader-chosen file types to tell
them apart. model.type "unet" previously fell through type derivation
and failed with 'not supported for download'; it now goes through the
checkpoint branch in both the download manager and the download routing
endpoint, so the standard chain (file type -> baseModel lists -> unknown
default) applies.

tests/routes/test_download_routing_handlers.py

@@ -109,6 +109,21 @@ async def test_unknown_base_model_honors_checkpoint_routing_setting():
     assert payload["root_kind"] == "checkpoint"
 
 
+@pytest.mark.asyncio
+async def test_unet_model_type_uses_checkpoint_branch():
+    """CivitAI ModelType.UNet has no branch of its own: it goes through the
+    checkpoint branch, where its UNet-typed files route to the unet roots."""
+    handler = DownloadRoutingHandler()
+    response = await handler.get_download_routing(
+        FakeRequest(
+            {"model_type": "unet", "base_model": "MiniMax H3", "file_types": ["UNet"]}
+        )
+    )
+    payload = json.loads(response.text)
+    assert payload["is_diffusion_model"] is True
+    assert payload["root_kind"] == "unet"
+
+
 @pytest.mark.asyncio
 async def test_lora_is_never_diffusion():
     handler = DownloadRoutingHandler()

tests/services/test_download_manager_basic.py

@@ -2200,6 +2200,54 @@ async def test_download_uses_raw_file_name_from_mini_endpoint(
     ]
 
 
+@pytest.mark.asyncio
+async def test_unet_model_type_download_lands_in_unet_roots(
+    monkeypatch, scanners, metadata_provider, tmp_path
+):
+    """CivitAI ModelType.UNet goes through the checkpoint branch: its
+    UNet-typed files route to the unet roots like any diffusion model."""
+    manager = DownloadManager()
+    unet_root = tmp_path / "unet"
+    get_settings_manager().settings["default_unet_root"] = str(unet_root)
+    metadata_provider.payload = {
+        "id": 42,
+        "model": {"type": "UNet", "tags": ["fantasy"]},
+        "baseModel": "MiniMax H3",
+        "creator": {"username": "Author"},
+        "files": [
+            {
+                "id": 1001,
+                "type": "UNet",
+                "primary": True,
+                "name": "minimax_h3.safetensors",
+                "downloadUrl": "https://example.invalid/file.safetensors",
+            }
+        ],
+    }
+
+    captured = {}
+
+    async def fake_execute_download(self, **kwargs):
+        captured["file_path"] = kwargs["metadata"].file_path
+        return {"success": True}
+
+    monkeypatch.setattr(
+        DownloadManager, "_execute_download", fake_execute_download, raising=False
+    )
+
+    result = await manager.download_from_civitai(
+        model_version_id=42,
+        save_dir=str(tmp_path),
+        use_default_paths=True,
+        progress_callback=None,
+        source=None,
+    )
+
+    assert result["success"] is True, result
+    assert captured["file_path"].startswith(str(unet_root))
+    assert captured["file_path"].endswith("minimax_h3.safetensors")
+
+
 @pytest.mark.asyncio
 async def test_download_falls_back_to_rest_name_when_mini_fails(
     monkeypatch, scanners, metadata_provider, tmp_path

tests/services/test_download_routing.py

@@ -20,6 +20,15 @@ def test_base_model_fallback_routes_to_unet():
     )
 
 
+@pytest.mark.parametrize("base_model", ["SVD XT", "Boogu", "Wan Video 3.0", "Flux 3 Video"])
+def test_new_diffusion_families_route_to_unet(base_model):
+    """DiT families from CivitAI's official baseModel list that plain
+    "Model"-typed files must not strand on the checkpoint roots."""
+    assert is_diffusion_model_download(
+        "checkpoint", file_types=["Model"], base_model=base_model
+    )
+
+
 def test_minimax_h3_routes_to_unet():
     """CivitAI model 2877206: type "Checkpoint", baseModel "MiniMax H3",
     all file entries typed "Model"."""
@@ -28,7 +37,19 @@ def test_minimax_h3_routes_to_unet():
     )
 
 
-@pytest.mark.parametrize("base_model", ["SDXL 1.0", "Illustrious", "SD 1.5", "SD 3.5 Large"])
+@pytest.mark.parametrize(
+    "base_model",
+    [
+        "SDXL 1.0",
+        "Illustrious",
+        "SD 1.5",
+        "SD 2.1 768",
+        "SD 3.5 Large",
+        "SDXL Turbo",
+        "Playground v2",
+        "Stable Cascade",
+    ],
+)
 def test_known_checkpoint_base_models_stay_on_checkpoint_roots(base_model):
     """CHECKPOINT_BASE_MODELS members never route to unet, even when the
     unknown-base-model default is diffusion."""