chore: format code

src/model/integrations/anima.cpp

@@ -9,13 +9,13 @@ static bool build_anima(const sd::model_builders::Context& ctx, const TokenizerC
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<AnimaConditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                            tensor_storage_map,
-                                                            weight_manager,
-                                                            tokenizers);
+                                                                        tensor_storage_map,
+                                                                        weight_manager,
+                                                                        tokenizers);
     result.diffusion               = std::make_shared<Anima::AnimaRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                            tensor_storage_map,
-                                                            "model.diffusion_model",
-                                                            weight_manager);
+                                                                          tensor_storage_map,
+                                                                          "model.diffusion_model",
+                                                                          weight_manager);
     return true;
 }
 

src/model/integrations/boogu_image.cpp

@@ -9,17 +9,17 @@ static bool build_boogu_image(const sd::model_builders::Context& ctx, const Toke
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       true,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   true,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Boogu::BooguImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                 tensor_storage_map,
-                                                                 "model.diffusion_model",
-                                                                 version,
-                                                                 weight_manager);
+                                                                               tensor_storage_map,
+                                                                               "model.diffusion_model",
+                                                                               version,
+                                                                               weight_manager);
     return true;
 }
 

src/model/integrations/ernie_image.cpp

@@ -9,16 +9,16 @@ static bool build_ernie_image(const sd::model_builders::Context& ctx, const Toke
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<ErnieImage::ErnieImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                      tensor_storage_map,
-                                                                      "model.diffusion_model",
-                                                                      weight_manager);
+                                                                                    tensor_storage_map,
+                                                                                    "model.diffusion_model",
+                                                                                    weight_manager);
     return true;
 }
 

src/model/integrations/fibo2.cpp

@@ -10,9 +10,9 @@ static bool build_fibo2(const sd::model_builders::Context& ctx, const TokenizerC
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<Fibo2Conditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                            tensor_storage_map, weight_manager, tokenizers);
+                                                                        tensor_storage_map, weight_manager, tokenizers);
     result.diffusion               = std::make_shared<Fibo2::Fibo2Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                            tensor_storage_map, "model.diffusion_model", weight_manager);
+                                                                          tensor_storage_map, "model.diffusion_model", weight_manager);
     return true;
 }
 

src/model/integrations/flux2.cpp

@@ -11,18 +11,18 @@ static bool build_flux2(const sd::model_builders::Context& ctx, const TokenizerC
     const auto& weight_manager     = ctx.weight_manager;
     bool is_chroma                 = false;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Flux::FluxRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                          tensor_storage_map,
-                                                          "model.diffusion_model",
-                                                          version,
-                                                          weight_manager,
-                                                          sd_ctx_params->model_args);
+                                                                        tensor_storage_map,
+                                                                        "model.diffusion_model",
+                                                                        version,
+                                                                        weight_manager,
+                                                                        sd_ctx_params->model_args);
     return true;
 }
 

src/model/integrations/flux3.cpp

@@ -9,9 +9,9 @@ static bool build_flux3(const sd::model_builders::Context& ctx, const TokenizerC
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map, version, "", false, weight_manager, tokenizers);
+                                                                   tensor_storage_map, version, "", false, weight_manager, tokenizers);
     result.diffusion               = std::make_shared<Flux3::Flux3Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                            tensor_storage_map, "model.diffusion_model", weight_manager);
+                                                                          tensor_storage_map, "model.diffusion_model", weight_manager);
     return true;
 }
 

src/model/integrations/hidream_o1.cpp

@@ -9,13 +9,13 @@ static bool build_hidream_o1(const sd::model_builders::Context& ctx, const Token
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<HiDreamO1::HiDreamO1Conditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                                           tensor_storage_map,
-                                                                           weight_manager,
-                                                                           tokenizers);
+                                                                                       tensor_storage_map,
+                                                                                       weight_manager,
+                                                                                       tokenizers);
     result.diffusion               = std::make_shared<HiDreamO1::HiDreamO1Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                    tensor_storage_map,
-                                                                    "model",
-                                                                    weight_manager);
+                                                                                  tensor_storage_map,
+                                                                                  "model",
+                                                                                  weight_manager);
     return true;
 }
 

src/model/integrations/hunyuan_video.cpp

@@ -9,17 +9,17 @@ static bool build_hunyuan_video(const sd::model_builders::Context& ctx, const To
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Hunyuan::HunyuanVideoRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                     tensor_storage_map,
-                                                                     "model.diffusion_model",
-                                                                     version,
-                                                                     weight_manager);
+                                                                                   tensor_storage_map,
+                                                                                   "model.diffusion_model",
+                                                                                   version,
+                                                                                   weight_manager);
     return true;
 }
 

