Merge pull request 'feat(enhance): LoRA switches per template (#218)' (#219) from feat/enhance-lora-switches into master

Reviewed-on: #219

CLAUDE.md

@@ -459,14 +459,20 @@ auth and stays LAN-only, so ImageApi relays previews too.
   Keys: `url`, `timeout_secs`, `probe_ttl_secs`, `poll_secs`, `idle_free_secs`,
   `unreachable_grace_secs`, `default_template`, `warn_above_megapixels`,
   `[[path_map]]` (`from`, `to`), `[[template]]` (`name`, `label`, `description`,
-  `file`, `prompt_mode`, `prompt_join`, `output_megapixels`).
+  `file`, `prompt_mode`, `prompt_join`, `output_megapixels`, `[[template.lora]]`
+  (`id`, `label`, `default`, `strength`, `min`, `max`)).
 - **Templates** are API-format workflow exports, read-only (never edit them from
   here). Nodes are found by `_meta.title`: `imageapi:source` (required, gets the
   photo path), `imageapi:save` (required, forced to `require_approval = true`; a
   `ImageApiSaveVideoVersion` there makes the template's `output` `video`, an MP4 clip,
   else `image`),
   `imageapi:prompt` (optional; fills the first of `text` / `prompt` / `value`),
-  `imageapi:reference` (optional). `prompt_mode = "append"`: the user's text is joined
+  `imageapi:reference` (optional), `imageapi:lora:<id>` (optional LoRA switches, #218:
+  a declared `[[template.lora]]` id drives every node with that title, e.g. Wan's high and
+  low pair; the resolved scale multiplies each node's exported `strength_model` /
+  `strength_clip` (1.0 = as exported, 0 = off, a pair keeps its ratio), never rewired; a
+  node with no declaration keeps its strength, a declaration with no node isn't offered;
+  both log a startup warning). `prompt_mode = "append"`: the user's text is joined
   after the template's own prompt with `prompt_join` (default one space); empty text
   leaves the prompt as is. `"replace"`: the text *is* the prompt and is required (empty
   = 400); it needs a prompt node. With no `reference_path` the reference node **and
