Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
53.1 KB
Raw Blame
// @vitest-environment jsdom

import { localGeneratorTemplate as createGeneratorTemplate } from "./h3TestUtils";
import { saveActiveGeneratorId, loadActiveGeneratorId, selectedGeneratorTemplate } from "./settings";
import { beforeEach, describe, expect, it } from "vitest";
import { TURBO_LORA, VIGGLE_ANIMATE_LORA, loadLoras, saveLoras } from "./loras";
import {
  agentEndpointProviderSettings,
  chooseWeightSource,
  selectedImageGeneratorTemplate, minimaxImageTemplate, kreaImageTemplates, musicTemplates, mossImageTemplate, fiboImageTemplate, fiboBaseTemplate, templateSupportsEditing, templateSupportsOutpainting, defaultGeneratorTemplate, generatorPathFields, templateSupportsVideo,
  engineProviderSetting,
  loadInferenceBackend,
  saveInferenceBackend,
  loadDefaultGenerationSteps,
  loadAgentEndpointSettings,
  loadEngineSettings,
  loadGeneratorTemplateSettings,
  minimaxOriginalTemplate,
  minimaxReferencesTemplate,
  minimaxFastTemplate,
  minimaxSingularityTemplate,
  minimaxSingularityV2Template,
  viggleAnimateTemplate,
  templateNeedsDownload,
  saveAgentEndpointSettings,
  saveGeneratorTemplateSettings,
} from "./settings";


function generatorOwned(value: any): any {
  if (Array.isArray(value)) return value.map(generatorOwned);
  if (value?.modelType === "h3_image") {
    const { sharedTextEncoder: _shared, ...template } = value;
    const { textEncoder: _text, tokenizer: _tokenizer, ...paths } = template.paths;
    const { textEncoder: _sources, tokenizer: _tokenizerSources, ...sources } = template.sources ?? {};
    return { ...template, paths, sources };
  }
  if (!value || value.modelType !== "minimax-h3") return value;
  const { videoVaeId: _video, audioVaeId: _audio, ...template } = value;
  const { textEncoder: _text, tokenizer: _tokenizer, videoVae: _videoPath, audioVae: _audioPath, ...paths } = template.paths;
  const { textEncoder: _textSources, tokenizer: _tokenizerSources, videoVae: _videoSources, audioVae: _audioSources, ...sources } = template.sources ?? {};
  return { ...template, paths, sources };
}

