fix(lora): accept diffusion_model.* prefix and use pipe.load_lora hotload

The sniff allowlist only had transformer./dit./model.transformer., so any
CivitAI / Kohya LoRA whose keys started with diffusion_model.* (Toontastic,
DarkGhibly, etc.) was rejected before reaching the pipeline.

The bigger issue: _apply_lora_impl was calling diffsynth.utils.lora.merge_lora
(loras: List[Dict], alpha) as if it were a state_dict-to-module fuser. It isn't
— it's an image2lora list-merger — so even the LoRAs we did accept never
actually patched the DiT. Swapped to pipe.load_lora(module=pipe.dit, ...)
which routes through GeneralLoRALoader.convert_state_dict (strips the
diffusion_model. prefix natively) and hotloads into AutoWrappedLinear,
reverted at exit via pipe.clear_lora().

Verified live with Toon5_E10 (Z-Image-Turbo) and DarkGhiblyZBase (Z-Image
Base) on local MPS.

lora.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-ZIMAGE_LORA_PREFIXES = ("transformer.", "dit.", "model.transformer.")
+ZIMAGE_LORA_PREFIXES = ("transformer.", "dit.", "model.transformer.", "diffusion_model.")
 
 
 class LoRAValidationError(ValueError):
@@ -97,27 +97,15 @@ def applied_lora(pipe: Any, path: Path | str | None, strength: float) -> Iterato
 
 
 def _apply_lora_impl(pipe: Any, path: Path | str, strength: float) -> None:
-    """Apply a LoRA to ``pipe.dit``. Imports DiffSynth lazily for testability."""
-    from diffsynth.utils.lora import merge_lora
+    """Apply a LoRA to ``pipe.dit`` using DiffSynth's ``load_lora`` (hotload mode).
 
-    merge_lora(pipe.dit, str(path), alpha=float(strength))
-
-
-def _revert_lora_impl(pipe: Any) -> None:
-    """Revert the most recent LoRA from ``pipe.dit``.
-
-    Tries DiffSynth's ``unmerge_lora`` first; falls back to re-fetching clean
-    weights from the model pool if unavailable.
+    ``GeneralLoRALoader.convert_state_dict`` normalises CivitAI-style
+    ``diffusion_model.*`` keys into the bare module-path keys DiffSynth's
+    AutoWrappedLinear modules consume, so we don't need to remap ourselves.
     """
-    try:
-        from diffsynth.utils.lora import unmerge_lora
+    pipe.load_lora(module=pipe.dit, lora_config=str(path), alpha=float(strength), verbose=0)
 
-        unmerge_lora(pipe.dit)
-        return
-    except ImportError:
-        pass
 
-    if hasattr(pipe, "model_pool"):
-        variant = getattr(pipe.dit, "_zis_variant", None)
-        if variant:
-            pipe.dit = pipe.model_pool.fetch_model("z_image_dit", variant=variant)
+def _revert_lora_impl(pipe: Any) -> None:
+    """Clear the hotloaded LoRA so the cached transformer is left clean."""
+    pipe.clear_lora(verbose=0)

tests/test_lora.py

@@ -37,6 +37,21 @@ def test_sniff_rejects_non_safetensors(tmp_path):
     assert "safetensors" in str(exc.value).lower()
 
 
+def test_sniff_accepts_diffusion_model_prefix(tmp_path):
+    """CivitAI / Kohya LoRAs prefix keys with ``diffusion_model.`` — must be accepted."""
+    p = tmp_path / "civitai.safetensors"
+    _write_safetensors(
+        p,
+        {
+            "diffusion_model.layers.0.adaLN_modulation.0.lora_A.weight": {"dtype": "BF16", "shape": [16, 3840]},
+            "diffusion_model.layers.0.adaLN_modulation.0.lora_B.weight": {"dtype": "BF16", "shape": [3840, 16]},
+        },
+    )
+    info = lora.sniff(p)
+    assert info.rank == 16
+    assert info.target == "transformer"
+
+
 def test_sniff_rejects_non_zimage_keys(tmp_path):
     p = tmp_path / "wrong.safetensors"
     _write_safetensors(