src/model/integrations/ideogram4.cpp

@@ -9,16 +9,16 @@ static bool build_ideogram4(const sd::model_builders::Context& ctx, const Tokeni
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Ideogram4::Ideogram4Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                    tensor_storage_map,
-                                                                    "model.diffusion_model",
-                                                                    weight_manager);
+                                                                                  tensor_storage_map,
+                                                                                  "model.diffusion_model",
+                                                                                  weight_manager);
     return true;
 }
 

src/model/integrations/iris.cpp

@@ -9,9 +9,9 @@ static bool build_iris(const sd::model_builders::Context& ctx, const TokenizerCo
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map, version, "", false, weight_manager, tokenizers);
+                                                                   tensor_storage_map, version, "", false, weight_manager, tokenizers);
     result.diffusion               = std::make_shared<Iris::IrisRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                          tensor_storage_map, "model.diffusion_model", weight_manager);
+                                                                        tensor_storage_map, "model.diffusion_model", weight_manager);
     return true;
 }
 

src/model/integrations/krea2.cpp

@@ -9,16 +9,16 @@ static bool build_krea2(const sd::model_builders::Context& ctx, const TokenizerC
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       true,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   true,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Krea2::Krea2Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                            tensor_storage_map,
-                                                            "model.diffusion_model",
-                                                            weight_manager);
+                                                                          tensor_storage_map,
+                                                                          "model.diffusion_model",
+                                                                          weight_manager);
     return true;
 }
 

src/model/integrations/lens.cpp

@@ -9,16 +9,16 @@ static bool build_lens(const sd::model_builders::Context& ctx, const TokenizerCo
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Lens::LensRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                          tensor_storage_map,
-                                                          "model.diffusion_model",
-                                                          weight_manager);
+                                                                        tensor_storage_map,
+                                                                        "model.diffusion_model",
+                                                                        weight_manager);
     return true;
 }
 

src/model/integrations/lingbot_video.cpp

@@ -23,10 +23,10 @@ static bool build_lingbot_video(const sd::model_builders::Context& ctx, const To
                                                        weight_manager,
                                                        tokenizers);
     result.diffusion   = std::make_shared<LingBotVideo::LingBotVideoRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                          tensor_storage_map,
-                                                                          "model.diffusion_model",
-                                                                          weight_manager,
-                                                                          sd_ctx_params->model_args);
+                                                                            tensor_storage_map,
+                                                                            "model.diffusion_model",
+                                                                            weight_manager,
+                                                                            sd_ctx_params->model_args);
     return true;
 }
 

src/model/integrations/llada_image.cpp

@@ -9,17 +9,17 @@ static bool build_llada_image(const sd::model_builders::Context& ctx, const Toke
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLaDAImageEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                              tensor_storage_map,
-                                                              "text_encoders.llm",
-                                                              "queryformer",
-                                                              "text_projection",
-                                                              "sigvq",
-                                                              weight_manager,
-                                                              tokenizers);
+                                                                          tensor_storage_map,
+                                                                          "text_encoders.llm",
+                                                                          "queryformer",
+                                                                          "text_projection",
+                                                                          "sigvq",
+                                                                          weight_manager,
+                                                                          tokenizers);
     result.diffusion               = std::make_shared<LLaDAImage::LLaDAImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                      tensor_storage_map,
-                                                                      "model.diffusion_model",
-                                                                      weight_manager);
+                                                                                    tensor_storage_map,
+                                                                                    "model.diffusion_model",
+                                                                                    weight_manager);
     return true;
 }
 

src/model/integrations/longcat.cpp

@@ -9,18 +9,18 @@ static bool build_longcat(const sd::model_builders::Context& ctx, const Tokenize
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       true,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   true,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Flux::FluxRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                          tensor_storage_map,
-                                                          "model.diffusion_model",
-                                                          version,
-                                                          weight_manager,
-                                                          sd_ctx_params->model_args);
+                                                                        tensor_storage_map,
+                                                                        "model.diffusion_model",
+                                                                        version,
+                                                                        weight_manager,
+                                                                        sd_ctx_params->model_args);
     return true;
 }
 

src/model/integrations/ltxav.cpp

@@ -9,15 +9,15 @@ static bool build_ltxav(const sd::model_builders::Context& ctx, const TokenizerC
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LTXAVEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                         tensor_storage_map,
-                                                         "text_encoders.llm",
-                                                         "text_embedding_projection",
-                                                         weight_manager,
-                                                         tokenizers);
+                                                                     tensor_storage_map,
+                                                                     "text_encoders.llm",
+                                                                     "text_embedding_projection",
+                                                                     weight_manager,
+                                                                     tokenizers);
     result.diffusion               = std::make_shared<LTXV::LTXAVRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                           tensor_storage_map,