describe("generator templates", () => {
  beforeEach(() => localStorage.clear());

  it("selects the highest fitting MiniMax weight tier and rejects undersized GPUs", () => {
    const cases = [
      [minimaxOriginalTemplate(), [[12, null], [13, "w4a8_convrot_pruned"], [16, "w6a8"], [20, "w6a8"], [21, "int8_convrot"]]],
      [minimaxReferencesTemplate(), [[12, null], [13, "w4a8_mixed"], [16, "w6a8"], [20, "w6a8"], [21, "int8_convrot"]]],
      [minimaxFastTemplate(), [[16, null], [17, "w4a8"], [21, "w4a8"], [22, "int8_convrot"]]],
      [minimaxSingularityTemplate(), [[11, null], [12, "w4a8"], [20, "w4a8"], [21, "int8"]]],
      [minimaxSingularityV2Template(), [[11, null], [12, "w4a8"], [15, "w4a8"], [16, "w6a8_r2"], [20, "w6a8_r2"], [21, "int8_convrot_r2"]]],
    ] as const;
    for (const [template, selections] of cases) {
      const sources = template.sources!.transformer!;
      for (const [memory, suffix] of selections) {
        const selected = chooseWeightSource(sources, [{ name: "GPU", memoryBytes: memory * 1024 ** 3 }]);
        if (suffix === null) expect(selected).toBeNull();
        else expect(selected?.url.endsWith(`${suffix}.safetensors`)).toBe(true);
      }
      expect(chooseWeightSource(sources, [])).toBeNull();
    }
    const v2 = minimaxSingularityV2Template();
    expect(v2.sources!.transformer!.map(({ minVramGb }) => minVramGb)).toEqual([21, 16, 12]);
    expect(v2.defaultSteps).toBe(4);
    expect(v2.loras).toEqual([{ loraId: TURBO_LORA.id, enabled: true, strength: 1 }]);
    expect(minimaxFastTemplate().loras).toBeUndefined();
  });

  it("adds MiniMax low-memory tiers once without replacing custom settings, cached files or removed generators", () => {
    const original = minimaxOriginalTemplate();
    const fast = minimaxFastTemplate();
    const singularity = minimaxSingularityTemplate();
    const custom = { url: "https://example.com/custom.safetensors", gpuModel: "Custom GPU", minVramGb: 10 };
    const cached = "D:/weights/original.safetensors";
    original.name = "My first/last";
    original.defaultSteps = 27;
    original.paths.transformer = cached;
    original.sources!.transformer = [{ ...original.sources!.transformer![0], downloadedPath: cached },
      { ...original.sources!.transformer![1], minVramGb: 12 }, custom];
    fast.sources!.transformer = [{ ...fast.sources!.transformer![0], gpuModel: "RTX", minVramGb: 24 }];
    singularity.sources!.transformer = [singularity.sources!.transformer![0]];
    saveGeneratorTemplateSettings({ templates: [original, fast, singularity], defaultTemplateId: "", catalogVersion: 20 });
    const migrated = loadGeneratorTemplateSettings();
    expect(migrated.catalogVersion).toBe(23);
    expect(migrated.templates.map(({ id }) => id)).toEqual([original.id, fast.id, singularity.id, "minimax-h3-singularity-v2", "minimax-h3-image"]);
    expect(migrated.templates[0]).toMatchObject({ name: original.name, defaultSteps: 27, paths: { transformer: cached },
      sources: { transformer: [original.sources!.transformer![0], { ...original.sources!.transformer![1], minVramGb: 13 }, custom, minimaxOriginalTemplate().sources!.transformer![2]] } });
    expect(migrated.templates[1].sources!.transformer).toEqual([fast.sources!.transformer![0], minimaxFastTemplate().sources!.transformer![1]]);
    expect(migrated.templates[2].sources!.transformer).toEqual(minimaxSingularityTemplate().sources!.transformer);
    expect(loadGeneratorTemplateSettings()).toEqual(migrated);
    migrated.templates = [migrated.templates[0]];
    migrated.templates[0].sources!.transformer = [custom];
    saveGeneratorTemplateSettings(migrated);
    expect(loadGeneratorTemplateSettings()).toEqual(migrated);
  });

  it("remembers independent active generators and falls back only when the selected template is removed", () => {
    const video = createGeneratorTemplate("Video"), image = createGeneratorTemplate("Image"), music = musicTemplates()[0];
    const settings = { templates: [video, image, music], defaultTemplateId: video.id };
    saveActiveGeneratorId("video", video.id);
    saveActiveGeneratorId("image", image.id);
    saveActiveGeneratorId("music", music.id);
    for (const [medium, template] of [["video", video], ["image", image], ["music", music]] as const) {
      expect(loadActiveGeneratorId(medium)).toBe(template.id);
      expect(selectedGeneratorTemplate(medium, settings).id).toBe(template.id);
    }
    saveActiveGeneratorId("video", image.id);
    expect(selectedGeneratorTemplate("music", settings).id).toBe(music.id);
    expect(selectedImageGeneratorTemplate(settings).id).toBe(image.id);
    expect(selectedImageGeneratorTemplate({ ...settings, templates: [video, music] }).id).toBe(video.id);
  });

  it("adds Krea Turbo and Raw once with three weights, preserving custom templates and removal", () => {
    const [turbo, raw] = kreaImageTemplates();
    for (const template of [turbo, raw]) {
      expect(template).toMatchObject({ modelType: "krea2", editingModel: false, attention: "flash2" });
      expect(template.sources!.transformer![0].minVramGb).toBe(14);
      expect(template.sources!.textEncoder![0].minVramGb).toBe(5);
      expect(template.sources!.videoVae![0].minVramGb).toBe(0);
      expect(generatorPathFields(template).filter(({ required }) => required).map(({ id }) => id)).toEqual(["transformer", "textEncoder", "videoVae"]);
      expect(templateSupportsVideo(template)).toBe(false);
      expect(templateSupportsEditing({ ...template, editingModel: true })).toBe(false);
    }
    const custom = { ...raw, name: "My Raw", defaultSteps: 60, paths: { ...raw.paths, transformer: "D:/raw.safetensors" } };
    saveGeneratorTemplateSettings({ templates: [custom], defaultTemplateId: "", catalogVersion: 19 });
    const migrated = loadGeneratorTemplateSettings();
    expect(generatorOwned(migrated.templates)).toEqual(generatorOwned([custom, turbo, minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(loadGeneratorTemplateSettings()).toEqual(migrated);
    saveGeneratorTemplateSettings({ ...migrated, templates: [custom] });
    expect(loadGeneratorTemplateSettings().templates).toEqual([custom]);
    const provider = engineProviderSetting(custom.paths, undefined, custom.attention, [], "prompt", [], false, custom.sources, custom);
    expect(provider.options).toMatchObject({ modelType: "krea2", kreaVariant: "raw", editingModel: false, attention: "flash2" });
    expect(provider.options).not.toHaveProperty("audioVae");
    expect(provider.options).not.toHaveProperty("tokenizer");
  });

  it("selects YuE2 BF16 only above 8 GiB, with INT8 for smaller or unknown GPUs", () => {
    const sources = musicTemplates()[0].sources!.transformer!;
    for (const [gib, filename] of [[4, "yue2_3b_int8_convrot.safetensors"], [8, "yue2_3b_int8_convrot.safetensors"],
      [8.01, "yue2_3b_bf16.safetensors"], [12, "yue2_3b_bf16.safetensors"], [31.4, "yue2_3b_bf16.safetensors"]] as const) {
      expect(chooseWeightSource(sources, [{ name: "GPU", memoryBytes: gib * 1024 ** 3 }])?.url)
        .toBe(`https://huggingface.co/Comfy-Org/YuE2/resolve/main/checkpoints/${filename}`);
    }
    expect(chooseWeightSource(sources, [])?.url).toBe(musicTemplates()[0].paths.transformer);
  });

  it("uses the supplied MiniMax Music3 weights and only its three required model roles", () => {
    const template = musicTemplates()[1];
    const root = "https://huggingface.co/Comfy-Org/MiniMax-Music-3/resolve/main/";
    expect(template.paths).toMatchObject({
      transformer: root + "diffusion_models/minimax_music3_dit_int8_convrot.safetensors",
      textEncoder: root + "text_encoders/minimax_music3_text_encoder_pruned_int8_convrot.safetensors",
      audioVae: root + "vae/minimax_music3_dav.safetensors",
    });
    expect(generatorPathFields(template).map(({ id }) => id)).toEqual(["transformer", "textEncoder", "audioVae"]);
  });

  it.each([[3, "int8_convrot"], [4, "int8_convrot"], [4.7, "fp16"], [5, "fp16"], [8, "fp16"], [9, "fp16"], [9.7, "fp32"], [10, "fp32"], [24, "fp32"]] as const)("selects Music3 %s GB transformer as %s", (gib, precision) => {
    const sources = musicTemplates()[1].sources!.transformer!;
    expect(chooseWeightSource(sources, [{ name: "GPU", memoryBytes: gib * 1024 ** 3 }])?.url)
      .toBe(`https://huggingface.co/Comfy-Org/MiniMax-Music-3/resolve/main/diffusion_models/minimax_music3_dit_${precision}.safetensors`);
  });

  it("adds Music3 precision variants once, preserving downloads and custom variants", () => {
    const template = musicTemplates()[1];
    const [fp32, fp16, int8] = template.sources!.transformer!;
    const cached = "D:/weights/music-int8.safetensors";
    const customFp16 = { ...fp16, url: fp16.url.replace("/resolve/", "/blob/"), minVramGb: 7 };
    const custom = { url: "https://example.com/custom.safetensors", gpuModel: "Custom GPU", minVramGb: 6 };
    const previous = { ...template, name: "My music", paths: { ...template.paths, transformer: cached },
      sources: { ...template.sources, transformer: [{ ...int8, downloadedPath: cached }, customFp16, custom] } };
    saveGeneratorTemplateSettings({ templates: [previous], defaultTemplateId: previous.id, catalogVersion: 18 });
    const upgraded = loadGeneratorTemplateSettings();
    expect(upgraded.catalogVersion).toBe(23);
    expect(upgraded.templates[0]).toMatchObject({ name: "My music", paths: { transformer: cached },
      sources: { transformer: [fp32, { ...int8, downloadedPath: cached }, customFp16, custom] } });
    expect(loadGeneratorTemplateSettings()).toEqual(upgraded);
    // Removing an alternative after the migration is a persistent user choice.
    upgraded.templates[0].sources!.transformer = [int8];
    saveGeneratorTemplateSettings(upgraded);
    expect(loadGeneratorTemplateSettings().templates[0].sources!.transformer).toEqual([int8]);

    const customTemplate = { ...previous, sources: { transformer: [custom] } };
    saveGeneratorTemplateSettings({ templates: [customTemplate], defaultTemplateId: customTemplate.id, catalogVersion: 18 });
    expect(loadGeneratorTemplateSettings().templates[0].sources!.transformer).toEqual([custom]);
  });

  it("upgrades YuE2's old step default once and leaves custom steps and Music3 unchanged", () => {
    const yue = { ...musicTemplates()[0], defaultSteps: 32 };
    const custom = { ...yue, id: "custom-yue", defaultSteps: 12 };
    const music3 = musicTemplates()[1];
    saveGeneratorTemplateSettings({ templates: [yue, custom, music3], defaultTemplateId: yue.id, catalogVersion: 21 });
    const updated = loadGeneratorTemplateSettings();
    expect(updated.catalogVersion).toBe(23);
    expect(updated.templates.map(template => template.defaultSteps)).toEqual([6, 12, 30, 6]);
    saveGeneratorTemplateSettings({ ...updated, templates: updated.templates.map(template => ({ ...template, defaultSteps: 32 })) });
    expect(loadGeneratorTemplateSettings().templates.filter(template => template.modelType !== "h3_image").every(template => template.defaultSteps === 32)).toBe(true);
  });

  it("upgrades existing YuE2 sources once while preserving downloaded and custom choices", () => {
    const template = musicTemplates()[0];
    const int8 = template.sources!.transformer![1];
    const cached = "D:/weights/yue2-int8.safetensors";
    const previous = { ...template, name: "My music", paths: { ...template.paths, transformer: cached },
      sources: { transformer: [{ ...int8, downloadedPath: cached }] } };
    saveGeneratorTemplateSettings({ templates: [previous], defaultTemplateId: previous.id, catalogVersion: 16 });
    const upgraded = loadGeneratorTemplateSettings();
    expect(upgraded.catalogVersion).toBe(23);
    expect(upgraded.templates[0]).toMatchObject({ name: "My music", paths: { transformer: cached },
      sources: { transformer: [template.sources!.transformer![0], { ...int8, downloadedPath: cached }] } });
    expect(loadGeneratorTemplateSettings()).toEqual(upgraded);

    const custom = { ...previous, sources: { transformer: [{ url: "https://example.com/custom.safetensors", gpuModel: "", minVramGb: 0 }] } };
    saveGeneratorTemplateSettings({ templates: [custom], defaultTemplateId: custom.id, catalogVersion: 16 });
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([custom, ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    const remaining = musicTemplates()[1];
    saveGeneratorTemplateSettings({ ...upgraded, templates: [remaining], defaultTemplateId: "" });
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([remaining]));
  });

  it("starts image projects with the remembered Fibo generator's four-step default", async () => {
    const h3 = createGeneratorTemplate("Video"), fibo = createGeneratorTemplate("Fibo", "fibo2");
    saveGeneratorTemplateSettings({ templates: [h3, fibo], defaultTemplateId: h3.id, catalogVersion: 14 });
    localStorage.setItem("slopus.image-generator-template.v1", fibo.id);
    expect(selectedImageGeneratorTemplate().defaultSteps).toBe(4);
    const { createProject } = await import("./persistence");
    const record = await createProject({ name: "Fibo image", generationType: "image", prompt: "A blue vase", aspectRatio: "1:1", resolution: "768p", targetDurationSeconds: 10 });
    expect(record?.config.imageScene?.steps).toBe(4);
  });

  it("normalizes missing Fibo steps to four while retaining explicit custom defaults", () => {
    const fibo = fiboImageTemplate();
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [{ ...fibo, defaultSteps: undefined }], catalogVersion: 14 }));
    expect(loadGeneratorTemplateSettings().templates[0].defaultSteps).toBe(4);
    saveGeneratorTemplateSettings({ templates: [{ ...fibo, defaultSteps: 8 }], defaultTemplateId: "", catalogVersion: 14 });
    expect(loadGeneratorTemplateSettings().templates[0].defaultSteps).toBe(8);
  });

  it("adds Fibo once without replacing custom settings or restoring a removed template", () => {
    const custom = createGeneratorTemplate("Custom");
    saveGeneratorTemplateSettings({ templates: [custom], defaultTemplateId: custom.id, catalogVersion: 13 });
    const migrated = loadGeneratorTemplateSettings();
    expect(generatorOwned(migrated.templates)).toEqual(generatorOwned([custom, fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(migrated.defaultTemplateId).toBe(custom.id);
    expect(loadGeneratorTemplateSettings()).toEqual(migrated);
    saveGeneratorTemplateSettings({ ...migrated, templates: [custom] });
    expect(loadGeneratorTemplateSettings().templates).toHaveLength(1);
  });

  it("configures Fibo with three weights, embedded tokenizer and four Flash steps", () => {
    const fibo = fiboImageTemplate();
    expect(createGeneratorTemplate("Fibo", "fibo2")).toMatchObject({ defaultSteps: 4, attention: "flash2" });
    expect(fibo.paths).toEqual({
      transformer: "https://huggingface.co/Comfy-Org/Fibo-2.0/resolve/main/diffusion_models/fibo2_edit_turbo_int8_convrot.safetensors",
      textEncoder: "https://huggingface.co/Comfy-Org/Fibo-2.0/resolve/main/text_encoders/qwen3vl_4b_int8_convrot.safetensors",
      videoVae: "https://huggingface.co/Comfy-Org/Fibo-2.0/resolve/main/vae/flux2-vae.safetensors", audioVae: "", tokenizer: "",
    });
    expect(generatorPathFields(fibo).filter(({ required }) => required).map(({ id }) => id)).toEqual(["transformer", "textEncoder", "videoVae"]);
    expect(templateSupportsVideo(fibo)).toBe(false);
    const paths = { ...fibo.paths, transformer: "transformer", textEncoder: "qwen", videoVae: "flux" };
    const provider = engineProviderSetting(paths, { enabled: true, model: null, options: { tokenizer: "old-tokenizer", audioVae: "old-audio" } }, fibo.attention, [], "prompt", [], false, fibo.sources, fibo);
    expect(provider.options).toMatchObject({ modelType: "fibo2", attention: "flash2", transformer: "transformer", textEncoder: "qwen", videoVae: "flux" });
    expect(provider.options).not.toHaveProperty("audioVae");
    expect(provider.options).not.toHaveProperty("tokenizer");
  });

  it("adds MOSS once, preserving local templates, defaults and catalog removal", () => {
    const custom = createGeneratorTemplate("Custom");
    saveGeneratorTemplateSettings({ templates: [custom], defaultTemplateId: custom.id, catalogVersion: 9 });
    const migrated = loadGeneratorTemplateSettings();
    expect(generatorOwned(migrated.templates)).toEqual(generatorOwned([custom, mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(migrated.defaultTemplateId).toBe(custom.id);
    expect(loadGeneratorTemplateSettings()).toEqual(migrated);
    saveGeneratorTemplateSettings({ ...migrated, templates: [custom] });
    expect(loadGeneratorTemplateSettings().templates).toHaveLength(1);
  });

  it("uses MOSS image weights and tokenizer without audio and excludes it from video defaults", () => {
    const moss = mossImageTemplate();
    expect(generatorPathFields(moss).filter((field) => field.required).map((field) => field.id)).toEqual(["transformer", "textEncoder", "videoVae", "tokenizer"]);
    expect(generatorPathFields(moss).find((field) => field.id === "tokenizer")?.directory).toBe(false);
    expect(templateSupportsVideo(moss)).toBe(false);
    moss.paths = Object.fromEntries(Object.entries(moss.paths).map(([key, value]) => [key, value ? `D:/weights/${key}` : ""])) as typeof moss.paths;
    const h3 = createGeneratorTemplate("Video");
    const settings = { templates: [moss, h3], defaultTemplateId: moss.id, catalogVersion: 10 };
    expect(defaultGeneratorTemplate(settings).id).toBe(moss.id);
    expect(defaultGeneratorTemplate(settings, "video").id).toBe(h3.id);
    const provider = engineProviderSetting(moss.paths, { enabled: true, model: null, options: { audioVae: "old-audio" } }, moss.attention, [], "prompt", [], false, moss.sources, moss);
    expect(provider.options).toMatchObject({ modelType: "moss", attention: "flash2", tokenizer: "D:/weights/tokenizer", videoVae: "D:/weights/videoVae" });
    expect(provider.options).not.toHaveProperty("audioVae");
  });

  it("assigns MiniMax H3 to current and legacy generators and preserves future model types", () => {
    expect(createGeneratorTemplate().modelType).toBe("minimax-h3");
    expect(loadGeneratorTemplateSettings().templates.filter((template) => ! ["moss-image", "fibo2-edit-turbo", "fibo2-base", "yue2", "minimax_music3", "krea2-turbo", "krea2-raw", "minimax-h3-image"].includes(template.id)).every((template) => template.modelType === "minimax-h3")).toBe(true);
    for (const modelType of [undefined, null, "", 123]) {
      localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({
        templates: [{ id: "legacy", name: "Renamed generator", modelType }], defaultTemplateId: "legacy", catalogVersion: 9,
      }));
      expect(loadGeneratorTemplateSettings().templates[0].modelType).toBe("minimax-h3");
    }
    const future = createGeneratorTemplate("Future generator", "future-model");
    saveGeneratorTemplateSettings({ templates: [future], defaultTemplateId: future.id, catalogVersion: 9 });
    expect(loadGeneratorTemplateSettings().templates[0]).toMatchObject(future);
  });

  it("persists MotionCache per template and replaces stale runtime options", () => {
    const template = createGeneratorTemplate();
    expect(template.motionCache ?? false).toBe(false);
    template.motionCache = true;
    saveGeneratorTemplateSettings({ templates: [template], defaultTemplateId: template.id, catalogVersion: 8 });
    expect(loadGeneratorTemplateSettings().templates[0].motionCache).toBe(true);
    const enabled = engineProviderSetting(template.paths);
    expect(enabled.options.motionCache).toBe(true);
    expect(engineProviderSetting(template.paths, enabled, template.attention, [], "prompt", [], false).options).not.toHaveProperty("motionCache");
    expect(engineProviderSetting(template.paths, enabled, template.attention, [], "animate", [], true).options).not.toHaveProperty("motionCache");
    template.motionCache = false;
    saveGeneratorTemplateSettings({ templates: [template], defaultTemplateId: template.id, catalogVersion: 8 });
    expect(engineProviderSetting(template.paths, enabled).options).not.toHaveProperty("motionCache");
  });

  it("migrates the former flat engine paths into the Default template", () => {
    localStorage.setItem("slopus.engine-paths.v1", JSON.stringify({ transformer: "D:\\Models\\main.safetensors" }));
    const settings = loadGeneratorTemplateSettings();
    expect(settings.defaultTemplateId).toBe("");
    expect(templateNeedsDownload(settings.templates[0])).toBe(true);
    expect(settings.templates).toHaveLength(15);
    expect(settings.templates[1].name).toBe("First/Last Frame");
    expect(settings.templates[0]).toMatchObject({
      id: "default",
      name: "Default",
      defaultSteps: 20,
      attention: "sage2",
      paths: { transformer: "D:\\Models\\main.safetensors" },
    });
  });

  it("migrates missing or invalid attention to Sage", () => {
    for (const attention of [undefined, "unsupported"]) {
      localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({
        templates: [{ id: "old", name: "Old", attention }], defaultTemplateId: "old",
      }));
      expect(loadGeneratorTemplateSettings().templates[0].attention).toBe("sage2");
    }
  });

  it("adds conditioning to installed Animate templates once without replacing custom files", () => {
    const animate = viggleAnimateTemplate();
    animate.paths.transformer = "D:/models/viggle.safetensors";
    delete animate.additionalSafetensors;
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [animate], defaultTemplateId: "", catalogVersion: 7 }));
    const migrated = loadGeneratorTemplateSettings();
    expect(migrated.templates[0].paths.transformer).toBe(animate.paths.transformer);
    expect(migrated.templates[0].additionalSafetensors).toEqual(viggleAnimateTemplate().additionalSafetensors);
    expect(loadGeneratorTemplateSettings()).toEqual(migrated);
    migrated.templates[0].additionalSafetensors![0].url = "https://example.com/custom.safetensors";
    saveGeneratorTemplateSettings(migrated);
    expect(loadGeneratorTemplateSettings().templates[0].additionalSafetensors![0].url).toBe("https://example.com/custom.safetensors");
  });

  it("migrates Animate once and preserves its mode, local weights and four-step adapter", () => {
    const custom = createGeneratorTemplate("Existing");
    saveGeneratorTemplateSettings({ templates: [custom], defaultTemplateId: custom.id, catalogVersion: 6 });
    const settings = loadGeneratorTemplateSettings();
    const template = settings.templates.find(({ id }) => id === "viggle-animate")!;
    expect(generatorOwned(template)).toEqual(generatorOwned(viggleAnimateTemplate()));
    expect(settings.defaultTemplateId).toBe(custom.id);
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
    expect(template.paths.transformer).toBe("https://huggingface.co/DeepBeepMeep/MiniMax-H3/resolve/main/Viggle-Animate-pruned_rank8_int8_convrot.safetensors");
    expect(templateNeedsDownload(template)).toBe(true);
    template.additionalSafetensors![0].downloadedPath = "D:/weights/conditioning.safetensors";
    template.name = "My animation";
    template.paths.transformer = "local";
    for (const entry of settings.h3Components!.templates) entry.path = `D:/weights/${entry.id}.safetensors`;
    saveLoras(loadLoras().map((lora) => lora.id === VIGGLE_ANIMATE_LORA.id ? { ...lora, path: "adapter" } : lora));
    saveGeneratorTemplateSettings({ ...settings, defaultTemplateId: template.id });
    expect(generatorOwned(loadGeneratorTemplateSettings().templates.find(({ id }) => id === template.id))).toEqual(generatorOwned(template));
    const options = engineProviderSetting(loadEngineSettings()).options;
    expect(options).toMatchObject({ generationMode: "animate", stepOverride: 4, promptEmbedding: "D:/weights/conditioning.safetensors" });
    expect(options).not.toHaveProperty("textEncoder");
    expect(options).not.toHaveProperty("tokenizer");
    expect(JSON.parse(options.loras as string)).toEqual([{ path: "adapter", strength: 1 }]);
    expect(engineProviderSetting(custom.paths, { enabled: true, model: null, options }, "sage2", [], "prompt").options).not.toHaveProperty("generationMode");
    expect(engineProviderSetting(custom.paths, { enabled: true, model: null, options }, "sage2", [], "prompt").options).not.toHaveProperty("promptEmbedding");
  });

  it("keeps References on REF2VA for all VRAM tiers", () => {
    const original = minimaxOriginalTemplate();
    const references = minimaxReferencesTemplate();
    const transformer = "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors";
    expect(original.name).toBe("First/Last Frame");
    expect(references).toEqual({ ...original, id: "minimax-h3-references", name: "References",
      paths: { ...original.paths, transformer },
      sources: { ...original.sources, transformer: [{ ...original.sources!.transformer![0], url: transformer }, { url: "https://huggingface.co/koongrizzly/MiniMax_H3_int4_W4A8_ConvRot_Pruned/resolve/main/diffusion_models/minimax_h3_ref2va_hybrid_b20-49_pruned_w4a8_mixed.safetensors", gpuModel: "", minVramGb: 13 }, { url: "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_w6a8.safetensors", gpuModel: "", minVramGb: 16 }] },
    });
    expect(loadGeneratorTemplateSettings().templates.map(({ name }) => name)).toEqual(["Default", "First/Last Frame", "References", "FastH3 Omni", "Singularity", "Animate", "MOSS Image", "Fibo 2.0 Edit Turbo", "Fibo 2.0 Base", "YuE2", "MiniMax Music3", "Krea 2 Turbo", "Krea 2 Raw", "Singularity v2", "MiniMax H3 Image"]);
  });

  it.each(["Minimax H3 Original", "My custom generator"])("migrates the saved %s template without changing its configuration", (name) => {
    const template = minimaxOriginalTemplate();
    template.name = name;
    template.defaultSteps = 12;
    template.attention = "exact";
    template.paths = { transformer: "transformer", textEncoder: "encoder", videoVae: "video", audioVae: "audio", tokenizer: "" };
    template.sources!.transformer![0].downloadedPath = "transformer";
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], defaultTemplateId: template.id, catalogVersion: 3 }));
    const settings = loadGeneratorTemplateSettings();
    expect(generatorOwned(settings.templates[0])).toEqual(generatorOwned({ ...template, name: name === "Minimax H3 Original" ? "First/Last Frame" : name }));
    expect(generatorOwned(settings.templates[1])).toEqual(generatorOwned(minimaxReferencesTemplate()));
    expect(generatorOwned(settings.templates[2])).toEqual(generatorOwned(minimaxFastTemplate()));
    expect(generatorOwned(settings.templates[3])).toEqual(generatorOwned(minimaxSingularityTemplate()));
    expect(settings.defaultTemplateId).toBe(template.id);
    expect(settings.catalogVersion).toBe(23);
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
    saveGeneratorTemplateSettings({ ...settings, templates: [settings.templates[0]] });
    expect(loadGeneratorTemplateSettings().templates).toHaveLength(1);
  });

  it("preserves an existing References template during catalog migration", () => {
    const references = minimaxReferencesTemplate();
    references.paths.transformer = "D:/Models/custom.safetensors";
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [references], catalogVersion: 3 }));
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([references, minimaxFastTemplate(), minimaxSingularityTemplate(), viggleAnimateTemplate(), mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
  });

  it("adds Singularity to the previous catalog once while preserving saved templates", () => {
    const custom = createGeneratorTemplate("My generator");
    custom.defaultSteps = 12;
    custom.paths.transformer = "D:/Models/custom.safetensors";
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [custom], defaultTemplateId: custom.id, catalogVersion: 4 }));
    const settings = loadGeneratorTemplateSettings();
    expect(generatorOwned(settings.templates)).toEqual(generatorOwned([custom, minimaxSingularityTemplate(), viggleAnimateTemplate(), mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(settings.defaultTemplateId).toBe(custom.id);
    expect(settings.catalogVersion).toBe(23);
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
    saveGeneratorTemplateSettings({ ...settings, templates: [custom] });
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([custom]));
  });

  it("preserves a customized Singularity during catalog migration", () => {
    const template = minimaxSingularityTemplate();
    template.defaultSteps = 8;
    template.paths.transformer = "D:/Models/singularity.safetensors";
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 4 }));
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([template, viggleAnimateTemplate(), mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
  });

  it("adds Turbo to saved Singularity once and preserves other adapters and settings", () => {
    const template = minimaxSingularityTemplate();
    template.defaultSteps = 8;
    template.paths = { transformer: "main", textEncoder: "encoder", videoVae: "video", audioVae: "audio", tokenizer: "" };
    template.loras = [{ loraId: "custom", enabled: false, strength: 0.5 }];
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], defaultTemplateId: template.id, catalogVersion: 5 }));
    const settings = loadGeneratorTemplateSettings();
    expect(generatorOwned(settings.templates)).toEqual(generatorOwned([{ ...template, loras: [...template.loras, { loraId: TURBO_LORA.id, enabled: true, strength: 1 }] }, viggleAnimateTemplate(), mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(settings.defaultTemplateId).toBe("");
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
    saveGeneratorTemplateSettings({ ...settings, templates: [template] });
    expect(loadGeneratorTemplateSettings().templates[0].loras).toEqual(template.loras);
  });

  it("preserves an existing disabled Turbo selection during migration", () => {
    const template = minimaxSingularityTemplate();
    template.loras = [{ loraId: TURBO_LORA.id, enabled: false, strength: 0.3 }];
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 5 }));
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([template, viggleAnimateTemplate(), mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
  });

  it("adds FastH3 Omni with eight steps and its model URLs", () => {
    const original = minimaxOriginalTemplate();
    const fast = minimaxFastTemplate();
    const transformer = "https://huggingface.co/FastVideo/FastH3-Omni-Comfy/resolve/main/diffusion_models/fasth3_omniref_8step_pruned_int8_convrot.safetensors";
    const videoVae = "https://huggingface.co/Comfy-Org/MiniMax-H3/blob/main/vae/minimax_h3_video_vae_int8_convrot.safetensors";
    expect(fast).toEqual({ ...original, id: "minimax-h3-fast", name: "FastH3 Omni", defaultSteps: 8,
      paths: { ...original.paths, transformer, videoVae },
      sources: { ...original.sources, transformer: [{ url: transformer, gpuModel: "", minVramGb: 22 }, { url: "https://huggingface.co/berryber09/FastH3-OmniRef-8step-pruned-w4a8/resolve/main/fasth3_omniref_8step_pruned_w4a8.safetensors", gpuModel: "", minVramGb: 17 }],
        videoVae: [{ url: videoVae, gpuModel: "", minVramGb: 3 }] },
    });
    saveGeneratorTemplateSettings({ templates: [fast], defaultTemplateId: "", catalogVersion: 4 });
    expect(loadGeneratorTemplateSettings().templates[0].defaultSteps).toBe(8);
  });

  it.each([false, true])("upgrades saved Fast model URLs and invalidates old downloads: %s", (downloaded) => {
    const template = minimaxFastTemplate();
    template.defaultSteps = 6;
    const oldUrls = {
      transformer: "https://huggingface.co/datasets/jacokon/fasth3-live/resolve/main/minimax_h3_fl2va_fasth3_dense_pruned_int8_convrot.safetensors",
      videoVae: minimaxOriginalTemplate().paths.videoVae.replace("/blob/", "/resolve/"),
    };
    for (const field of ["transformer", "videoVae"] as const) {
      const downloadedPath = `D:/Models/old-${field}.safetensors`;
      template.paths[field] = downloaded ? downloadedPath : oldUrls[field];
      template.sources![field]![0] = { ...template.sources![field]![0], url: oldUrls[field],
        ...(downloaded ? { downloadedPath } : {}) };
    }
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 8 }));
    const settings = loadGeneratorTemplateSettings();
    expect(generatorOwned(settings.templates)).toEqual(generatorOwned([minimaxFastTemplate(), mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(settings.catalogVersion).toBe(23);
    expect(templateNeedsDownload(settings.templates[0])).toBe(true);
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
  });

  it.each([false, true])("migrates the FastH3 Omni name and transformer without reusing old downloaded weights (downloaded: %s)", (downloaded) => {
    const template = minimaxFastTemplate();
    const oldUrl = "https://huggingface.co/FastVideo/FastVideo-FastH3-Comfy/resolve/main/diffusion_models/fastvideo_fasth3_8step_v2_pruned_int8_convrot.safetensors";
    template.name = "First/Last Frame Fast";
    template.paths.transformer = downloaded ? "D:/weights/fast-old.safetensors" : oldUrl.replace("/resolve/", "/blob/");
    template.sources!.transformer = [{ url: oldUrl.replace("/resolve/", "/blob/"), gpuModel: "RTX 5090", minVramGb: 24,
      ...(downloaded ? { downloadedPath: template.paths.transformer } : {}) }];
    const otherPaths = { ...template.paths };
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 10 }));
    const settings = loadGeneratorTemplateSettings();
    expect(settings.catalogVersion).toBe(23);
    expect(settings.templates).toHaveLength(9);
    expect(settings.templates[0]).toMatchObject({ id: template.id, name: "FastH3 Omni", defaultSteps: 8,
      paths: { ...otherPaths, transformer: minimaxFastTemplate().paths.transformer },
      sources: { transformer: [{ url: minimaxFastTemplate().paths.transformer, gpuModel: "RTX 5090", minVramGb: 24 }, minimaxFastTemplate().sources!.transformer![1]] } });
    expect(settings.templates[0].sources!.transformer![0].downloadedPath).toBeUndefined();
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
  });

  it.each(["url", "downloaded", "primary", "custom"])("migrates the First/Last Frame fallback from %s without changing other generators", (selection) => {
    const template = minimaxOriginalTemplate();
    const expectedUrl = "https://huggingface.co/Winnougan/MiniMax-H3-INT4_Convrot_ComfyUI/resolve/main/minimax_h3_fl2va_pruned-w4a8_convrot_pruned.safetensors";
    const oldFallback = { ...minimaxReferencesTemplate().sources!.transformer![1], downloadedPath: "D:/weights/ref2va.safetensors" };
    template.sources!.transformer = [template.sources!.transformer![0], oldFallback];
    template.paths.transformer = selection === "url" ? oldFallback.url.replace("/resolve/", "/blob/")
      : selection === "downloaded" ? oldFallback.downloadedPath : selection === "custom" ? "D:/custom.safetensors" : template.paths.transformer;
    const previousPath = template.paths.transformer;
    template.name = "My first/last generator";
    template.defaultSteps = 12;
    const references = minimaxReferencesTemplate(), fast = minimaxFastTemplate();
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template, references, fast], catalogVersion: 12 }));
    const settings = loadGeneratorTemplateSettings();
    const migrated = settings.templates[0];
    expect(migrated.sources!.transformer).toContainEqual({ url: expectedUrl, gpuModel: "", minVramGb: 13 });
    expect(migrated.sources!.transformer!.some((source) => source.url.includes("ref2va") || source.downloadedPath === oldFallback.downloadedPath)).toBe(false);
    expect(migrated.paths.transformer).toBe(selection === "url" || selection === "downloaded" ? expectedUrl : previousPath);
    expect(migrated.name).toBe(template.name);
    expect(migrated.defaultSteps).toBe(12);
    expect(generatorOwned(settings.templates.slice(1))).toEqual(generatorOwned([references, fast, fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
  });

  it.each(["url", "downloaded", "cached omni", "custom", "fallback only"])("removes the FastH3 fallback from saved settings using %s", (selection) => {
    const template = minimaxFastTemplate();
    const omniUrl = template.paths.transformer;
    const fallback = { ...minimaxReferencesTemplate().sources!.transformer![1], downloadedPath: "D:/weights/ref2va.safetensors" };
    template.name = "My Omni";
    template.defaultSteps = 12;
    template.paths = { transformer: selection === "url" ? fallback.url.replace("/resolve/", "/blob/") : selection === "custom" ? "D:/custom.safetensors" : fallback.downloadedPath,
      textEncoder: "encoder", videoVae: "video", audioVae: "audio", tokenizer: "" };
    template.sources!.transformer = [
      ...(selection === "fallback only" ? [] : [{ url: omniUrl, gpuModel: "", minVramGb: 21, ...(selection === "cached omni" ? { downloadedPath: "D:/weights/omni.safetensors" } : {}) }]),
      fallback,
      { url: "https://example.com/custom.safetensors", gpuModel: "Custom GPU", minVramGb: 8 },
    ];
    const original = minimaxOriginalTemplate(), references = minimaxReferencesTemplate();
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template, original, references], defaultTemplateId: template.id, catalogVersion: 11 }));
    const settings = loadGeneratorTemplateSettings();
    const migrated = settings.templates[0];
    expect(migrated.name).toBe("My Omni");
    expect(migrated.defaultSteps).toBe(12);
    expect(migrated.sources!.transformer!.map((source) => source.url)).not.toContain(fallback.url);
    expect(migrated.sources!.transformer).toContainEqual(expect.objectContaining({ url: omniUrl, gpuModel: "", minVramGb: 22 }));
    expect(migrated.sources!.transformer).toContainEqual({ url: "https://example.com/custom.safetensors", gpuModel: "Custom GPU", minVramGb: 8 });
    expect(migrated.paths.transformer).toBe(selection === "custom" ? "D:/custom.safetensors" : selection === "cached omni" ? "D:/weights/omni.safetensors" : omniUrl);
    expect(settings.defaultTemplateId).toBe(selection === "custom" || selection === "cached omni" ? template.id : "");
    expect(generatorOwned(settings.templates.slice(1))).toEqual(generatorOwned([original, references, fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
  });

  it("preserves custom Fast names, weights, steps and removed templates during the Omni upgrade", () => {
    const template = minimaxFastTemplate();
    template.name = "My fast generator";
    template.defaultSteps = 12;
    template.paths.transformer = "D:/custom/model.safetensors";
    template.sources!.transformer = [{ url: "https://example.com/custom.safetensors", downloadedPath: template.paths.transformer, gpuModel: "", minVramGb: 0 }];
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 10 }));
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([template, fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    const other = createGeneratorTemplate("Custom");
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [other], defaultTemplateId: other.id, catalogVersion: 10 }));
    const settings = loadGeneratorTemplateSettings();
    expect(generatorOwned(settings.templates)).toEqual(generatorOwned([other, fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    expect(settings.defaultTemplateId).toBe(other.id);
  });

  it("preserves customized Fast models and steps, and does not restore a removed template", () => {
    const template = minimaxFastTemplate();
    template.defaultSteps = 12;
    template.paths.transformer = "D:/Models/custom-transformer.safetensors";
    template.paths.videoVae = "https://example.com/custom-vae.safetensors";
    template.sources = { ...template.sources, videoVae: [{ url: template.paths.videoVae, gpuModel: "", minVramGb: 0 }] };
    delete template.sources.transformer;
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 8 }));
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([template, mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
    const original = minimaxOriginalTemplate();
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [original], catalogVersion: 8 }));
    expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([original, mossImageTemplate(), fiboImageTemplate(), fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
  });

  it.each(["textEncoder", "transformer"] as const)("upgrades saved Minimax %s variants once and preserves downloaded weights", (field) => {
    const template = minimaxOriginalTemplate();
    const downloadedPath = "D:/Models/encoder.safetensors";
    template.sources![field] = [{ url: template.paths[field], gpuModel: "", minVramGb: 0, downloadedPath }];
    template.paths[field] = downloadedPath;
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 1 }));
    const settings = loadGeneratorTemplateSettings();
    expect(settings.catalogVersion).toBe(23);
    expect(settings.templates[0].paths[field]).toBe(downloadedPath);
    expect(settings.templates[0].sources![field]).toEqual(minimaxOriginalTemplate().sources![field]!.map((source, index) =>
      index === 0 ? { ...source, downloadedPath } : source));
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
  });

  it.each(["textEncoder", "transformer"] as const)("preserves custom Minimax %s variants and does not restore a removed catalog template", (field) => {
    const template = minimaxOriginalTemplate();
    template.paths[field] = "https://example.com/custom.safetensors";
    template.sources![field] = [{ url: template.paths[field], gpuModel: "", minVramGb: 0 }];
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 1 }));
    expect(loadGeneratorTemplateSettings().templates[0].sources![field]).toEqual(template.sources![field]);
    const custom = createGeneratorTemplate();
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [custom], catalogVersion: 1 }));
    expect(loadGeneratorTemplateSettings().templates.map(({ id }) => id)).toEqual([custom.id, "minimax-h3-references", "minimax-h3-fast", "minimax-h3-singularity", "viggle-animate", "moss-image", "fibo2-edit-turbo", "fibo2-base", "yue2", "minimax_music3", "krea2-turbo", "krea2-raw", "minimax-h3-singularity-v2", "minimax-h3-image"]);
  });

  it.each(["url", "downloaded", "original", "custom", "cached original"])("removes the incompatible encoder from saved templates using %s", (selection) => {
    const template = minimaxOriginalTemplate();
    const originalUrl = template.paths.textEncoder;
    const removedUrl = "https://huggingface.co/Merserk/qwen3vl-4b-int4-convrot/resolve/main/qwen3vl_4b_int4_convrot.safetensors";
    const downloadedPath = "D:/Models/qwen3vl_4b_int4_convrot.safetensors";
    const cachedOriginal = "D:/Models/original.safetensors";
    const custom = { url: "https://example.com/custom.safetensors", gpuModel: "RTX", minVramGb: 8 };
    template.sources!.textEncoder = [
      { url: originalUrl, gpuModel: "", minVramGb: 13, ...(selection === "cached original" ? { downloadedPath: cachedOriginal } : {}) },
      { url: removedUrl, gpuModel: "", minVramGb: 0, downloadedPath },
      custom,
    ];
    template.paths = { transformer: "transformer", videoVae: "video", audioVae: "audio", tokenizer: "",
      textEncoder: selection === "url" ? removedUrl : selection === "original" ? cachedOriginal : selection === "custom" ? "D:/Models/custom.safetensors" : downloadedPath };
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], defaultTemplateId: template.id, catalogVersion: 2 }));
    const settings = loadGeneratorTemplateSettings();
    const migrated = settings.templates[0];
    expect(settings.catalogVersion).toBe(23);
    expect(migrated.sources!.textEncoder).toEqual([
      { url: originalUrl, gpuModel: "", minVramGb: 16, ...(selection === "cached original" ? { downloadedPath: cachedOriginal } : {}) },
      custom,
    ]);
    expect(migrated.paths.textEncoder).toBe(selection === "url" || selection === "downloaded" ? originalUrl
      : selection === "custom" ? "D:/Models/custom.safetensors" : cachedOriginal);
    expect(templateNeedsDownload(migrated)).toBe(selection === "url" || selection === "downloaded");
    expect(settings.defaultTemplateId).toBe(templateNeedsDownload(migrated) ? "" : template.id);
    expect(loadGeneratorTemplateSettings()).toEqual(settings);
  });

  it("restores the original encoder when only the removed URL was saved", () => {
    const template = minimaxOriginalTemplate();
    const originalUrl = template.paths.textEncoder;
    template.paths.textEncoder = "https://huggingface.co/Merserk/qwen3vl-4b-int4-convrot/resolve/main/qwen3vl_4b_int4_convrot.safetensors";
    delete template.sources!.textEncoder;
    localStorage.setItem("slopus.generator-templates.v1", JSON.stringify({ templates: [template], catalogVersion: 2 }));
    const migrated = loadGeneratorTemplateSettings().templates[0];
    expect(migrated.paths.textEncoder).toBe(originalUrl);
    expect(migrated.sources!.textEncoder).toEqual(minimaxOriginalTemplate().sources!.textEncoder);
  });

  it("passes the default generator's attention and machine backend to the engine", () => {
    const template = createGeneratorTemplate();
    expect(template.attention).toBe("sage2");
    expect(loadInferenceBackend()).toBe("cuda");
    for (const attention of ["exact", "flash2", "sage2", "sol"] as const) {
      template.attention = attention;
      saveGeneratorTemplateSettings({ templates: [template], defaultTemplateId: template.id });
      for (const inferenceBackend of ["cuda", "vulkan"] as const) {
        saveInferenceBackend(inferenceBackend);
        expect(engineProviderSetting(loadEngineSettings()).options).toMatchObject({ attention, inferenceBackend });
      }
    }
  });

  it("uses the selected default template for engine paths and step defaults", () => {
    const fast = createGeneratorTemplate("Fast draft");
    fast.defaultSteps = 8;
    fast.paths.transformer = "D:\\Models\\fast.safetensors";
    saveGeneratorTemplateSettings({ templates: [createGeneratorTemplate("Quality"), fast], defaultTemplateId: fast.id });

    expect(loadEngineSettings().transformer).toBe("D:\\Models\\fast.safetensors");
    expect(loadDefaultGenerationSteps()).toBe(8);
  });
});