@@ -512,8 +518,11 @@ GET  /enhance/templates
       "templates": [{"name","label","description","accepts_prompt",
                      "prompt_mode": "append"|"replace", "prompt_required",
                      "accepts_reference","default","output_megapixels",
-                     "warn_above_megapixels", "output": "image"|"video"}]}
+                     "warn_above_megapixels", "output": "image"|"video",
-POST /enhance  {"path","template","prompt"?,"reference_path"?,"library"?}  -> job
+                     "loras": [{"id","label","default","strength","min","max"}]}]}
+POST /enhance  {"path","template","prompt"?,"reference_path"?,"loras"?: {id: bool|scale},"library"?}  -> job
+     (true = the switch's strength, false or scale <= 0 = off, a scale is clamped to min..max;
+      a missing switch uses its default; an id the template doesn't offer = 400)
 GET  /enhance/jobs/{id}              -> job
 GET  /enhance/jobs?path=&library=    -> {"jobs": [job, ...]}  newest first, discarded hidden
 GET  /enhance/jobs[?status=a,b]       -> {"jobs": [...]}  no path = the jobs manager: every photo's
@@ -530,7 +539,8 @@ POST /enhance/jobs/{id}/approve {"n"} -> a /image/versions `versions[]` (or `cli
 POST /enhance/jobs/{id}/discard      -> job (hidden from the list; ComfyUI untouched)
 
 job = {"id","status","queue_position"?,"error"?,"path","library_id","template",
-       "prompt"?,"reference_path"?,"created_at","updated_at",
+       "prompt"?,"reference_path"?,"loras"?: {id: scale} (resolved, 0 = off; absent without switches),
+       "created_at","updated_at",
        "run_ms": <ms ComfyUI ran it, or null until finished / when ComfyUI gave no timings>,
        "pending": [{"n","preview": "/enhance/jobs/{id}/preview/{n}","approved"}],
        "saved":   [{"n","path","library_id"}]}

enhance.example.toml

@@ -63,3 +63,27 @@ prompt_mode = "replace"
 # name = "restore-dev"
 # label = "Restore (Dev, slow)"
 # file = "/media/nas/image_fibo2_restore_imageapi_API.json"
+
+# A video template with optional LoRAs the app can switch on or off and scale
+# (#218). Each [[template.lora]] matches the workflow's LoRA loader nodes titled
+# "imageapi:lora:<id>" (Wan's high- and low-noise pair share one id). The
+# request's scale multiplies each node's exported strength_model (and
+# strength_clip), so 1.0 = as exported, 0 = off and a pair keeps its ratio; the
+# graph isn't rewired. Any number of switches can be on at once (LoRA patches
+# add up, so their order in the graph doesn't matter). Nodes titled that way
+# with no entry here keep their exported strength.
+[[template]]
+name = "animate"
+label = "Animate"
+description = "A short clip from the photo."
+file = "/media/nas/image_wan22_animate_imageapi_API.json"
+prompt_join = ", "
+output_megapixels = 0.92
+
+[[template.lora]]
+id = "style"                         # node title "imageapi:lora:style"
+label = "Style"
+default = false                      # default: false; used when the request omits it
+strength = 1.0                       # default: 1.0; the scale when on without a number
+min = 0.0                            # default: 0.0; slider range while on (a requested
+max = 1.5                            # default: 1.5;  scale is clamped; <= 0 is off)

migrations/2026-11-03-100000_add_enhance_loras/down.sql

@@ -0,0 +1 @@
+ALTER TABLE enhance_jobs DROP COLUMN loras;

migrations/2026-11-03-100000_add_enhance_loras/up.sql

@@ -0,0 +1,2 @@
+-- The job's resolved LoRA switches (#218): JSON {id: bool}; NULL = the template had none.
+ALTER TABLE enhance_jobs ADD COLUMN loras TEXT;

src/database/enhance_dao.rs

@@ -62,11 +62,15 @@ pub struct EnhanceJobRow {
     /// Milliseconds ComfyUI actually ran the job; set once it finishes.
     #[diesel(sql_type = Nullable<BigInt>)]
     pub run_ms: Option<i64>,
+    /// The resolved LoRA switches (#218), JSON `{id: bool}`; `None` when the
+    /// template had none. Owned by `crate::enhance` like `pending`.
+    #[diesel(sql_type = Nullable<Text>)]
+    pub loras: Option<String>,
 }
 
 const COLUMNS: &str = "id, original_hash, library_id, rel_path, template, prompt, reference_hash, \
      reference_path, comfy_prompt_id, status, error, queue_position, pending, saved, \
-     discarded, created_at, updated_at, run_ms";
+     discarded, created_at, updated_at, run_ms, loras";
 
 /// One distinct prompt used across jobs, newest use first.
 #[derive(Debug, Clone, PartialEq, Eq, QueryableByName)]
@@ -171,7 +175,7 @@ impl EnhanceJobDao for SqliteEnhanceJobDao {
         trace_db_call("insert", "enhance_job_insert", |_span| {
             let mut conn = self.connection.lock().expect("Unable to get EnhanceJobDao");
             sql_query(format!(
-                "INSERT INTO enhance_jobs ({COLUMNS}) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+                "INSERT INTO enhance_jobs ({COLUMNS}) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
             ))
             .bind::<Text, _>(&job.id)
             .bind::<Text, _>(&job.original_hash)
@@ -191,6 +195,7 @@ impl EnhanceJobDao for SqliteEnhanceJobDao {
             .bind::<BigInt, _>(job.created_at)
             .bind::<BigInt, _>(job.updated_at)
             .bind::<Nullable<BigInt>, _>(job.run_ms)
+            .bind::<Nullable<Text>, _>(&job.loras)
             .execute(&mut *conn)
             .map(|_| ())
             .map_err(|e| anyhow::anyhow!("Insert error: {}", e))
@@ -370,6 +375,7 @@ mod tests {
             created_at: created,
             updated_at: created,
             run_ms: None,
+            loras: None,
         }
     }
 

src/database/schema.rs

@@ -73,6 +73,7 @@ diesel::table! {
         created_at -> BigInt,
         updated_at -> BigInt,
         run_ms -> Nullable<BigInt>,
+        loras -> Nullable<Text>,
     }
 }
 

src/enhance/config.rs

@@ -100,6 +100,72 @@ pub struct TemplateConfig {
     /// Approximate output size, for the client's large-original warning.
     #[serde(default = "default_output_mp")]
     pub output_megapixels: f64,
+    /// Optional LoRAs the app can switch on or off (#218), each matching the
+    /// workflow nodes titled `imageapi:lora:<id>`.
+    #[serde(rename = "lora", default)]
+    pub loras: Vec<LoraConfig>,
+}
+
+/// One LoRA switch (`[[template.lora]]`).
+#[derive(Debug, Clone, PartialEq, Deserialize, serde::Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct LoraConfig {
+    /// Matches the nodes titled `imageapi:lora:<id>` (Wan's high and low
+    /// pair share one id); clients send it in `POST /enhance { loras }`.
+    pub id: String,
+    pub label: String,
+    /// On when the request doesn't say.
+    #[serde(default)]
+    pub default: bool,
+    /// Scale applied when on and the request gives no number: a factor on the
+    /// strengths exported in the workflow (1.0 = as exported), so a high/low
+    /// pair keeps its ratio.
+    #[serde(default = "default_lora_strength")]
+    pub strength: f64,
+    /// Slider bounds; a requested scale is clamped to them.
+    #[serde(default)]
+    pub min: f64,
+    #[serde(default = "default_lora_max")]
+    pub max: f64,
+}
+
+impl LoraConfig {
+    /// The scale a request resolves to: `true` = `strength`, `false` or a
+    /// number <= 0 = off (0), another number clamped to `min..=max` (the
+    /// slider's range while on), absent = the default's.
+    pub fn resolve(&self, request: Option<LoraRequest>) -> f64 {
+        match request {
+            None if self.default => self.strength,
+            None => 0.0,
+            Some(LoraRequest::On(true)) => self.strength,
+            Some(LoraRequest::On(false)) => 0.0,
+            Some(LoraRequest::Scale(s)) if s <= 0.0 => 0.0,
+            Some(LoraRequest::Scale(s)) => s.clamp(self.min, self.max),
+        }
+    }
+}
+
+/// One switch in `POST /enhance { loras }`: on/off, or a scale for the slider.
+#[derive(Debug, Clone, Copy, PartialEq, Deserialize)]
+#[serde(untagged)]
+pub enum LoraRequest {
+    On(bool),
+    Scale(f64),
+}
+
+fn default_lora_strength() -> f64 {
+    1.0
+}
+
+fn default_lora_max() -> f64 {
+    1.5
+}
+
+/// Template names and LoRA ids: non-empty, letters, digits, `_` and `-`.
+fn valid_id(s: &str) -> bool {
+    !s.is_empty()
+        && s.chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
 }
 
 fn default_join() -> String {
@@ -132,11 +198,7 @@ impl EnhanceConfig {
         }
         let mut seen = std::collections::HashSet::new();
         for t in &self.templates {
-            let ok = !t.name.is_empty()
+            if !valid_id(&t.name) {
-                && t.name
-                    .chars()
-                    .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-');
-            if !ok {
                 bail!(
                     "template name {:?} must be non-empty and use only letters, digits, '_' and '-'",
                     t.name
@@ -151,6 +213,38 @@ impl EnhanceConfig {
             if t.output_megapixels.is_nan() || t.output_megapixels <= 0.0 {
                 bail!("template {:?}: output_megapixels must be > 0", t.name);
             }
+            let mut ids = std::collections::HashSet::new();
+            for l in &t.loras {
+                if !valid_id(&l.id) {
+                    bail!(
+                        "template {:?}: lora id {:?} must be non-empty and use only letters, digits, '_' and '-'",
+                        t.name,
+                        l.id
+                    );
+                }
+                if !ids.insert(l.id.as_str()) {
+                    bail!("template {:?}: duplicate lora id {:?}", t.name, l.id);
+                }
+                if l.label.trim().is_empty() {
+                    bail!("template {:?}: lora {:?} needs a label", t.name, l.id);
+                }
+                let finite = [l.strength, l.min, l.max].iter().all(|v| v.is_finite());
+                if !finite
+                    || l.min < 0.0
+                    || l.min >= l.max
+                    || !(l.min..=l.max).contains(&l.strength)
+                {
+                    bail!(
+                        "template {:?}: lora {:?} needs 0 <= min < max and strength within them \
+                         (got min {}, strength {}, max {})",
+                        t.name,
+                        l.id,
+                        l.min,
+                        l.strength,
+                        l.max
+                    );
+                }
+            }
         }
         if let Some(d) = &self.default_template
             && !self.templates.iter().any(|t| &t.name == d)
@@ -252,6 +346,74 @@ mod tests {
         assert!(parse("[[path_map]]\nfrom=''\nto='Z:\\\\'").is_err());
     }
 
+    #[test]
+    fn lora_switches_parse_and_validate() {
+        let ok = "[[template]]\nname='a'\nlabel='A'\nfile='a.json'\n\
+                  [[template.lora]]\nid='style'\nlabel='Style'\n\
+                  [[template.lora]]\nid='detail'\nlabel='Detail'\ndefault=true";
+        let base = "[[template]]\nname='a'\nlabel='A'\nfile='a.json'\n";
+        let cfg = parse(ok).unwrap();
+        let l = &cfg.templates[0].loras;
+        assert_eq!((l[0].id.as_str(), l[0].default), ("style", false));
+        assert_eq!((l[1].id.as_str(), l[1].default), ("detail", true));
+        assert_eq!((l[0].strength, l[0].min, l[0].max), (1.0, 0.0, 1.5));
+        let ranged =
+            format!("{base}[[template.lora]]\nid='x'\nlabel='X'\nstrength=0.8\nmin=0.2\nmax=2.0");
+        let r = &parse(&ranged).unwrap().templates[0].loras[0];
+        assert_eq!((r.strength, r.min, r.max), (0.8, 0.2, 2.0));
+        for bad in ["strength=2.0", "min=1.5", "min=-0.5", "max=0.5"] {
+            assert!(
+                parse(&format!(
+                    "{base}[[template.lora]]\nid='x'\nlabel='X'\n{bad}"
+                ))
+                .is_err(),
+                "{bad}"
+            );
+        }
+
+        let dup = format!(
+            "{base}[[template.lora]]\nid='x'\nlabel='X'\n[[template.lora]]\nid='x'\nlabel='Y'"
+        );
+        assert!(parse(&dup).is_err());
+        assert!(parse(&format!("{base}[[template.lora]]\nid='a b'\nlabel='X'")).is_err());
+        assert!(parse(&format!("{base}[[template.lora]]\nid='x'\nlabel=' '")).is_err());
+        assert!(
+            parse(&format!(
+                "{base}[[template.lora]]\nid='x'\nlabel='X'\nweight=1"
+            ))
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn lora_requests_resolve_to_a_scale() {
+        let l = LoraConfig {
+            id: "x".into(),
+            label: "X".into(),
+            default: false,
+            strength: 0.8,
+            min: 0.2,
+            max: 1.2,
+        };
+        assert_eq!(l.resolve(None), 0.0);
+        assert_eq!(l.resolve(Some(LoraRequest::On(true))), 0.8);
+        assert_eq!(l.resolve(Some(LoraRequest::On(false))), 0.0);
+        assert_eq!(l.resolve(Some(LoraRequest::Scale(1.0))), 1.0);
+        // Clamped to the slider's range; 0 (or less) still means off.
+        assert_eq!(l.resolve(Some(LoraRequest::Scale(5.0))), 1.2);
+        assert_eq!(l.resolve(Some(LoraRequest::Scale(0.05))), 0.2);
+        assert_eq!(l.resolve(Some(LoraRequest::Scale(0.0))), 0.0);
+        assert_eq!(l.resolve(Some(LoraRequest::Scale(-1.0))), 0.0);
+        let on = LoraConfig { default: true, ..l };
+        assert_eq!(on.resolve(None), 0.8);
+
+        let parsed: std::collections::BTreeMap<String, LoraRequest> =
+            serde_json::from_str(r#"{"a": true, "b": false, "c": 0.5, "d": 1}"#).unwrap();
+        assert_eq!(parsed["a"], LoraRequest::On(true));
+        assert_eq!(parsed["c"], LoraRequest::Scale(0.5));
+        assert_eq!(parsed["d"], LoraRequest::Scale(1.0));
+    }
+
     #[test]
     fn template_defaults() {
         let cfg = parse("[[template]]\nname='a'\nlabel='A'\nfile='a.json'").unwrap();
@@ -259,5 +421,6 @@ mod tests {
         assert_eq!(t.prompt_mode, PromptMode::Append);
         assert_eq!(t.prompt_join, " ");
         assert_eq!(t.output_megapixels, 1.0);
+        assert!(t.loras.is_empty());
     }
 }

src/enhance/handlers.rs

@@ -91,6 +91,10 @@ pub struct JobView {
     prompt: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     reference_path: Option<String>,
+    /// The scale each LoRA switch ran at (#218; 0 = off); absent when the
+    /// template had none.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    loras: Option<std::collections::BTreeMap<String, f64>>,
     created_at: i64,
     updated_at: i64,
     /// Milliseconds ComfyUI ran the job; null until it has finished.
@@ -126,6 +130,10 @@ pub fn job_view(job: &EnhanceJobRow) -> JobView {
         template: job.template.clone(),
         prompt: job.prompt.clone(),
         reference_path: job.reference_path.clone(),
+        loras: job
+            .loras
+            .as_deref()
+            .and_then(|j| serde_json::from_str(j).ok()),
         created_at: job.created_at,
         updated_at: job.updated_at,
         run_ms: job.run_ms,
@@ -223,6 +231,8 @@ struct TemplateView {
     warn_above_megapixels: f64,
     /// `image` (a PNG version) or `video` (an MP4 clip, e.g. Animate).
     output: super::template::OutputKind,
+    /// Optional LoRAs the client can switch on or off (#218).
+    loras: Vec<super::config::LoraConfig>,
 }
 
 #[get("/enhance/templates")]
@@ -251,6 +261,7 @@ pub async fn get_templates(_: Claims, svc: web::Data<EnhanceService>) -> impl Re
             output_megapixels: t.cfg.output_megapixels,
             warn_above_megapixels: svc.config.warn_above_megapixels,
             output: t.output,
+            loras: t.lora_switches().cloned().collect(),
         })
         .collect();
     let mut body = json!({
@@ -280,6 +291,10 @@ pub struct SubmitBody {
     pub prompt: Option<String>,
     #[serde(default)]
     pub reference_path: Option<String>,
+    /// LoRA switches by id (#218): `true` / `false` or a scale (clamped to
+    /// the switch's range; <= 0 is off). A missing id uses its default.
+    #[serde(default)]
+    pub loras: std::collections::BTreeMap<String, super::config::LoraRequest>,
     #[serde(default)]
     pub library: Option<String>,
 }
@@ -325,6 +340,7 @@ pub async fn submit(
             &body.template,
             body.prompt.as_deref(),
             reference.as_ref(),
+            &body.loras,
         )
         .await
     {

src/enhance/integration_tests.rs

@@ -26,6 +26,7 @@ use crate::state::AppState;
 use crate::versions::xmp::test_png::{producer_xmp, write_png};
 
 const RESTORE: &str = include_str!("../../tests/fixtures/enhance/restore_turbo.json");
+const ANIMATE_LORAS: &str = include_str!("../../tests/fixtures/enhance/animate_loras.json");
 const EDIT: &str = include_str!("../../tests/fixtures/enhance/edit_turbo.json");
 
 // ---- mock ComfyUI ---------------------------------------------------------
@@ -168,12 +169,27 @@ fn template(name: &str, mode: PromptMode, json: &str) -> Template {
             prompt_mode: mode,
             prompt_join: " ".into(),
             output_megapixels: 1.0,
+            loras: Vec::new(),
         },
         serde_json::from_str(json).unwrap(),
     )
     .unwrap()
 }
 
+/// The Animate fixture with its `imageapi:lora:style` pair as a switch.
+fn animate_with_style() -> Template {
+    let mut cfg = template("animate", PromptMode::Append, ANIMATE_LORAS).cfg;
+    cfg.loras = vec![crate::enhance::config::LoraConfig {
+        id: "style".into(),
+        label: "Style".into(),
+        default: false,
+        strength: 0.8,
+        min: 0.0,
+        max: 1.5,
+    }];
+    Template::from_value(cfg, serde_json::from_str(ANIMATE_LORAS).unwrap()).unwrap()
+}
+
 async fn fx_with(url: Option<String>, tweak: impl FnOnce(&mut EnhanceConfig)) -> Fx {
     let (mock, mock_url) = start_mock().await;
     let mut state = AppState::test_state();
@@ -205,6 +221,7 @@ async fn fx_with(url: Option<String>, tweak: impl FnOnce(&mut EnhanceConfig)) ->
         vec![
             template("restore", PromptMode::Append, RESTORE),
             template("edit", PromptMode::Replace, EDIT),
+            animate_with_style(),
         ],
         dao,
     )
@@ -333,7 +350,7 @@ async fn comfy_down_means_unavailable_and_a_clear_submit_error() {
     assert_eq!(st, 200);
     assert_eq!(body["available"], false);
     assert_eq!(body["reason"], "ComfyUI isn't running");
-    assert_eq!(body["templates"].as_array().unwrap().len(), 2);
+    assert_eq!(body["templates"].as_array().unwrap().len(), 3);
 
     let (st, body, _) = call(
         &fx,
@@ -992,6 +1009,7 @@ async fn unreachable_active_jobs_become_unavailable_after_the_grace_period() {
         created_at: now,
         updated_at: now,
         run_ms: None,
+        loras: None,
     };
     SqliteEnhanceJobDao::from_shared(fx.conn.clone())
         .insert(&dao_job)
@@ -1101,3 +1119,107 @@ async fn recent_prompts_answers_when_enhance_is_off() {
     let (st, body, _) = call(&fx, "GET", "/enhance/prompts", None).await;
     assert_eq!((st, body), (200, json!({"prompts": []})));
 }
+
+#[actix_rt::test]
+async fn lora_switches_are_listed_sent_and_stored_on_the_job() {
+    let fx = fx().await;
+    fx.put(PHOTO, b"photo");
+
+    let (_, body, _) = call(&fx, "GET", "/enhance/templates", None).await;
+    let templates = body["templates"].as_array().unwrap();
+    let animate = templates.iter().find(|t| t["name"] == "animate").unwrap();
+    assert_eq!(
+        animate["loras"],
+        json!([{"id": "style", "label": "Style", "default": false, "strength": 0.8, "min": 0.0, "max": 1.5}])
+    );
+    let restore = templates.iter().find(|t| t["name"] == "restore").unwrap();
+    assert_eq!(restore["loras"], json!([]));
+
+    // On: the configured strength, and the job remembers it.
+    let (st, job, _) = call(
+        &fx,
+        "POST",
+        "/enhance",
+        Some(json!({"path": PHOTO, "template": "animate", "loras": {"style": true}})),
+    )
+    .await;
+    assert_eq!(st, 200, "{job}");
+    assert_eq!(job["loras"], json!({"style": 0.8}));
+    let (_, again, _) = call(
+        &fx,
+        "GET",
+        &format!("/enhance/jobs/{}", job["id"].as_str().unwrap()),
+        None,
+    )
+    .await;
+    assert_eq!(again["loras"], json!({"style": 0.8}));
+
+    // Omitted: the default (off) zeroes both nodes.
+    let (st, off, _) = call(
+        &fx,
+        "POST",
+        "/enhance",
+        Some(json!({"path": PHOTO, "template": "animate"})),
+    )
+    .await;
+    assert_eq!(st, 200, "{off}");
+    assert_eq!(off["loras"], json!({"style": 0.0}));
+
+    // A slider value scales the exported strength.
+    let (st, half, _) = call(
+        &fx,
+        "POST",
+        "/enhance",
+        Some(json!({"path": PHOTO, "template": "animate", "loras": {"style": 0.5}})),
+    )
+    .await;
+    assert_eq!(st, 200, "{half}");
+    assert_eq!(half["loras"], json!({"style": 0.5}));
+    {
+        let sent = fx.mock.submitted.lock().unwrap();
+        assert_eq!(
+            sent[0]["prompt"]["50"]["inputs"]["strength_model"],
+            json!(0.8)
+        );
+        assert_eq!(
+            sent[2]["prompt"]["51"]["inputs"]["strength_model"],
+            json!(0.5)
+        );
+        assert_eq!(
+            sent[1]["prompt"]["50"]["inputs"]["strength_model"],
+            json!(0.0)
+        );
+        assert_eq!(
+            sent[1]["prompt"]["51"]["inputs"]["strength_model"],
+            json!(0.0)
+        );
+    }
+
+    // Unknown switch, or one on a template without switches: 400.
+    let (st, err, _) = call(
+        &fx,
+        "POST",
+        "/enhance",
+        Some(json!({"path": PHOTO, "template": "animate", "loras": {"nope": true}})),
+    )
+    .await;
+    assert_eq!(st, 400, "{err}");
+    let (st, _, _) = call(
+        &fx,
+        "POST",
+        "/enhance",
+        Some(json!({"path": PHOTO, "template": "restore", "loras": {"style": true}})),
+    )
+    .await;
+    assert_eq!(st, 400);
+
+    // A template without switches stores none.
+    let (_, plain, _) = call(
+        &fx,
+        "POST",
+        "/enhance",
+        Some(json!({"path": PHOTO, "template": "restore"})),
+    )
+    .await;
+    assert!(plain.get("loras").is_none(), "{plain}");
+}

src/enhance/service.rs

@@ -292,6 +292,7 @@ impl EnhanceService {
         template_name: &str,
         prompt: Option<&str>,
         reference: Option<&SourceFile>,
+        loras: &std::collections::BTreeMap<String, super::config::LoraRequest>,
     ) -> Result<EnhanceJobRow, EnhanceError> {
         let Some(client) = &self.client else {
             return Err(EnhanceError::Disabled);
@@ -319,7 +320,13 @@ impl EnhanceService {
             None => None,
         };
         let filled = template
-            .fill(&source, prompt, reference_path.as_deref(), &mut random_seed)
+            .fill(
+                &source,
+                prompt,
+                reference_path.as_deref(),
+                loras,
+                &mut random_seed,
+            )
             .map_err(|e| EnhanceError::BadRequest(e.0))?;
 
         if !self.probe_now().await {
@@ -365,6 +372,8 @@ impl EnhanceService {
             created_at: now,
             updated_at: now,
             run_ms: None,
+            loras: (!filled.loras.is_empty())
+                .then(|| serde_json::to_string(&filled.loras).unwrap_or_default()),
         };
         self.dao
             .lock()

src/enhance/template.rs

@@ -4,17 +4,25 @@
 //! Nodes are found by `_meta.title`, never by id, so re-exporting after
 //! editing the graph keeps working.
 
+use std::collections::BTreeMap;
 use std::path::Path;
 
 use anyhow::{Context as _, Result, bail};
 use serde_json::{Map, Value, json};
 
-use super::config::{PromptMode, TemplateConfig};
+use super::config::{LoraConfig, LoraRequest, PromptMode, TemplateConfig};
 
 pub const TITLE_SOURCE: &str = "imageapi:source";
 pub const TITLE_SAVE: &str = "imageapi:save";
 pub const TITLE_PROMPT: &str = "imageapi:prompt";
 pub const TITLE_REFERENCE: &str = "imageapi:reference";
+/// `imageapi:lora:<id>`: a LoRA loader the app can switch off (#218).
+pub const TITLE_LORA_PREFIX: &str = "imageapi:lora:";
+
+/// LoRA loader inputs a switch scales (0 = off). `strength_model` is
+/// required (LoraLoaderModelOnly); `strength_clip` is scaled when present
+/// (LoraLoader).
+const LORA_STRENGTH_INPUTS: &[&str] = &["strength_model", "strength_clip"];
 
 /// Prompt-node inputs, in the order they are tried.
 const PROMPT_INPUTS: &[&str] = &["text", "prompt", "value"];
@@ -51,12 +59,22 @@ pub struct Template {
     /// `(node id, input name)` of the prompt text.
     prompt: Option<(String, &'static str)>,
     reference_id: Option<String>,
+    /// Declared LoRA switches that have nodes, in `enhance.toml` order.
+    loras: Vec<LoraSwitch>,
     /// Image or video, from the save node's class.
     pub output: OutputKind,
     /// Startup warnings (stray output nodes).
     pub warnings: Vec<String>,
 }
 
+#[derive(Debug, Clone)]
+struct LoraSwitch {
+    cfg: LoraConfig,
+    /// Every node titled `imageapi:lora:<id>`, with its exported strengths
+    /// (`(input, value)`), which the switch's scale multiplies.
+    nodes: Vec<(String, Vec<(&'static str, f64)>)>,
+}
+
 /// Why a request can't be turned into a ComfyUI prompt. The message is for
 /// the caller, so it names the problem in the user's terms.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -74,6 +92,9 @@ impl std::fmt::Display for FillError {
 pub struct Filled {
     pub prompt: Value,
     pub dropped_reference: bool,
+    /// Every switch's resolved scale (0 = off; request, else its default);
+    /// stored on the job so a retry repeats it. Empty without switches.
+    pub loras: BTreeMap<String, f64>,
 }
 
 impl Template {
@@ -150,6 +171,62 @@ impl Template {
         }
 
         let mut warnings = Vec::new();
+
+        // LoRA switches: declared ids collect their nodes; a declared id with
+        // none is skipped (not offered), an undeclared node keeps its strength.
+        let mut lora_nodes: BTreeMap<&str, Vec<String>> = BTreeMap::new();
+        for (id, node) in &workflow {
+            if let Some(lora) = title_of(node).and_then(|t| t.strip_prefix(TITLE_LORA_PREFIX)) {
+                if !inputs_of(&workflow, id)
+                    .get("strength_model")
+                    .is_some_and(Value::is_number)
+                {
+                    bail!(
+                        "node {id} titled {:?} has no numeric strength_model input \
+                         (use a LoraLoaderModelOnly or LoraLoader)",
+                        format!("{TITLE_LORA_PREFIX}{lora}")
+                    );
+                }
+                lora_nodes.entry(lora).or_default().push(id.clone());
+            }
+        }
+        let mut loras = Vec::new();
+        for l in &cfg.loras {
+            match lora_nodes.remove(l.id.as_str()) {
+                Some(mut ids) => {
+                    ids.sort();
+                    let nodes = ids
+                        .into_iter()
+                        .map(|id| {
+                            let inputs = inputs_of(&workflow, &id);
+                            let exported = LORA_STRENGTH_INPUTS
+                                .iter()
+                                .filter_map(|k| {
+                                    inputs.get(*k).and_then(Value::as_f64).map(|v| (*k, v))
+                                })
+                                .collect();
+                            (id, exported)
+                        })
+                        .collect();
+                    loras.push(LoraSwitch {
+                        cfg: l.clone(),
+                        nodes,
+                    });
+                }
+                None => warnings.push(format!(
+                    "lora {:?} has no node titled {:?}, so it isn't offered",
+                    l.id,
+                    format!("{TITLE_LORA_PREFIX}{}", l.id)
+                )),
+            }
+        }
+        for lora in lora_nodes.keys() {
+            warnings.push(format!(
+                "node titled {:?} has no [[template.lora]] entry, so it stays at its exported strength",
+                format!("{TITLE_LORA_PREFIX}{lora}")
+            ));
+        }
+
         for (id, node) in &workflow {
             let class = node["class_type"].as_str().unwrap_or_default();
             if STRAY_OUTPUT_CLASSES.contains(&class) {
@@ -170,6 +247,7 @@ impl Template {
             save_id,
             prompt,
             reference_id,
+            loras,
             output,
             warnings,
         })
@@ -187,6 +265,12 @@ impl Template {
         self.cfg.prompt_mode == PromptMode::Replace
     }
 
+    /// The LoRA switches clients can offer (declared and present in the
+    /// workflow), in `enhance.toml` order.
+    pub fn lora_switches(&self) -> impl Iterator<Item = &LoraConfig> {
+        self.loras.iter().map(|l| &l.cfg)
+    }
+
     /// Fill the workflow for one photo.
     ///
     /// - `source` / `reference` are paths as ComfyUI sees them.
@@ -195,13 +279,25 @@ impl Template {
     /// - Every `seed` / `noise_seed` / `*.seed` input gets a fresh value
     ///   (ComfyUI's "randomize after generate" only exists in its page), or a
     ///   retry would return the cached result.
+    /// - `loras` sets each switch (missing = its default; see
+    ///   [`LoraConfig::resolve`]): the resolved scale multiplies the node's
+    ///   exported strengths, 0 being off, so the graph is never rewired.
     pub fn fill(
         &self,
         source: &str,
         prompt: Option<&str>,
         reference: Option<&str>,
+        loras: &BTreeMap<String, LoraRequest>,
         next_seed: &mut dyn FnMut() -> u64,
     ) -> Result<Filled, FillError> {
+        if let Some(unknown) = loras
+            .keys()
+            .find(|id| !self.loras.iter().any(|l| &l.cfg.id == *id))
+        {
+            return Err(FillError(format!(
+                "this template has no LoRA switch {unknown:?}"
+            )));
+        }
         let user_text = prompt.map(str::trim).filter(|t| !t.is_empty());
         match (&self.prompt, user_text) {
             (None, Some(_)) => {
@@ -255,6 +351,17 @@ impl Template {
             }
         }
 
+        let mut resolved = BTreeMap::new();
+        for switch in &self.loras {
+            let scale = switch.cfg.resolve(loras.get(&switch.cfg.id).copied());
+            resolved.insert(switch.cfg.id.clone(), scale);
+            for (id, exported) in &switch.nodes {
+                for (input, value) in exported {
+                    set_input(&mut wf, id, input, json!(value * scale));
+                }
+            }
+        }
+
         for node in wf.values_mut() {
             let Some(inputs) = node.get_mut("inputs").and_then(Value::as_object_mut) else {
                 continue;
@@ -268,6 +375,7 @@ impl Template {
         Ok(Filled {
             prompt: Value::Object(wf),
             dropped_reference,
+            loras: resolved,
         })
     }
 }
@@ -324,6 +432,38 @@ mod tests {
     pub const RESTORE: &str = include_str!("../../tests/fixtures/enhance/restore_turbo.json");
     pub const EDIT: &str = include_str!("../../tests/fixtures/enhance/edit_turbo.json");
     pub const DEV: &str = include_str!("../../tests/fixtures/enhance/restore_dev.json");
+    /// The Animate template plus a Style pair titled `imageapi:lora:style`
+    /// (nodes 50 high, 51 low).
+    pub const ANIMATE_LORAS: &str = include_str!("../../tests/fixtures/enhance/animate_loras.json");
+
+    fn lora(id: &str, default: bool) -> LoraConfig {
+        LoraConfig {
+            id: id.into(),
+            label: id.into(),
+            default,
+            strength: 1.0,
+            min: 0.0,
+            max: 1.5,
+        }
+    }
+
+    fn load_with_loras(json: &str, loras: Vec<LoraConfig>) -> Result<Template> {
+        let mut c = cfg("animate", PromptMode::Append);
+        c.loras = loras;
+        Template::from_value(c, serde_json::from_str(json).unwrap())
+    }
+
+    fn reqs(pairs: &[(&str, LoraRequest)]) -> BTreeMap<String, LoraRequest> {
+        pairs.iter().map(|(k, v)| (k.to_string(), *v)).collect()
+    }
+
+    fn scales(pairs: &[(&str, f64)]) -> BTreeMap<String, f64> {
+        pairs.iter().map(|(k, v)| (k.to_string(), *v)).collect()
+    }
+
+    fn none() -> BTreeMap<String, LoraRequest> {
+        BTreeMap::new()
+    }
 
     fn cfg(name: &str, mode: PromptMode) -> TemplateConfig {
         TemplateConfig {
@@ -334,6 +474,7 @@ mod tests {
             prompt_mode: mode,
             prompt_join: " ".into(),
             output_megapixels: 1.0,
+            loras: Vec::new(),
         }
     }
 
@@ -401,7 +542,13 @@ mod tests {
         v["13"]["inputs"] = json!({"prompt": "base"});
         let t = Template::from_value(cfg("t", PromptMode::Append), v).unwrap();
         let f = t
-            .fill("Z:\\a.jpg", Some("more"), None, &mut seeds())
+            .fill(
+                "Z:\\a.jpg",
+                Some("more"),
+                None,
+                &BTreeMap::new(),
+                &mut seeds(),
+            )
             .unwrap();
         assert_eq!(input(&f.prompt, "13", "prompt"), "base more");
     }
@@ -418,7 +565,9 @@ mod tests {
     #[test]
     fn fill_sets_path_forces_approval_and_randomises_every_seed() {
         let t = load(RESTORE, PromptMode::Append).unwrap();
-        let f = t.fill("Z:\\p\\a.jpg", None, None, &mut seeds()).unwrap();
+        let f = t
+            .fill("Z:\\p\\a.jpg", None, None, &none(), &mut seeds())
+            .unwrap();
         assert_eq!(input(&f.prompt, "37", "path"), "Z:\\p\\a.jpg");
         assert_eq!(input(&f.prompt, "36", "require_approval"), true);
         // KSampler.seed and TextGenerate's sampling_mode.seed, both fresh.
@@ -430,8 +579,8 @@ mod tests {
         assert_ne!(a, 774744764437710);
         // Two fills with a real RNG differ.
         let mut rng = random_seed;
-        let x = t.fill("p", None, None, &mut rng).unwrap();
+        let x = t.fill("p", None, None, &none(), &mut rng).unwrap();
-        let y = t.fill("p", None, None, &mut rng).unwrap();
+        let y = t.fill("p", None, None, &none(), &mut rng).unwrap();
         assert_ne!(input(&x.prompt, "5", "seed"), input(&y.prompt, "5", "seed"));
     }
 
@@ -457,7 +606,7 @@ mod tests {
         // SeedVR2VideoUpscaler rejects seeds above 2^32 - 1 at validation.
         let t = load(RESTORE, PromptMode::Append).unwrap();
         for _ in 0..200 {
-            let f = t.fill("p", None, None, &mut random_seed).unwrap();
+            let f = t.fill("p", None, None, &none(), &mut random_seed).unwrap();
             assert!(input(&f.prompt, "5", "seed").as_u64().unwrap() <= u64::from(u32::MAX));
         }
     }
@@ -466,7 +615,7 @@ mod tests {
     fn force_approval_even_if_the_export_had_it_off() {
         let off = RESTORE.replace("\"require_approval\": true", "\"require_approval\": false");
         let t = load(&off, PromptMode::Append).unwrap();
-        let f = t.fill("p", None, None, &mut seeds()).unwrap();
+        let f = t.fill("p", None, None, &none(), &mut seeds()).unwrap();
         assert_eq!(input(&f.prompt, "36", "require_approval"), true);
     }
 
@@ -478,14 +627,24 @@ mod tests {
         let mut v: Value = serde_json::from_str(RESTORE).unwrap();
         v["13"]["inputs"]["value"] = json!(base);
         let t = Template::from_value(c, v).unwrap();
-        let f = t.fill("p", Some("  warmer  "), None, &mut seeds()).unwrap();
+        let f = t
+            .fill(
+                "p",
+                Some("  warmer  "),
+                None,
+                &BTreeMap::new(),
+                &mut seeds(),
+            )
+            .unwrap();
         assert_eq!(
             input(&f.prompt, "13", "value"),
             "Increase the clarity\n\nAdditional instructions: warmer"
         );
-        let f = t.fill("p", Some("   "), None, &mut seeds()).unwrap();
+        let f = t
+            .fill("p", Some("   "), None, &none(), &mut seeds())
+            .unwrap();
         assert_eq!(input(&f.prompt, "13", "value"), base);
-        let f = t.fill("p", None, None, &mut seeds()).unwrap();
+        let f = t.fill("p", None, None, &none(), &mut seeds()).unwrap();
         assert_eq!(input(&f.prompt, "13", "value"), base);
     }
 
@@ -493,7 +652,13 @@ mod tests {
     fn default_join_is_a_single_space_sentence() {
         let t = load(RESTORE, PromptMode::Append).unwrap();
         let f = t
-            .fill("p", Some("Make it warmer."), None, &mut seeds())
+            .fill(
+                "p",
+                Some("Make it warmer."),
+                None,
+                &BTreeMap::new(),
+                &mut seeds(),
+            )
             .unwrap();
         let text = input(&f.prompt, "13", "value").as_str().unwrap();
         assert!(text.ends_with("Remove any phone interface overlays. Make it warmer."));
@@ -502,11 +667,20 @@ mod tests {
     #[test]
     fn replace_mode_requires_and_uses_the_instruction() {
         let t = load(EDIT, PromptMode::Replace).unwrap();
-        let err = t.fill("p", None, None, &mut seeds()).unwrap_err();
+        let err = t.fill("p", None, None, &none(), &mut seeds()).unwrap_err();
         assert!(err.0.contains("instruction"));
-        assert!(t.fill("p", Some("  "), None, &mut seeds()).is_err());
+        assert!(
+            t.fill("p", Some("  "), None, &none(), &mut seeds())
+                .is_err()
+        );
         let f = t
-            .fill("p", Some("make it black and white"), None, &mut seeds())
+            .fill(
+                "p",
+                Some("make it black and white"),
+                None,
+                &BTreeMap::new(),
+                &mut seeds(),
+            )
             .unwrap();
         assert_eq!(input(&f.prompt, "13", "value"), "make it black and white");
     }
@@ -518,18 +692,28 @@ mod tests {
         // 14 links to 13; drop that link so the graph stays plausible.
         v["14"]["inputs"].as_object_mut().unwrap().remove("prompt");
         let t = Template::from_value(cfg("t", PromptMode::Append), v).unwrap();
-        assert!(t.fill("p", Some("x"), None, &mut seeds()).is_err());
+        assert!(t.fill("p", Some("x"), None, &none(), &mut seeds()).is_err());
-        assert!(t.fill("p", None, None, &mut seeds()).is_ok());
+        assert!(t.fill("p", None, None, &none(), &mut seeds()).is_ok());
 
         let restore = load(RESTORE, PromptMode::Append).unwrap();
-        assert!(restore.fill("p", None, Some("r"), &mut seeds()).is_err());
+        assert!(
+            restore
+                .fill("p", None, Some("r"), &none(), &mut seeds())
+                .is_err()
+        );
     }
 
     #[test]
     fn reference_given_sets_its_path_and_keeps_links() {
         let t = load(EDIT, PromptMode::Replace).unwrap();
         let f = t
-            .fill("src", Some("x"), Some("Z:\\ref.jpg"), &mut seeds())
+            .fill(
+                "src",
+                Some("x"),
+                Some("Z:\\ref.jpg"),
+                &BTreeMap::new(),
+                &mut seeds(),
+            )
             .unwrap();
         assert!(!f.dropped_reference);
         assert_eq!(input(&f.prompt, "38", "path"), "Z:\\ref.jpg");
@@ -539,7 +723,9 @@ mod tests {
     #[test]
     fn no_reference_removes_the_node_and_every_link_to_it() {
         let t = load(EDIT, PromptMode::Replace).unwrap();
-        let f = t.fill("src", Some("x"), None, &mut seeds()).unwrap();
+        let f = t
+            .fill("src", Some("x"), None, &none(), &mut seeds())
+            .unwrap();
         assert!(f.dropped_reference);
         let wf = f.prompt.as_object().unwrap();
         assert!(!wf.contains_key("38"));
@@ -554,4 +740,181 @@ mod tests {
         // Links to other nodes survive.
         assert_eq!(input(&f.prompt, "36", "source"), &json!(["37", 1]));
     }
+
+    #[test]
+    fn lora_switch_drives_every_node_with_its_id() {
+        let t = load_with_loras(ANIMATE_LORAS, vec![lora("style", false)]).unwrap();
+        assert_eq!(
+            t.lora_switches().map(|l| l.id.as_str()).collect::<Vec<_>>(),
+            ["style"]
+        );
+        assert!(t.warnings.is_empty(), "{:?}", t.warnings);
+
+        // Default off: both the high and the low node go to 0.
+        let off = t.fill("p", None, None, &none(), &mut seeds()).unwrap();
+        assert_eq!(off.loras, scales(&[("style", 0.0)]));
+        for id in ["50", "51"] {
+            assert_eq!(input(&off.prompt, id, "strength_model"), &json!(0.0));
+        }
+        // The graph isn't rewired, and the fixed lightx2v LoRAs are untouched.
+        assert_eq!(input(&off.prompt, "14", "model"), &json!(["50", 0]));
+        assert_eq!(input(&off.prompt, "12", "strength_model"), &json!(1.0));
+
+        // On: the configured strength (1.0 = as exported).
+        let on = t
+            .fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("style", LoraRequest::On(true))]),
+                &mut seeds(),
+            )
+            .unwrap();
+        assert_eq!(on.loras, scales(&[("style", 1.0)]));
+        for id in ["50", "51"] {
+            assert_eq!(input(&on.prompt, id, "strength_model"), &json!(1.0));
+        }
+    }
+
+    #[test]
+    fn a_scale_multiplies_each_nodes_exported_strength() {
+        // A pair exported at different strengths keeps its ratio.
+        let mut v: Value = serde_json::from_str(ANIMATE_LORAS).unwrap();
+        v["51"]["inputs"]["strength_model"] = json!(0.8);
+        let mut c = cfg("animate", PromptMode::Append);
+        c.loras = vec![lora("style", false)];
+        let t = Template::from_value(c, v).unwrap();
+
+        let f = t
+            .fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("style", LoraRequest::Scale(0.5))]),
+                &mut seeds(),
+            )
+            .unwrap();
+        assert_eq!(f.loras, scales(&[("style", 0.5)]));
+        assert_eq!(input(&f.prompt, "50", "strength_model"), &json!(0.5));
+        assert_eq!(input(&f.prompt, "51", "strength_model"), &json!(0.4));
+
+        // Clamped to the switch's max; 0 is off.
+        let f = t
+            .fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("style", LoraRequest::Scale(9.0))]),
+                &mut seeds(),
+            )
+            .unwrap();
+        assert_eq!(f.loras, scales(&[("style", 1.5)]));
+        let f = t
+            .fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("style", LoraRequest::Scale(0.0))]),
+                &mut seeds(),
+            )
+            .unwrap();
+        assert_eq!(input(&f.prompt, "51", "strength_model"), &json!(0.0));
+    }
+
+    #[test]
+    fn lora_default_on_and_unknown_ids_refused() {
+        let mut l = lora("style", true);
+        l.strength = 0.7;
+        let t = load_with_loras(ANIMATE_LORAS, vec![l]).unwrap();
+        let f = t.fill("p", None, None, &none(), &mut seeds()).unwrap();
+        assert_eq!(f.loras, scales(&[("style", 0.7)]));
+        assert_eq!(input(&f.prompt, "50", "strength_model"), &json!(0.7));
+
+        let err = t
+            .fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("nope", LoraRequest::On(true))]),
+                &mut seeds(),
+            )
+            .unwrap_err();
+        assert!(err.0.contains("nope"), "{err}");
+    }
+
+    #[test]
+    fn lora_clip_strength_is_scaled_too() {
+        let mut v: Value = serde_json::from_str(ANIMATE_LORAS).unwrap();
+        v["50"]["class_type"] = json!("LoraLoader");
+        v["50"]["inputs"]["strength_clip"] = json!(0.8);
+        let mut c = cfg("animate", PromptMode::Append);
+        c.loras = vec![lora("style", false)];
+        let t = Template::from_value(c, v).unwrap();
+        let off = t.fill("p", None, None, &none(), &mut seeds()).unwrap();
+        assert_eq!(input(&off.prompt, "50", "strength_clip"), &json!(0.0));
+        let half = t
+            .fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("style", LoraRequest::Scale(0.5))]),
+                &mut seeds(),
+            )
+            .unwrap();
+        assert_eq!(input(&half.prompt, "50", "strength_clip"), &json!(0.4));
+    }
+
+    #[test]
+    fn undeclared_or_missing_lora_switches_are_warnings() {
+        // Nodes but no [[template.lora]]: fixed at their strength, not offered.
+        let t = load_with_loras(ANIMATE_LORAS, Vec::new()).unwrap();
+        assert_eq!(t.lora_switches().count(), 0);
+        assert!(
+            t.warnings.iter().any(|w| w.contains("imageapi:lora:style")),
+            "{:?}",
+            t.warnings
+        );
+        let f = t.fill("p", None, None, &none(), &mut seeds()).unwrap();
+        assert!(f.loras.is_empty());
+        assert_eq!(input(&f.prompt, "50", "strength_model"), &json!(1.0));
+        assert!(
+            t.fill(
+                "p",
+                None,
+                None,
+                &reqs(&[("style", LoraRequest::On(false))]),
+                &mut seeds()
+            )
+            .is_err()
+        );
+
+        // Declared but no node: skipped with a warning, the rest load.
+        let t = load_with_loras(
+            ANIMATE_LORAS,
+            vec![lora("style", false), lora("detail", true)],
+        )
+        .unwrap();
+        assert_eq!(
+            t.lora_switches().map(|l| l.id.as_str()).collect::<Vec<_>>(),
+            ["style"]
+        );
+        assert!(
+            t.warnings.iter().any(|w| w.contains("\"detail\"")),
+            "{:?}",
+            t.warnings
+        );
+    }
+
+    #[test]
+    fn a_lora_node_without_strength_model_is_rejected() {
+        let bad = ANIMATE_LORAS.replace(
+            "\"strength_model\": 1.0,\n      \"model\": [\n        \"12\"",
+            "\"weight\": 1.0,\n      \"model\": [\n        \"12\"",
+        );
+        assert_ne!(bad, ANIMATE_LORAS, "fixture layout changed");
+        let err = load_with_loras(&bad, vec![lora("style", false)])
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("strength_model"), "{err}");
+    }
 }

tests/fixtures/enhance/animate_loras.json

@@ -0,0 +1,348 @@
+{
+  "1": {
+    "class_type": "ImageApiLoadImageFromPath",
+    "_meta": {
+      "title": "imageapi:source"
+    },
+    "inputs": {
+      "path": ""
+    }
+  },
+  "2": {
+    "class_type": "ImageApiTargetSize",
+    "_meta": {
+      "title": "Target Size (~0.92 MP, keeps aspect)"
+    },
+    "inputs": {
+      "image": [
+        "1",
+        0
+      ],
+      "max_megapixels": 0.92,
+      "min_megapixels": 0.92,
+      "multiple_of": 16
+    }
+  },
+  "10": {
+    "class_type": "UNETLoader",
+    "_meta": {
+      "title": "Wan 2.2 i2v high noise"
+    },
+    "inputs": {
+      "unet_name": "wan2.2_i2v_high_noise_14B_fp8_scaled.safetensors",
+      "weight_dtype": "default"
+    }
+  },
+  "11": {
+    "class_type": "UNETLoader",
+    "_meta": {
+      "title": "Wan 2.2 i2v low noise"
+    },
+    "inputs": {
+      "unet_name": "wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors",
+      "weight_dtype": "default"
+    }
+  },
+  "12": {
+    "class_type": "LoraLoaderModelOnly",
+    "_meta": {
+      "title": "lightx2v 4-step (high)"
+    },
+    "inputs": {
+      "model": [
+        "10",
+        0
+      ],
+      "lora_name": "wan2.2_i2v_lightx2v_4steps_lora_v1_high_noise.safetensors",
+      "strength_model": 1.0
+    }
+  },
+  "13": {
+    "class_type": "LoraLoaderModelOnly",
+    "_meta": {
+      "title": "lightx2v 4-step (low)"
+    },
+    "inputs": {
+      "model": [
+        "11",
+        0
+      ],
+      "lora_name": "wan2.2_i2v_lightx2v_4steps_lora_v1_low_noise.safetensors",
+      "strength_model": 1.0
+    }
+  },
+  "14": {
+    "class_type": "ModelSamplingSD3",
+    "_meta": {
+      "title": "Shift (high)"
+    },
+    "inputs": {
+      "model": [
+        "50",
+        0
+      ],
+      "shift": 5.0
+    }
+  },
+  "15": {
+    "class_type": "ModelSamplingSD3",
+    "_meta": {
+      "title": "Shift (low)"
+    },
+    "inputs": {
+      "model": [
+        "51",
+        0
+      ],
+      "shift": 5.0
+    }
+  },
+  "40": {
+    "class_type": "PathchSageAttentionKJ",
+    "_meta": {
+      "title": "Sage attention (high)"
+    },
+    "inputs": {
+      "model": [
+        "14",
+        0
+      ],
+      "sage_attention": "auto"
+    }
+  },
+  "41": {
+    "class_type": "PathchSageAttentionKJ",
+    "_meta": {
+      "title": "Sage attention (low)"
+    },
+    "inputs": {
+      "model": [
+        "15",
+        0
+      ],
+      "sage_attention": "auto"
+    }
+  },
+  "16": {
+    "class_type": "CLIPLoader",
+    "_meta": {
+      "title": "Load CLIP"
+    },
+    "inputs": {
+      "clip_name": "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+      "type": "wan",
+      "device": "default"
+    }
+  },
+  "17": {
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "imageapi:prompt"
+    },
+    "inputs": {
+      "clip": [
+        "16",
+        0
+      ],
+      "text": "natural, lifelike motion with a slow, gentle camera movement, realistic, cinematic"
+    }
+  },
+  "18": {
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "Negative"
+    },
+    "inputs": {
+      "clip": [
+        "16",
+        0
+      ],
+      "text": "static, frozen, blurry, low quality, distorted, warped faces, morphing, flicker, watermark, text"
+    }
+  },
+  "19": {
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "Load VAE"
+    },
+    "inputs": {
+      "vae_name": "wan_2.1_vae.safetensors"
+    }
+  },
+  "21": {
+    "class_type": "WanImageToVideo",
+    "_meta": {
+      "title": "Wan Image To Video (81 frames)"
+    },
+    "inputs": {
+      "positive": [
+        "17",
+        0
+      ],
+      "negative": [
+        "18",
+        0
+      ],
+      "vae": [
+        "19",
+        0
+      ],
+      "start_image": [
+        "1",
+        0
+      ],
+      "width": [
+        "2",
+        0
+      ],
+      "height": [
+        "2",
+        1
+      ],
+      "length": 81,
+      "batch_size": 1
+    }
+  },
+  "22": {
+    "class_type": "KSamplerAdvanced",
+    "_meta": {
+      "title": "Sampler (high, steps 0-2)"
+    },
+    "inputs": {
+      "model": [
+        "40",
+        0
+      ],
+      "positive": [
+        "21",
+        0
+      ],
+      "negative": [
+        "21",
+        1
+      ],
+      "latent_image": [
+        "21",
+        2
+      ],
+      "add_noise": "enable",
+      "noise_seed": 1,
+      "steps": 4,
+      "cfg": 1.0,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "start_at_step": 0,
+      "end_at_step": 2,
+      "return_with_leftover_noise": "enable"
+    }
+  },
+  "23": {
+    "class_type": "KSamplerAdvanced",
+    "_meta": {
+      "title": "Sampler (low, steps 2-4)"
+    },
+    "inputs": {
+      "model": [
+        "41",
+        0
+      ],
+      "positive": [
+        "21",
+        0
+      ],
+      "negative": [
+        "21",
+        1
+      ],
+      "latent_image": [
+        "22",
+        0
+      ],
+      "add_noise": "disable",
+      "noise_seed": 0,
+      "steps": 4,
+      "cfg": 1.0,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "start_at_step": 2,
+      "end_at_step": 10000,
+      "return_with_leftover_noise": "disable"
+    }
+  },
+  "24": {
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    },
+    "inputs": {
+      "samples": [
+        "23",
+        0
+      ],
+      "vae": [
+        "19",
+        0
+      ]
+    }
+  },
+  "25": {
+    "class_type": "CreateVideo",
+    "_meta": {
+      "title": "Create Video (16 fps)"
+    },
+    "inputs": {
+      "images": [
+        "24",
+        0
+      ],
+      "fps": 16.0
+    }
+  },
+  "36": {
+    "class_type": "ImageApiSaveVideoVersion",
+    "_meta": {
+      "title": "imageapi:save"
+    },
+    "inputs": {
+      "video": [
+        "25",
+        0
+      ],
+      "source": [
+        "1",
+        1
+      ],
+      "kind": "animated",
+      "subfolder": "aiedits",
+      "require_approval": true
+    }
+  },
+  "50": {
+    "inputs": {
+      "lora_name": "example_style_high.safetensors",
+      "strength_model": 1.0,
+      "model": [
+        "12",
+        0
+      ]
+    },
+    "class_type": "LoraLoaderModelOnly",
+    "_meta": {
+      "title": "imageapi:lora:style"
+    }
+  },
+  "51": {
+    "inputs": {
+      "lora_name": "example_style_low.safetensors",
+      "strength_model": 1.0,
+      "model": [
+        "13",
+        0
+      ]
+    },
+    "class_type": "LoraLoaderModelOnly",
+    "_meta": {
+      "title": "imageapi:lora:style"
+    }
+  }
+}