-                                                           "model.diffusion_model",
-                                                           weight_manager);
+                                                                         tensor_storage_map,
+                                                                         "model.diffusion_model",
+                                                                         weight_manager);
     return true;
 }
 

src/model/integrations/mage_flow.cpp

@@ -9,16 +9,16 @@ static bool build_mage_flow(const sd::model_builders::Context& ctx, const Tokeni
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       true,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   true,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<MageFlow::MageFlowRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                  tensor_storage_map,
-                                                                  "model.diffusion_model",
-                                                                  weight_manager);
+                                                                                tensor_storage_map,
+                                                                                "model.diffusion_model",
+                                                                                weight_manager);
     return true;
 }
 

src/model/integrations/ming_image.cpp

@@ -9,9 +9,9 @@ static bool build_ming_image(const sd::model_builders::Context& ctx, const Token
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<MingImageEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                             tensor_storage_map, weight_manager, tokenizers);
+                                                                         tensor_storage_map, weight_manager, tokenizers);
     result.diffusion               = std::make_shared<MingImage::MingImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                    tensor_storage_map, "model.diffusion_model", weight_manager);
+                                                                                  tensor_storage_map, "model.diffusion_model", weight_manager);
     return true;
 }
 

src/model/integrations/minimax_h3.cpp

@@ -9,16 +9,16 @@ static bool build_minimax_h3(const sd::model_builders::Context& ctx, const Token
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       true,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   true,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<MiniMaxH3::MiniMaxH3Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                    tensor_storage_map,
-                                                                    "model.diffusion_model",
-                                                                    weight_manager);
+                                                                                  tensor_storage_map,
+                                                                                  "model.diffusion_model",
+                                                                                  weight_manager);
     return true;
 }
 

src/model/integrations/minit2i.cpp

@@ -9,12 +9,12 @@ static bool build_minit2i(const sd::model_builders::Context& ctx, const Tokenize
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<MiniT2IConditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                              tensor_storage_map,
-                                                              weight_manager);
+                                                                          tensor_storage_map,
+                                                                          weight_manager);
     result.diffusion               = std::make_shared<MiniT2I::MiniT2IRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                tensor_storage_map,
-                                                                "model.diffusion_model.model.net",
-                                                                weight_manager);
+                                                                              tensor_storage_map,
+                                                                              "model.diffusion_model.model.net",
+                                                                              weight_manager);
     return true;
 }
 

src/model/integrations/moss_image.cpp

@@ -11,7 +11,7 @@ static bool build_moss_image(const sd::model_builders::Context& ctx,
                                                         ctx.tensor_storage_map, ctx.version, "", false,
                                                         ctx.weight_manager, tokenizers);
     runners.diffusion   = std::make_shared<MOSSImage::MOSSImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                     ctx.tensor_storage_map, "model.diffusion_model", ctx.weight_manager);
+                                                                       ctx.tensor_storage_map, "model.diffusion_model", ctx.weight_manager);
     return true;
 }
 

src/model/integrations/pid.cpp

@@ -9,16 +9,16 @@ static bool build_pid(const sd::model_builders::Context& ctx, const TokenizerCon
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<Pid::PiDRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                        tensor_storage_map,
-                                                        "model.diffusion_model.net",
-                                                        weight_manager);
+                                                                      tensor_storage_map,
+                                                                      "model.diffusion_model.net",
+                                                                      weight_manager);
     return true;
 }
 

src/model/integrations/pixart.cpp

@@ -31,17 +31,17 @@ static bool build_pixart(const sd::model_builders::Context& ctx, const Tokenizer
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<T5CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                          tensor_storage_map,
-                                                          true,
-                                                          0,
-                                                          false,
-                                                          weight_manager,
-                                                          sd_ctx_params->model_args);
+                                                                      tensor_storage_map,
+                                                                      true,
+                                                                      0,
+                                                                      false,
+                                                                      weight_manager,
+                                                                      sd_ctx_params->model_args);
     result.diffusion               = std::make_shared<PixArt::PixArtRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                              tensor_storage_map,
-                                                              "model.diffusion_model",
-                                                              weight_manager,
-                                                              sd_ctx_params->model_args);
+                                                                            tensor_storage_map,
+                                                                            "model.diffusion_model",
+                                                                            weight_manager,
+                                                                            sd_ctx_params->model_args);
     return true;
 }
 

src/model/integrations/qwen_image.cpp