describe("machine prompt LLM settings", () => {
  beforeEach(() => localStorage.clear());

  it("only exposes endpoint providers after their required settings are complete", () => {
    const settings = loadAgentEndpointSettings();
    expect(agentEndpointProviderSettings()).toEqual({});

    settings.openrouter.model = "openai/gpt-test";
    saveAgentEndpointSettings(settings);
    expect(agentEndpointProviderSettings()).toEqual({});

    settings.openrouter.apiKey = "sk-or-test";
    saveAgentEndpointSettings(settings);
    expect(agentEndpointProviderSettings().openrouter).toMatchObject({
      enabled: true,
      model: "openai/gpt-test",
      options: { endpoint: "https://openrouter.ai/api/v1", apiKey: "sk-or-test" },
    });

    settings.local = { endpoint: "http://localhost:1234/v1", apiKey: "", model: "local-model" };
    saveAgentEndpointSettings(settings);
    expect(agentEndpointProviderSettings().local).toMatchObject({
      model: "local-model",
      options: { endpoint: "http://localhost:1234/v1" },
    });
  });
});

it("adds Base once and persists per-template editing through runtime options", () => {
  const edit = fiboImageTemplate();
  edit.defaultSteps = 8;
  saveGeneratorTemplateSettings({ templates: [edit], defaultTemplateId: "", catalogVersion: 14 });
  const migrated = loadGeneratorTemplateSettings();
  expect(generatorOwned(migrated.templates)).toEqual(generatorOwned([edit, fiboBaseTemplate(), ...musicTemplates(), ...kreaImageTemplates(), minimaxSingularityV2Template(), minimaxImageTemplate()]));
  expect(loadGeneratorTemplateSettings()).toEqual(migrated);
  const base = migrated.templates[1];
  expect(base.name).toBe("Fibo 2.0 Base");
  expect(base.paths.transformer).toBe("https://huggingface.co/Comfy-Org/Fibo-2.0/resolve/main/diffusion_models/fibo2_dev_int8_convrot.safetensors");
  expect(base.sources!.transformer![0].url).toBe(base.paths.transformer);
  expect(base.paths.textEncoder).toBe(edit.paths.textEncoder);
  expect(base.paths.videoVae).toBe(edit.paths.videoVae);
  expect(templateSupportsEditing(base)).toBe(false);
  expect(templateSupportsOutpainting(base)).toBe(false);
  expect(templateSupportsOutpainting(edit)).toBe(true);
  expect(templateSupportsEditing({ ...edit, editingModel: false })).toBe(false);
  expect(templateSupportsEditing({ ...mossImageTemplate(), editingModel: true })).toBe(false);
  expect(templateSupportsEditing({ ...edit, editingModel: undefined })).toBe(true);
  const provider = engineProviderSetting(base.paths, undefined, base.attention, [], "prompt", [], false, base.sources, base);
  expect(provider.options.editingModel).toBe(false);
  saveGeneratorTemplateSettings({ ...migrated, templates: [{ ...edit, editingModel: false }] });
  expect(generatorOwned(loadGeneratorTemplateSettings().templates)).toEqual(generatorOwned([{ ...edit, editingModel: false }]));
});