@bendyline/gezel-inference 1.0.5 → 1.0.7

package/dist/providers/image/sd-cpp.js

@@ -19,13 +19,13 @@ import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
 import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createAwakeTimeout, createLogger, imageModelDefaultSide } from '@bendyline/gezel';
-import { resolveModelDirectory } from '../../models/model-id.js';
-import { MODEL_HASH_READ_BUFFER_BYTES, assertModelStorePathSafe, findModelRoot, hashModelPayloadFiles, listOverlayModelIds, makeSharedModelReadable, modelExistsOnlyReadOnly, readOnlyModelError, verifyReadOnlyModelPayload, } from '../../models/storage-roots.js';
+import { ImageLoraPromptSchema, ImageLoraPurposeSchema, ImageLoraRenderSchema, chooseImageModel, createAwakeTimeout, createLogger, imageModelDefaultSide, } from '@bendyline/gezel';
+import { isSafeModelId, resolveModelDirectory } from '../../models/model-id.js';
+import { MODEL_HASH_READ_BUFFER_BYTES, assertModelStorePathSafe, findModelRoot, hashModelPayloadFiles, listOverlayModelIds, makeSharedModelReadable, modelExistsOnlyReadOnly, readOnlyModelError, removeModelDir, verifyReadOnlyModelPayload, } from '../../models/storage-roots.js';
 import { downloadWithRetry } from '../../utils/download-with-retry.js';
 import { readImageMeta } from '../../utils/image-meta.js';
-import { resolveImg2ImgSupport } from './img2img-support.js';
-import { ImageCapacityError, ImageGenerationCancelledError, } from './types.js';
+import { resolveImageEditCapability } from './img2img-support.js';
+import { ImageCapacityError, ImageGenerationCancelledError, ImageSourceRequiredError, } from './types.js';
 const log = createLogger('image');
 const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_SAMPLE_STEPS = 20;