@@ -11,12 +11,12 @@ static bool build_qwen_image(const sd::model_builders::Context& ctx, const Token
     const auto& weight_manager     = ctx.weight_manager;
     bool enable_vision             = version != VERSION_QWEN_IMAGE_LAYERED;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       enable_vision,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   enable_vision,
+                                                                   weight_manager,
+                                                                   tokenizers);
     if (version == VERSION_QWEN_IMAGE_2_1) {
         result.diffusion = std::make_shared<Qwen::QwenImage21Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
                                                                      tensor_storage_map,

src/model/integrations/sd.cpp

@@ -34,10 +34,10 @@ static bool build_sd(const sd::model_builders::Context& ctx, const TokenizerConf
                                                                              weight_manager,
                                                                              tokenizers);
     result.diffusion   = std::make_shared<UNetModelRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                         tensor_storage_map,
-                                                         "model.diffusion_model",
-                                                         version,
-                                                         weight_manager);
+                                                           tensor_storage_map,
+                                                           "model.diffusion_model",
+                                                           version,
+                                                           weight_manager);
     return true;
 }
 static prediction_t detect_sdxl_prediction(const String2TensorStorage& weights) {

src/model/integrations/sd3.cpp

@@ -9,13 +9,13 @@ static bool build_sd3(const sd::model_builders::Context& ctx, const TokenizerCon
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<SD3CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                           tensor_storage_map,
-                                                           weight_manager,
-                                                           tokenizers);
+                                                                       tensor_storage_map,
+                                                                       weight_manager,
+                                                                       tokenizers);
     result.diffusion               = std::make_shared<MMDiTRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                     tensor_storage_map,
-                                                     "model.diffusion_model",
-                                                     weight_manager);
+                                                                   tensor_storage_map,
+                                                                   "model.diffusion_model",
+                                                                   weight_manager);
     return true;
 }
 

src/model/integrations/sensenova_u1.cpp

@@ -10,9 +10,9 @@ static bool build_sensenova_u1(const sd::model_builders::Context& ctx, const Tok
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<SenseNovaU1Conditioner>();
     result.diffusion               = std::make_shared<SenseNovaU1::SenseNovaU1Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                        tensor_storage_map,
-                                                                        "",
-                                                                        weight_manager);
+                                                                                      tensor_storage_map,
+                                                                                      "",
+                                                                                      weight_manager);
     return true;
 }
 

src/model/integrations/wan.cpp

@@ -10,16 +10,16 @@ static bool build_wan(const sd::model_builders::Context& ctx, const TokenizerCon
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<T5CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                          tensor_storage_map,
-                                                          true,
-                                                          0,
-                                                          true,
-                                                          weight_manager);
+                                                                      tensor_storage_map,
+                                                                      true,
+                                                                      0,
+                                                                      true,
+                                                                      weight_manager);
     result.diffusion               = std::make_shared<WAN::WanRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                        tensor_storage_map,
-                                                        "model.diffusion_model",
-                                                        version,
-                                                        weight_manager);
+                                                                      tensor_storage_map,
+                                                                      "model.diffusion_model",
+                                                                      version,
+                                                                      weight_manager);
     if (strlen(SAFE_STR(sd_ctx_params->high_noise_diffusion_model_path)) > 0) {
         result.high_noise_diffusion = std::make_shared<WAN::WanRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
                                                                        tensor_storage_map,

src/model/integrations/z_image.cpp

@@ -9,17 +9,17 @@ static bool build_z_image(const sd::model_builders::Context& ctx, const Tokenize
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<ZImage::ZImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                              tensor_storage_map,
-                                                              "model.diffusion_model",
-                                                              version,
-                                                              weight_manager);
+                                                                            tensor_storage_map,
+                                                                            "model.diffusion_model",
+                                                                            version,
+                                                                            weight_manager);
     return true;
 }
 

src/model/integrations/z_image_l2p.cpp

@@ -9,16 +9,16 @@ static bool build_z_image_l2p(const sd::model_builders::Context& ctx, const Toke
     const auto version             = ctx.version;
     const auto& weight_manager     = ctx.weight_manager;
     result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
-                                                       tensor_storage_map,
-                                                       version,
-                                                       "",
-                                                       false,
-                                                       weight_manager,
-                                                       tokenizers);
+                                                                   tensor_storage_map,
+                                                                   version,
+                                                                   "",
+                                                                   false,
+                                                                   weight_manager,
+                                                                   tokenizers);
     result.diffusion               = std::make_shared<ZImageL2P::ZImageL2PRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
-                                                                    tensor_storage_map,
-                                                                    "model.diffusion_model",
-                                                                    weight_manager);
+                                                                                  tensor_storage_map,
+                                                                                  "model.diffusion_model",
+                                                                                  weight_manager);
     return true;
 }