@@ -56,6 +56,10 @@ export const MODEL_SAMPLE_STEP_DEFAULTS = new Map([
     // The publisher recommends 100; 50 renders the same at half the time
     // (300 s to 148 s per 1024px image on a DGX Spark, image bench 2026-10-19).
     ['iris-3b-f32', 50],
+    // The publisher recommends 40; at 20 a recolor matched it apart from a
+    // hubcap's trim, and a restyle and a two-picture composite held up, in half
+    // the time (654 s to 334 s per 1024x768 edit on an RTX Spark N1X, 2026-10-27).
+    ['qwen-image-edit-2511-q4', 20],
 ]);
 /**
  * Classifier-free guidance (CFG) scale per model, applied to the
@@ -83,6 +87,8 @@ export const MODEL_CFG_DEFAULTS = new Map([
     ['iris-3b-f32', 3],
     // The model card's recommendation; the server's 7 over-saturates it.
     ['animagine-xl-4', 5],
+    // The model card's true CFG.
+    ['qwen-image-edit-2511-q4', 4],
 ]);
 /**
  * Whether the engine runs this model with guidance that reads a negative
@@ -98,6 +104,7 @@ export const MODEL_SAMPLER_DEFAULTS = new Map([
     ['ming-image-0.1-design-bf16', 'Euler'],
     ['moss-image-sft-q4', 'Euler'],
     ['iris-3b-f32', 'Euler'],
+    ['qwen-image-edit-2511-q4', 'Euler'],
 ]);
 /**
  * Models whose VAE shows visible tile-boundary seams under
@@ -114,6 +121,17 @@ export const VAE_TILING_INCOMPATIBLE_MODELS = new Set([
     'krea-2-turbo-q4',
     'krea-2-turbo-q6',
     'krea-2-turbo-q8',
+    // The same Qwen-Image VAE file as Krea 2.
+    'qwen-image-edit-2511-q4',
+]);
+/**
+ * `--model-args` a model needs. Qwen-Image-Edit 2511 was trained with its
+ * reference latents at timestep zero; upstream warns that edits degrade
+ * badly without the flag, and the engine only infers it from a marker
+ * tensor not every quantization carries.
+ */
+const MODEL_ARGS = new Map([
+    ['qwen-image-edit-2511-q4', 'qwen_image_zero_cond_t=true'],
 ]);
 /**
  * Models that render the same with EasyCache step reuse. MOSS took 205 s per
@@ -123,7 +141,11 @@ export const VAE_TILING_INCOMPATIBLE_MODELS = new Set([
  */
 const EASYCACHE_MODELS = new Set(['moss-image-sft-q4']);
 export function sdServerLoadProfile(modelId) {
-    const stepCache = EASYCACHE_MODELS.has(modelId) ? { stepCache: 'easycache' } : {};
+    const modelArgs = MODEL_ARGS.get(modelId);
+    const extras = {
+        ...(EASYCACHE_MODELS.has(modelId) ? { stepCache: 'easycache' } : {}),
+        ...(modelArgs ? { modelArgs } : {}),
+    };
     if (modelId === 'iris-3b-f32') {
         // Iris generates pixels directly: no VAE to tile. Upstream's Iris recipe
         // enables diffusion flash attention for the 1024px sequence. The
@@ -134,7 +156,7 @@ export function sdServerLoadProfile(modelId) {
             defaultSidePx: imageModelDefaultSide(modelId),
             bf16TensorPattern: '^model\\.diffusion_model\\.',
             diffusionFlashAttention: true,
-            ...stepCache,
+            ...extras,
         };
     }
     // Tiling avoids VAE-decode OOM on large images, but produces visible
@@ -143,7 +165,7 @@ export function sdServerLoadProfile(modelId) {
         vaeDecode: VAE_TILING_INCOMPATIBLE_MODELS.has(modelId) ? 'untiled' : 'tiled',
         defaultSidePx: imageModelDefaultSide(modelId),
         diffusionFlashAttention: false,
-        ...stepCache,
+        ...extras,
     };
 }
 export class StableDiffusionCppProvider {
@@ -151,6 +173,7 @@ export class StableDiffusionCppProvider {
     baseUrl;
     modelsRoot;
     storageRoots;
+    loraRoots;
     timeoutMs;
     fetchImpl;
     supervisor;
@@ -167,6 +190,8 @@ export class StableDiffusionCppProvider {
             writableRoot: opts.modelsRoot,
             readOnlyRoots: [],
         };
+        if (opts.loraRoots)
+            this.loraRoots = opts.loraRoots;
         this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         this.fetchImpl = opts.fetchImpl ?? fetch;
         this.supervisor = opts.supervisor;
@@ -222,14 +247,39 @@ export class StableDiffusionCppProvider {
         const { signal } = input;
         if (signal?.aborted)
             throw new ImageGenerationCancelledError();
-        const modelId = input.model ?? (await this.resolveDefaultModelId());
+        const hasSources = (input.inputImages?.length ?? 0) > 0;
+        const modelId = input.model ?? (await this.chooseModel(hasSources));
+        const installed = await this.readInstalledManifestFields(modelId);
+        const capability = resolveImageEditCapability({
+            modelId,
+            explicit: installed?.supportsImg2Img,
+            weightsKind: installed?.weightsKind,
+            referenceImages: installed?.referenceImages,
+            editOnly: installed?.editOnly,
+        });
+        // An edit-only model handed nothing to edit, named or the only kind
+        // installed, fails here rather than after a launch that loads its weights.
+        if (!hasSources) {
+            const blocker = capability.editOnly
+                ? { id: modelId, name: installed?.name }
+                : modelId === undefined
+                    ? (await this.listInstalledModels()).find((m) => m.editOnly)
+                    : undefined;
+            if (blocker)
+                throw new ImageSourceRequiredError(blocker.name ?? blocker.id ?? 'This model');
+        }
         const defaultDimension = imageModelDefaultSide(modelId);
         const width = input.width ?? defaultDimension;
         const height = input.height ?? defaultDimension;
-        const steps = input.steps ?? (await this.defaultSampleSteps(modelId));
+        const resolvedLoras = await this.resolveLoras(modelId, input.loras ?? []);
+        let loras = resolvedLoras.loras;
+        // A speed LoRA's recipe is what makes its few steps valid, so it wins
+        // over a style's.
+        const render = loras.find((l) => l.purpose === 'speed')?.render ?? loras.find((l) => l.render)?.render;
+        const steps = input.steps ?? render?.steps ?? (await this.defaultSampleSteps(modelId));
         const seed = input.seed ?? Math.floor(Math.random() * 2_147_483_647);
         const started = Date.now();
-        log.info(`[sd-cpp] generate model=${modelId ?? 'default'} steps=${steps} explicitSteps=${input.steps !== undefined} size=${width}x${height}`);
+        log.info(`[sd-cpp] generate model=${modelId ?? 'default'} steps=${steps} explicitSteps=${input.steps !== undefined} size=${width}x${height}${loras.length > 0 ? ` loras=${loras.map((l) => l.id).join(',')}` : ''}`);
         // Model selection: sd-server serves one model per process. When a
         // request targets a different installed model than the one currently
         // loaded, point resolveLaunch at it (via the shared launchState) and
@@ -290,7 +340,11 @@ export class StableDiffusionCppProvider {
             // `seed`, `cfg_scale`, and `negative_prompt`, so caller overrides
             // actually take effect. `cfg_scale` is set per model (distilled /
             // Flux-flow models need CFG 1; others inherit the server default).
-            const cfg = modelId ? MODEL_CFG_DEFAULTS.get(modelId) : undefined;
+            const cfg = render?.cfg ?? (modelId ? MODEL_CFG_DEFAULTS.get(modelId) : undefined);
+            const settingsNotes = [...resolvedLoras.notes];
+            if (loras.length > 0) {
+                loras = await this.lorasTheEngineHas(baseUrl, loras, request.signal, settingsNotes);
+            }
             let inputImages = input.inputImages ?? [];
             // Capability gate: models whose architecture doesn't honor init
             // latents on the pinned sd-server fall back to txt2img instead of
@@ -299,40 +353,56 @@ export class StableDiffusionCppProvider {
             // bubble) can say so honestly.
             let img2imgSkippedReason;
             if (inputImages.length > 0) {
-                const installed = await this.readInstalledManifestFields(modelId);
-                const verdict = resolveImg2ImgSupport({
-                    modelId,
-                    explicit: installed?.supportsImg2Img,
-                    weightsKind: installed?.weightsKind,
-                });
-                if (!verdict.supported) {
-                    img2imgSkippedReason = verdict.reason ?? 'model does not support image editing (img2img)';
+                const max = capability.maxSourceImages ?? 1;
+                if (!capability.editMode) {
+                    img2imgSkippedReason =
+                        capability.reason ?? 'model does not support image editing (img2img)';
                     log.info(`[sd-cpp] dropping ${inputImages.length} input image(s): ${img2imgSkippedReason}`);
                     inputImages = [];
                 }
+                else if (inputImages.length > max) {
+                    log.info(`[sd-cpp] received ${inputImages.length} input images; ${modelId} takes ${max}`);
+                    settingsNotes.push(`Used the first ${max} of ${inputImages.length} source pictures; ${installed?.name ?? modelId} takes ${max}.`);
+                    inputImages = inputImages.slice(0, max);
+                }
             }
+            // A LoRA's trigger words or trained instruction go around the prompt
+            // here, so neither the person nor a gezel ever writes them.
+            const prompt = [
+                ...loras.map((l) => l.prompt?.prefix),
+                withoutEngineDirectives(input.prompt),
+                ...loras.map((l) => l.prompt?.suffix),
+            ]
+                .filter((part) => Boolean(part?.trim()))
+                .join(' ');
             const body = {
-                prompt: input.prompt,
-                negative_prompt: input.negativePrompt ?? '',
+                prompt,
+                negative_prompt: withoutEngineDirectives(input.negativePrompt ?? ''),
                 width,
                 height,
                 steps,
                 seed,
                 batch_size: 1,
+                // Always present: the server's `lora` field replaces any LoRA list a
+                // prompt directive slipped past the strip above.
+                lora: loras.map((l) => ({ path: `${l.id}/${l.filename}`, multiplier: l.strength })),
             };
             if (cfg !== undefined)
                 body.cfg_scale = cfg;
-            const sampler = modelId ? MODEL_SAMPLER_DEFAULTS.get(modelId) : undefined;
+            const sampler = render?.sampler ?? (modelId ? MODEL_SAMPLER_DEFAULTS.get(modelId) : undefined);
             if (sampler)
                 body.sampler_name = sampler;
+            if (render?.scheduler)
+                body.scheduler = render.scheduler;
             let endpoint = `${baseUrl}/sdapi/v1/txt2img`;
-            // Img2img: a single source image drives `/sdapi/v1/img2img` via
-            // `init_images` (base64). stable-diffusion.cpp's img2img path takes
-            // one image, so we use the first and warn for any extras.
-            if (inputImages.length > 0) {
-                if (inputImages.length > 1) {
-                    log.info(`[sd-cpp] received ${inputImages.length} input images; img2img uses the first only`);
-                }
+            if (inputImages.length > 0 && capability.editMode === 'reference') {
+                // A reference editor reads the sources beside the instruction
+                // (`extra_images` becomes the engine's ref_images) and renders
+                // from noise; `strength` has no meaning there.
+                body.extra_images = inputImages.map((image) => Buffer.from(image.data).toString('base64'));
+            }
+            else if (inputImages.length > 0) {
+                // Img2img: one source drives `/sdapi/v1/img2img` via `init_images`.
                 const first = inputImages[0];
                 body.init_images = [Buffer.from(first.data).toString('base64')];
                 if (typeof input.strength === 'number')
@@ -395,6 +465,8 @@ export class StableDiffusionCppProvider {
                     heightPx: rendered?.height || height,
                     durationMs: Date.now() - started,
                     ...(img2imgSkippedReason ? { img2imgSkippedReason } : {}),
+                    ...(settingsNotes.length > 0 ? { settingsNotes } : {}),
+                    ...(loras.length > 0 ? { loras: loras.map((l) => ({ id: l.id, name: l.name })) } : {}),
                 },
             };
         }
@@ -415,6 +487,7 @@ export class StableDiffusionCppProvider {
     async listInstalledModels() {
         const entries = await listOverlayModelIds(this.storageRoots);
         const out = [];
+        const installedLoras = await this.listLoras();
         for (const id of entries) {
             const root = await findModelRoot(this.storageRoots, id);
             if (!root)
@@ -428,6 +501,13 @@ export class StableDiffusionCppProvider {
                 if (!(await verifyReadOnlyModelPayload(this.storageRoots, root, id, parsed.fileSha256))) {
                     continue;
                 }
+                const capability = resolveImageEditCapability({
+                    modelId: parsed.id,
+                    explicit: parsed.supportsImg2Img,
+                    weightsKind: parsed.weightsKind,
+                    referenceImages: parseReferenceImages(parsed.referenceImages),
+                    editOnly: typeof parsed.editOnly === 'boolean' ? parsed.editOnly : undefined,
+                });
                 out.push({
                     id: parsed.id,
                     name: parsed.name,
@@ -437,6 +517,11 @@ export class StableDiffusionCppProvider {
                     ...(typeof parsed.supportsImg2Img === 'boolean'
                         ? { supportsImg2Img: parsed.supportsImg2Img }
                         : {}),
+                    ...(capability.editMode
+                        ? { editMode: capability.editMode, maxSourceImages: capability.maxSourceImages }
+                        : {}),
+                    ...(capability.editOnly ? { editOnly: true } : {}),
+                    ...lorasFitting(installedLoras, parsed.id),
                 });
             }
             catch {
@@ -446,6 +531,147 @@ export class StableDiffusionCppProvider {
         out.sort((a, b) => a.name.localeCompare(b.name));
         return out;
     }
+    /** Installed LoRAs, from the root the engine reads; none when this engine takes none. */
+    async listLoras() {
+        if (!this.loraRoots)
+            return [];
+        const out = [];
+        for (const lora of await readInstalledLoras(this.loraRoots.writableRoot)) {
+            out.push({
+                id: lora.id,
+                name: lora.name,
+                purpose: lora.purpose,
+                ...(lora.render?.steps !== undefined ? { steps: lora.render.steps } : {}),
+                baseModels: lora.baseModels,
+                approxSizeBytes: lora.approxSizeBytes,
+                installedAt: lora.installedAt,
+            });
+        }
+        return out.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Install one LoRA: a single safetensors file, sha256-checked like a model,
+     * beside a `manifest.json` that keeps the catalog's recipe so the engine can
+     * apply it without the catalog.
+     */
+    async *pullLora(id, spec, signal) {
+        const fail = (error) => [
+            { type: 'error', error },
+            { type: 'done', id },
+        ];
+        // A fixed short name, not the upstream one: sd-server lists a file it
+        // cannot open past Windows' 260-character path limit, then draws without
+        // it, so a long name in a deep home made a style silently do nothing.
+        const filename = 'lora.safetensors';
+        if (!this.loraRoots) {
+            yield* fail('This image engine does not take styles or fast mode.');
+            return;
+        }
+        if (!isSafeModelId(id) || !/\.safetensors$/i.test(extractFilename(spec.downloadUrl))) {
+            yield* fail('Styles and fast mode install only as safetensors files.');
+            return;
+        }
+        const root = this.loraRoots.writableRoot;
+        const itemDir = join(root, id);
+        await mkdir(root, { recursive: true });
+        await assertModelStorePathSafe(root, itemDir);
+        await mkdir(itemDir, { recursive: true });
+        await assertModelStorePathSafe(root, itemDir);
+        const result = yield* this.downloadFile({
+            url: spec.downloadUrl,
+            destPath: join(itemDir, filename),
+            expectedSha256: spec.sha256,
+            approxSizeBytes: spec.approxSizeBytes,
+            writtenSoFar: 0,
+            totalAllBytes: spec.approxSizeBytes,
+            // The size is pinned beside the sha256: nothing larger is this file.
+            maxBytes: spec.approxSizeBytes + 1024 * 1024,
+            ...(signal ? { signal } : {}),
+        });
+        if (result.kind === 'error') {
+            yield* fail(result.error);
+            return;
+        }
+        await writeFile(join(itemDir, 'manifest.json'), JSON.stringify({
+            id,
+            name: spec.name,
+            filename,
+            approxSizeBytes: result.actualSize,
+            sha256: spec.sha256.toLowerCase(),
+            baseModels: spec.baseModels,
+            purpose: spec.purpose,
+            strength: spec.strength,
+            ...(spec.prompt ? { prompt: spec.prompt } : {}),
+            ...(spec.render ? { render: spec.render } : {}),
+            fileSha256: await hashModelPayloadFiles(itemDir),
+            installedAt: new Date().toISOString(),
+        }, null, 2), 'utf8');
+        await makeSharedModelReadable(itemDir);
+        yield { type: 'progress', bytesWritten: result.writtenAll, totalBytes: spec.approxSizeBytes };
+        yield { type: 'done', id };
+    }
+    async deleteLora(id) {
+        if (!this.loraRoots)
+            return;
+        const root = this.loraRoots.writableRoot;
+        await removeModelDir(resolveModelDirectory(root, id), root);
+    }
+    /**
+     * The LoRAs a render asked for that this engine can apply to `modelId`:
+     * installed in the root the engine reads and checked on that model. The
+     * rest are dropped with a note, never an error.
+     */
+    async resolveLoras(modelId, requested) {
+        if (requested.length === 0)
+            return { loras: [], notes: [] };
+        if (!this.loraRoots) {
+            return { loras: [], notes: ['This image engine takes no styles or fast mode.'] };
+        }
+        const loras = [];
+        const notes = [];
+        for (const { id } of requested) {
+            if (loras.some((l) => l.id === id))
+                continue;
+            const lora = await this.readInstalledLora(id);
+            if (!lora) {
+                notes.push(`${id} is not installed here, so the picture was drawn without it.`);
+            }
+            else if (!modelId || !lora.baseModels.includes(modelId)) {
+                notes.push(`${lora.name} does not fit ${modelId ?? 'this model'}, so it was left out.`);
+            }
+            else {
+                loras.push(lora);
+            }
+        }
+        return { loras, notes };
+    }
+    /**
+     * Keep the LoRAs the running engine can see. sd-server fills its LoRA list
+     * only when it is asked for it, and answers `invalid lora path` for any LoRA
+     * named before then, so the list is read before every LoRA render.
+     */
+    async lorasTheEngineHas(baseUrl, loras, signal, notes) {
+        let listed;
+        try {
+            const res = await this.fetchImpl(`${baseUrl}/sdapi/v1/loras`, { signal });
+            const body = res.ok ? (await res.json()) : [];
+            listed = new Set((Array.isArray(body) ? body : []).flatMap((e) => typeof e.path === 'string' ? [e.path] : []));
+        }
+        catch (err) {
+            if (signal.aborted)
+                throw err;
+            listed = new Set();
+        }
+        return loras.filter((l) => {
+            if (listed.has(`${l.id}/${l.filename}`))
+                return true;
+            notes.push(`The image engine could not load ${l.name}, so it was left out.`);
+            return false;
+        });
+    }
+    async readInstalledLora(id) {
+        return this.loraRoots ? readInstalledLora(this.loraRoots.writableRoot, id) : undefined;
+    }
     async *pullModel(id, spec, signal) {
         const itemDir = join(this.modelsRoot, id);
         await mkdir(this.modelsRoot, { recursive: true });
@@ -506,6 +732,8 @@ export class StableDiffusionCppProvider {
             weightsFilename,
             weightsKind: spec.weightsKind,
             ...(spec.supportsImg2Img !== undefined ? { supportsImg2Img: spec.supportsImg2Img } : {}),
+            ...(spec.referenceImages ? { referenceImages: spec.referenceImages } : {}),
+            ...(spec.editOnly !== undefined ? { editOnly: spec.editOnly } : {}),
             weightsSizeBytes: weightsActualSize,
             sha256: spec.sha256.toLowerCase(),
             auxiliaryFiles: auxiliaryRecords,
@@ -535,6 +763,7 @@ export class StableDiffusionCppProvider {
             destPath,
             approxSizeBytes,
             fetchImpl: this.fetchImpl,
+            ...(opts.maxBytes !== undefined ? { maxBytes: opts.maxBytes } : {}),
             ...(signal ? { signal } : {}),
         });
         let writtenThisFile = 0;
@@ -665,16 +894,19 @@ export class StableDiffusionCppProvider {
         await this.supervisor?.stop();
     }
     /**
-     * The configured default when it is installed, else the first installed
-     * model id, else undefined. Stable ordering matches
-     * {@link listInstalledModels} so the default is deterministic.
+     * The model a fresh picture renders with: the configured default when it
+     * is installed and draws, else the first installed model that draws. Stable
+     * ordering matches {@link listInstalledModels} so the default is
+     * deterministic.
      */
     async resolveDefaultModelId() {
-        const models = await this.listInstalledModels();
-        if (this.defaultModelId && models.some((m) => m.id === this.defaultModelId)) {
-            return this.defaultModelId;
-        }
-        return models[0]?.id;
+        return this.chooseModel(false);
+    }
+    async chooseModel(hasSources) {
+        return chooseImageModel(await this.listInstalledModels(), {
+            defaultModelId: this.defaultModelId,
+            hasSources,
+        });
     }
     async defaultSampleSteps(modelId) {
         if (!modelId)
@@ -703,7 +935,9 @@ export class StableDiffusionCppProvider {
                 return null;
             const raw = await readFile(join(root, modelId, 'manifest.json'), 'utf8');
             const parsed = JSON.parse(raw);
+            const referenceImages = parseReferenceImages(parsed.referenceImages);
             return {
+                ...(typeof parsed.name === 'string' ? { name: parsed.name } : {}),
                 ...(typeof parsed.recommendedSteps === 'number'
                     ? { recommendedSteps: parsed.recommendedSteps }
                     : {}),
@@ -713,6 +947,8 @@ export class StableDiffusionCppProvider {
                 ...(typeof parsed.supportsImg2Img === 'boolean'
                     ? { supportsImg2Img: parsed.supportsImg2Img }
                     : {}),
+                ...(referenceImages ? { referenceImages } : {}),
+                ...(typeof parsed.editOnly === 'boolean' ? { editOnly: parsed.editOnly } : {}),
             };
         }
         catch {
@@ -742,6 +978,93 @@ const RECENT_ENGINE_LINES = 40;
  * answers the request with a bare `generate_image returned no results`.
  */
 const ENGINE_MEMORY_SHORTFALL = /cannot make enough memory available|out of (?:device )?memory|ErrorOutOfDeviceMemory|failed to allocate/i;
+/**
+ * sd-server reads `<sd_cpp_extra_args>{json}</sd_cpp_extra_args>` out of a
+ * prompt and applies the JSON as generation parameters, including LoRA and
+ * ADetailer model paths it never checks. Prompts come from gezels reading
+ * untrusted content and from other apps, so the tag never reaches the engine.
+ * Repeated until stable: removing one tag can join the pieces around it into
+ * another.
+ */
+export function withoutEngineDirectives(text) {
+    const tag = /<\s*\/?\s*sd_cpp_extra_args\s*>/gi;
+    let out = text;
+    let previous;
+    do {
+        previous = out;
+        out = out.replace(tag, '');
+    } while (out !== previous);
+    return out;
+}
+/**
+ * Read an installed LoRA's manifest, or nothing when it is malformed. The
+ * filename must be a bare `.safetensors` name: the engine resolves it inside
+ * its LoRA folder, and it also loads pickle files.
+ */
+function parseInstalledLora(id, raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const m = raw;
+    const purpose = ImageLoraPurposeSchema.safeParse(m.purpose);
+    if (typeof m.name !== 'string' ||
+        typeof m.filename !== 'string' ||
+        !/^[^/\\]+\.safetensors$/i.test(m.filename) ||
+        !purpose.success ||
+        !Array.isArray(m.baseModels)) {
+        return undefined;
+    }
+    const prompt = ImageLoraPromptSchema.safeParse(m.prompt);
+    const render = ImageLoraRenderSchema.safeParse(m.render);
+    return {
+        id,
+        name: m.name,
+        filename: m.filename,
+        purpose: purpose.data,
+        strength: typeof m.strength === 'number' && m.strength > 0 ? m.strength : 1,
+        baseModels: m.baseModels.filter((b) => typeof b === 'string'),
+        ...(m.prompt !== undefined && prompt.success ? { prompt: prompt.data } : {}),
+        ...(m.render !== undefined && render.success ? { render: render.data } : {}),
+        approxSizeBytes: typeof m.approxSizeBytes === 'number' ? m.approxSizeBytes : 0,
+        installedAt: typeof m.installedAt === 'string' ? m.installedAt : '',
+    };
+}
+async function readInstalledLora(loraRoot, id) {
+    if (!isSafeModelId(id))
+        return undefined;
+    try {
+        const raw = await readFile(join(loraRoot, id, 'manifest.json'), 'utf8');
+        return parseInstalledLora(id, JSON.parse(raw));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Every LoRA installed under `loraRoot`, skipping malformed ones. */
+export async function readInstalledLoras(loraRoot) {
+    const ids = await listOverlayModelIds({ writableRoot: loraRoot, readOnlyRoots: [] }).catch(() => []);
+    const out = [];
+    for (const id of ids) {
+        const lora = await readInstalledLora(loraRoot, id);
+        if (lora)
+            out.push(lora);
+    }
+    return out;
+}
+function lorasFitting(installed, modelId) {
+    const loras = installed
+        .filter((l) => l.baseModels.includes(modelId))
+        .map(({ id, name, purpose, steps }) => ({
+        id,
+        name,
+        purpose,
+        ...(steps !== undefined ? { steps } : {}),
+    }));
+    return loras.length > 0 ? { loras } : {};
+}
+function parseReferenceImages(value) {
+    const max = value?.max;
+    return typeof max === 'number' && Number.isInteger(max) && max > 0 ? { max } : undefined;
+}
 function emitProgress(input, progress) {
     try {
         input.onProgress?.(progress);