genai-electron 0.9.0 → 0.11.0

package/dist/managers/DiffusionServerManager.js

@@ -6,11 +6,12 @@ import { ResourceOrchestrator } from './ResourceOrchestrator.js';
 import { GenerationRegistry } from './GenerationRegistry.js';
 import http from 'node:http';
 import { promises as fs } from 'node:fs';
-import { getTempPath, PATHS } from '../config/paths.js';
-import { BINARY_VERSIONS, DEFAULT_PORTS, DIFFUSION_VRAM_THRESHOLDS, DIFFUSION_COMPONENT_FLAGS, DIFFUSION_COMPONENT_ORDER, } from '../config/defaults.js';
+import { getTempPath } from '../config/paths.js';
+import { BINARY_VERSIONS, DEFAULT_PORTS, DIFFUSION_VRAM_THRESHOLDS, DIFFUSION_COMPONENT_FLAGS, DIFFUSION_COMPONENT_ORDER, DIFFUSION_CALIBRATION_DEFAULTS, } from '../config/defaults.js';
 import { deleteFile } from '../utils/file-utils.js';
+import { debugLog } from '../utils/debug-log.js';
 import { findFreePort } from '../process/port-utils.js';
-import { ServerError, ModelNotFoundError, InsufficientResourcesError } from '../errors/index.js';
+import { GenaiElectronError, ServerError, ModelNotFoundError, InsufficientResourcesError, } from '../errors/index.js';
 export class DiffusionServerManager extends ServerManager {
     static VALID_CONFIG_FIELDS = new Set([
         'modelId',
@@ -34,6 +35,8 @@ export class DiffusionServerManager extends ServerManager {
     currentGeneration;
     activeGeneration;
     currentModelInfo;
+    lastResolvedOptimizations;
+    calibrating = false;
     modelLoadTime = 2000;
     diffusionTimePerStepPerMegapixel = 1000;
     vaeTimePerMegapixel = 8000;
@@ -71,6 +74,11 @@ export class DiffusionServerManager extends ServerManager {
                 suggestion: 'Stop the server first with stop()',
             });
         }
+        if (this.calibrating) {
+            throw new ServerError('Cannot start server while offload calibration is in progress', {
+                suggestion: 'Wait for calibrate() to finish, or abort it via its AbortSignal',
+            });
+        }
         this.validateConfigFields(config, DiffusionServerManager.VALID_CONFIG_FIELDS, 'DiffusionServerManager');
         this.setStatus('starting');
         this._config = config;
@@ -173,6 +181,389 @@ export class DiffusionServerManager extends ServerManager {
         }
         await this.logManager?.write(`Generation ${id} cancelled`, 'info');
     }
+    async calibrate(config) {
+        if (this._status !== 'stopped') {
+            throw new ServerError('Cannot calibrate while the server is running', {
+                suggestion: 'Stop the server with stop() before calibrating',
+            });
+        }
+        if (this.calibrating) {
+            throw new ServerError('Calibration is already in progress', {
+                suggestion: 'Wait for the current calibrate() call to finish',
+            });
+        }
+        const defaults = DIFFUSION_CALIBRATION_DEFAULTS;
+        const sizes = config.sizes && config.sizes.length > 0 ? config.sizes : [...defaults.sizes];
+        for (const size of sizes) {
+            if (!Number.isInteger(size.width) ||
+                !Number.isInteger(size.height) ||
+                size.width <= 0 ||
+                size.height <= 0 ||
+                size.width % 64 !== 0 ||
+                size.height % 64 !== 0) {
+                throw new ServerError(`Invalid calibration size ${size.width}x${size.height}: dimensions must be positive multiples of 64`, { suggestion: 'Use sd.cpp-compatible dimensions, e.g. 512x512, 768x768, 512x1024' });
+            }
+        }
+        const samples = Math.max(1, Math.floor(config.samples ?? defaults.samples));
+        const steps = config.steps ?? defaults.steps;
+        const seed = config.seed ?? defaults.seed;
+        const sampler = config.sampler ?? defaults.sampler;
+        const prompt = config.prompt ?? defaults.prompt;
+        const runs = [];
+        if (config.signal?.aborted) {
+            throw this.calibrationAbortError(runs);
+        }
+        this.calibrating = true;
+        const savedConfig = this._config;
+        const savedModelInfo = this.currentModelInfo;
+        const savedBinaryPath = this.binaryPath;
+        const abortListener = () => {
+            this.currentGeneration?.cancel();
+        };
+        config.signal?.addEventListener('abort', abortListener);
+        let emitFn;
+        let comboCountForProgress = 0;
+        let lastOverallPercent = 0;
+        let succeeded = false;
+        try {
+            const modelInfo = await this.modelManager.getModelInfo(config.modelId);
+            if (modelInfo.type !== 'diffusion') {
+                throw new ModelNotFoundError(`Model ${config.modelId} is not a diffusion model (type: ${modelInfo.type})`);
+            }
+            const requestedCombos = (config.combos && config.combos.length > 0 ? config.combos : defaults.combos).map((combo) => ({ ...combo }));
+            const skippedCombos = [];
+            let combos = requestedCombos;
+            if (defaults.sd35LargePattern.test(modelInfo.id) ||
+                defaults.sd35LargePattern.test(modelInfo.name)) {
+                combos = requestedCombos.filter((combo) => {
+                    if (combo.clipOnCpu === true) {
+                        skippedCombos.push({
+                            combo,
+                            reason: 'SD3.5-Large produces garbled output with --clip-on-cpu (leejet/stable-diffusion.cpp#1578)',
+                        });
+                        return false;
+                    }
+                    return true;
+                });
+            }
+            if (combos.length === 0) {
+                throw new ServerError('No offload combos left to benchmark after SD3.5-Large filtering', {
+                    skippedCombos,
+                    suggestion: 'Provide combos without clipOnCpu: true for this model',
+                });
+            }
+            comboCountForProgress = combos.length;
+            const totalUnits = combos.length * (1 + samples * sizes.length);
+            let completedUnits = 0;
+            const emit = (p) => {
+                try {
+                    config.onProgress?.(p);
+                }
+                catch (error) {
+                    debugLog('[Calibrate] onProgress callback threw:', error);
+                }
+                try {
+                    this.emit('calibration-progress', p);
+                }
+                catch (error) {
+                    debugLog('[Calibrate] calibration-progress listener threw:', error);
+                }
+            };
+            emitFn = emit;
+            const overallPercent = (generationFraction = 0) => {
+                const pct = Math.min(100, ((completedUnits + generationFraction) / totalUnits) * 100);
+                lastOverallPercent = Math.max(lastOverallPercent, pct);
+                return lastOverallPercent;
+            };
+            emit({
+                phase: 'preparing',
+                comboIndex: 0,
+                comboCount: combos.length,
+                sizeIndex: 0,
+                sizeCount: sizes.length,
+                overallPercent: 0,
+            });
+            const canRun = await this.systemInfo.canRunModel(modelInfo, { checkTotalMemory: true });
+            if (!canRun.possible) {
+                const memoryInfo = this.systemInfo.getMemoryInfo();
+                throw new InsufficientResourcesError(`System cannot run model: ${canRun.reason || 'Insufficient resources'}`, {
+                    required: `Model size: ${Math.round(modelInfo.size / 1024 / 1024 / 1024)}GB`,
+                    available: `Total RAM: ${Math.round(memoryInfo.total / 1024 / 1024 / 1024)}GB`,
+                    suggestion: canRun.suggestion || canRun.reason || 'Try a smaller model',
+                });
+            }
+            if (!this.logManager) {
+                await this.initializeLogManager('diffusion-server.log', 'Offload calibration starting');
+            }
+            void this.logManager
+                ?.write(`Calibration: model=${config.modelId}, sizes=${sizes
+                .map((s) => `${s.width}x${s.height}`)
+                .join(',')}, combos=${combos.length}${skippedCombos.length > 0 ? ` (${skippedCombos.length} skipped: SD3.5-Large)` : ''}, steps=${steps}, samples=${samples}`, 'info')
+                .catch(() => void 0);
+            this.currentModelInfo = modelInfo;
+            this.binaryPath = await this.ensureBinary(modelInfo);
+            if (config.signal?.aborted) {
+                throw this.calibrationAbortError(runs);
+            }
+            const syntheticConfig = { modelId: config.modelId };
+            if (config.threads !== undefined) {
+                syntheticConfig.threads = config.threads;
+            }
+            if (config.batchSize !== undefined) {
+                syntheticConfig.batchSize = config.batchSize;
+            }
+            this._config = syntheticConfig;
+            await this.orchestrator?.waitForReload();
+            await this.orchestrator?.offloadLLM();
+            for (let comboIndex = 0; comboIndex < combos.length; comboIndex++) {
+                const combo = combos[comboIndex];
+                const baseProgress = {
+                    comboIndex,
+                    comboCount: combos.length,
+                    combo,
+                    sizeCount: sizes.length,
+                };
+                let warmupFailure;
+                if (config.signal?.aborted) {
+                    throw this.calibrationAbortError(runs);
+                }
+                emit({
+                    phase: 'warmup',
+                    ...baseProgress,
+                    sizeIndex: 0,
+                    size: sizes[0],
+                    overallPercent: overallPercent(),
+                });
+                try {
+                    await this.runCalibrationGeneration({
+                        prompt,
+                        size: sizes[0],
+                        steps,
+                        cfgScale: config.cfgScale,
+                        seed,
+                        sampler,
+                        combo,
+                        onGenerationProgress: (pct) => emit({
+                            phase: 'warmup',
+                            ...baseProgress,
+                            sizeIndex: 0,
+                            size: sizes[0],
+                            generationPercent: pct,
+                            overallPercent: overallPercent(pct / 100),
+                        }),
+                    });
+                }
+                catch (error) {
+                    if (config.signal?.aborted) {
+                        throw this.calibrationAbortError(runs);
+                    }
+                    warmupFailure = this.classifyCalibrationFailure(error);
+                }
+                completedUnits++;
+                for (let sizeIndex = 0; sizeIndex < sizes.length; sizeIndex++) {
+                    const size = sizes[sizeIndex];
+                    const samplesMs = [];
+                    const snapshots = [];
+                    let resolved;
+                    let failure;
+                    if (sizeIndex === 0 && warmupFailure) {
+                        failure = warmupFailure;
+                        completedUnits += samples;
+                    }
+                    else {
+                        for (let sample = 1; sample <= samples; sample++) {
+                            if (config.signal?.aborted) {
+                                throw this.calibrationAbortError(runs);
+                            }
+                            emit({
+                                phase: 'sampling',
+                                ...baseProgress,
+                                sizeIndex,
+                                size,
+                                sample,
+                                sampleCount: samples,
+                                overallPercent: overallPercent(),
+                            });
+                            try {
+                                const result = await this.runCalibrationGeneration({
+                                    prompt,
+                                    size,
+                                    steps,
+                                    cfgScale: config.cfgScale,
+                                    seed,
+                                    sampler,
+                                    combo,
+                                    onGenerationProgress: (pct) => emit({
+                                        phase: 'sampling',
+                                        ...baseProgress,
+                                        sizeIndex,
+                                        size,
+                                        sample,
+                                        sampleCount: samples,
+                                        generationPercent: pct,
+                                        overallPercent: overallPercent(pct / 100),
+                                    }),
+                                });
+                                samplesMs.push(result.timeTaken);
+                                snapshots.push(this.snapshotStageMs());
+                                resolved = this.lastResolvedOptimizations
+                                    ? { ...this.lastResolvedOptimizations }
+                                    : undefined;
+                                completedUnits++;
+                            }
+                            catch (error) {
+                                if (config.signal?.aborted) {
+                                    throw this.calibrationAbortError(runs);
+                                }
+                                failure = this.classifyCalibrationFailure(error);
+                                completedUnits += samples - sample + 1;
+                                break;
+                            }
+                        }
+                    }
+                    const run = { size, combo, status: failure ? failure.status : 'ok' };
+                    if (resolved) {
+                        run.resolved = resolved;
+                    }
+                    if (samplesMs.length > 0) {
+                        run.samplesMs = samplesMs;
+                    }
+                    if (failure) {
+                        run.error = failure.message;
+                    }
+                    else {
+                        const median = medianOf(samplesMs);
+                        run.timeTakenMs = median;
+                        let bestIdx = 0;
+                        for (let i = 1; i < samplesMs.length; i++) {
+                            if (Math.abs(samplesMs[i] - median) < Math.abs(samplesMs[bestIdx] - median)) {
+                                bestIdx = i;
+                            }
+                        }
+                        const stage = snapshots[bestIdx];
+                        if (stage &&
+                            (stage.loadMs !== undefined ||
+                                stage.diffusionMs !== undefined ||
+                                stage.decodeMs !== undefined)) {
+                            run.stageMs = stage;
+                        }
+                    }
+                    runs.push(run);
+                    void this.logManager
+                        ?.write(`Calibration run: ${combo.label ?? JSON.stringify(combo)} @ ${size.width}x${size.height} → ${run.status}${run.timeTakenMs !== undefined ? ` (${Math.round(run.timeTakenMs)} ms)` : ''}${run.error ? ` — ${run.error.split('\n')[0]}` : ''}`, run.status === 'ok' ? 'info' : 'warn')
+                        .catch(() => void 0);
+                }
+            }
+            const recommended = pickRecommended(runs, defaults.tieTolerancePct);
+            const machine = {};
+            try {
+                const gpu = await this.systemInfo.getGPUInfo();
+                machine.gpuType = gpu.type;
+                machine.gpuName = gpu.name;
+                machine.vramBytes = gpu.vram;
+                machine.vramAvailableBytes = gpu.vramAvailable;
+            }
+            catch {
+            }
+            const report = {
+                machine,
+                modelId: config.modelId,
+                steps,
+                sampler,
+                samples,
+                runs,
+                recommended,
+            };
+            if (skippedCombos.length > 0) {
+                report.skippedCombos = skippedCombos;
+            }
+            succeeded = true;
+            return report;
+        }
+        finally {
+            config.signal?.removeEventListener('abort', abortListener);
+            this._config = savedConfig;
+            this.currentModelInfo = savedModelInfo;
+            this.binaryPath = savedBinaryPath;
+            this.calibrating = false;
+            if (this.orchestrator) {
+                emitFn?.({
+                    phase: 'restoring-llm',
+                    comboIndex: Math.max(0, comboCountForProgress - 1),
+                    comboCount: comboCountForProgress,
+                    sizeIndex: Math.max(0, sizes.length - 1),
+                    sizeCount: sizes.length,
+                    overallPercent: succeeded ? 100 : lastOverallPercent,
+                });
+                await this.orchestrator.reloadLLM();
+            }
+            if (succeeded) {
+                emitFn?.({
+                    phase: 'done',
+                    comboIndex: Math.max(0, comboCountForProgress - 1),
+                    comboCount: comboCountForProgress,
+                    sizeIndex: Math.max(0, sizes.length - 1),
+                    sizeCount: sizes.length,
+                    overallPercent: 100,
+                });
+            }
+        }
+    }
+    isCalibrating() {
+        return this.calibrating;
+    }
+    calibrationAbortError(runs) {
+        return new ServerError('Calibration aborted', {
+            code: 'CALIBRATION_ABORTED',
+            runs: [...runs],
+            suggestion: 'Partial results are available in error.details.runs',
+        });
+    }
+    async runCalibrationGeneration(params) {
+        const genConfig = {
+            prompt: params.prompt,
+            width: params.size.width,
+            height: params.size.height,
+            steps: params.steps,
+            seed: params.seed,
+            sampler: params.sampler,
+            onProgress: (_currentStep, _totalSteps, _stage, percentage) => {
+                if (percentage !== undefined) {
+                    params.onGenerationProgress(percentage);
+                }
+            },
+        };
+        if (params.cfgScale !== undefined) {
+            genConfig.cfgScale = params.cfgScale;
+        }
+        return this.executeImageGeneration(genConfig, params.combo);
+    }
+    snapshotStageMs() {
+        const stage = {};
+        if (this.loadStartTime && this.loadEndTime) {
+            stage.loadMs = this.loadEndTime - this.loadStartTime;
+        }
+        if (this.diffusionStartTime && this.diffusionEndTime) {
+            stage.diffusionMs = this.diffusionEndTime - this.diffusionStartTime;
+        }
+        if (this.vaeStartTime && this.vaeEndTime) {
+            stage.decodeMs = this.vaeEndTime - this.vaeStartTime;
+        }
+        return stage;
+    }
+    classifyCalibrationFailure(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        let stderr = '';
+        if (error instanceof GenaiElectronError && error.details && typeof error.details === 'object') {
+            const detailStderr = error.details.stderr;
+            if (typeof detailStderr === 'string') {
+                stderr = detailStderr;
+            }
+        }
+        const text = `${message}\n${stderr}`;
+        const isOom = DIFFUSION_CALIBRATION_DEFAULTS.oomPatterns.some((pattern) => pattern.test(text));
+        return { status: isOom ? 'oom' : 'error', message };
+    }
     async generateImage(config) {
         if (this._status !== 'running') {
             throw new ServerError('Server is not running', {
@@ -447,7 +838,7 @@ export class DiffusionServerManager extends ServerManager {
             req.on('error', reject);
         });
     }
-    async executeImageGeneration(config) {
+    async executeImageGeneration(config, flagOverrides) {
         const startTime = Date.now();
         if (!this.currentModelInfo) {
             throw new ServerError('Model information not available', {
@@ -459,7 +850,7 @@ export class DiffusionServerManager extends ServerManager {
             seed: config.seed === undefined || config.seed < 0 ? this.generateRandomSeed() : config.seed,
         };
         this.initializeProgressTracking(normalizedConfig);
-        const optimizations = await this.computeDiffusionOptimizations();
+        const optimizations = await this.computeDiffusionOptimizations(flagOverrides);
         const args = this.buildDiffusionArgs(normalizedConfig, this.currentModelInfo, optimizations);
         const outputPath = getTempPath(`sd-output-${Date.now()}.png`);
         args.push('-o', outputPath);
@@ -574,7 +965,7 @@ export class DiffusionServerManager extends ServerManager {
         }
         return images;
     }
-    async computeDiffusionOptimizations() {
+    async computeDiffusionOptimizations(flagOverrides) {
         const serverConfig = this._config;
         const modelSize = this.currentModelInfo?.size ?? 0;
         const modelFootprint = modelSize * DIFFUSION_VRAM_THRESHOLDS.modelOverheadMultiplier;
@@ -590,15 +981,10 @@ export class DiffusionServerManager extends ServerManager {
             }
             else {
                 const headroom = gpu.vram - modelFootprint;
-                const isCuda = await this.isInstalledVariantCuda();
-                autoClipOnCpu = isCuda
-                    ? false
-                    : headroom < DIFFUSION_VRAM_THRESHOLDS.clipOnCpuHeadroomBytes;
-                autoVaeOnCpu = isCuda ? false : headroom < DIFFUSION_VRAM_THRESHOLDS.vaeOnCpuHeadroomBytes;
-                autoOffloadToCpu = isCuda ? false : modelFootprint > gpu.vram * 0.85;
-                if (!isCuda &&
-                    gpu.vramAvailable !== undefined &&
-                    gpu.vramAvailable - modelFootprint < 2 * 1024 ** 3) {
+                autoClipOnCpu = headroom < DIFFUSION_VRAM_THRESHOLDS.clipOnCpuHeadroomBytes;
+                autoVaeOnCpu = headroom < DIFFUSION_VRAM_THRESHOLDS.vaeOnCpuHeadroomBytes;
+                autoOffloadToCpu = modelFootprint > gpu.vram * 0.85;
+                if (gpu.vramAvailable !== undefined && gpu.vramAvailable - modelFootprint < 2 * 1024 ** 3) {
                     autoClipOnCpu = true;
                 }
             }
@@ -610,25 +996,17 @@ export class DiffusionServerManager extends ServerManager {
         }
         const hasLLMComponent = !!this.currentModelInfo?.components?.llm;
         const autoDiffusionFlashAttention = hasLLMComponent;
-        const clipOnCpu = serverConfig.clipOnCpu ?? autoClipOnCpu;
-        const vaeOnCpu = serverConfig.vaeOnCpu ?? autoVaeOnCpu;
-        const offloadToCpu = serverConfig.offloadToCpu ?? autoOffloadToCpu;
-        const diffusionFlashAttention = serverConfig.diffusionFlashAttention ?? autoDiffusionFlashAttention;
+        const clipOnCpu = flagOverrides?.clipOnCpu ?? serverConfig.clipOnCpu ?? autoClipOnCpu;
+        const vaeOnCpu = flagOverrides?.vaeOnCpu ?? serverConfig.vaeOnCpu ?? autoVaeOnCpu;
+        const offloadToCpu = flagOverrides?.offloadToCpu ?? serverConfig.offloadToCpu ?? autoOffloadToCpu;
+        const diffusionFlashAttention = flagOverrides?.diffusionFlashAttention ??
+            serverConfig.diffusionFlashAttention ??
+            autoDiffusionFlashAttention;
         const batchSize = serverConfig.batchSize;
+        this.lastResolvedOptimizations = { clipOnCpu, vaeOnCpu, offloadToCpu, diffusionFlashAttention };
         await this.logManager?.write(`VRAM optimizations: clipOnCpu=${clipOnCpu}, vaeOnCpu=${vaeOnCpu}, offloadToCpu=${offloadToCpu}, diffusionFa=${diffusionFlashAttention}${batchSize !== undefined ? `, batchSize=${batchSize}` : ''} (auto: clip=${autoClipOnCpu}, vae=${autoVaeOnCpu}, offload=${autoOffloadToCpu}, fa=${autoDiffusionFlashAttention})`, 'info');
         return { clipOnCpu, vaeOnCpu, offloadToCpu, diffusionFlashAttention, batchSize };
     }
-    async isInstalledVariantCuda() {
-        try {
-            const variantCachePath = `${PATHS.binaries.diffusion}/.variant.json`;
-            const content = await fs.readFile(variantCachePath, 'utf-8');
-            const cache = JSON.parse(content);
-            return cache.variant === 'cuda';
-        }
-        catch {
-            return false;
-        }
-    }
     buildDiffusionArgs(config, modelInfo, optimizations) {
         const args = [];
         if (modelInfo.components) {
@@ -736,7 +1114,7 @@ export class DiffusionServerManager extends ServerManager {
         this.totalEstimatedTime = loadTime + diffusionTime + vaeTime;
     }
     processStdoutForProgress(data, config) {
-        if (data.includes('loading tensors from')) {
+        if (data.includes('loading tensors from') || data.includes('loading model from')) {
             this.currentStage = 'loading';
             this.loadStartTime = Date.now();
             this.reportProgress(config);
@@ -768,7 +1146,7 @@ export class DiffusionServerManager extends ServerManager {
                 config.onProgress(0, 0, 'decoding', 100);
             }
         }
-        const progressMatch = data.match(/\|\s*(\d+)\/(\d+)\s*-/);
+        const progressMatch = data.match(/\|\s*(\d+)\/(\d+)\s*-\s*[\d.]+\s*(?:it\/s|s\/it)/);
         if (progressMatch && progressMatch[1] && progressMatch[2]) {
             const current = parseInt(progressMatch[1], 10);
             const total = parseInt(progressMatch[2], 10);
@@ -787,6 +1165,21 @@ export class DiffusionServerManager extends ServerManager {
                 this.reportProgress(config);
             }
         }
+        const byteMatch = data.match(/\|\s*(\d+)\/(\d+)\s*-\s*[\d.]+\s*(?:B|KB|MB|GB)\/s/);
+        if (byteMatch && byteMatch[1] && byteMatch[2]) {
+            const current = parseInt(byteMatch[1], 10);
+            const total = parseInt(byteMatch[2], 10);
+            if (this.currentStage === 'loading') {
+                this.loadProgress = { current, total };
+                this.reportProgress(config);
+            }
+            else if (this.currentStage === undefined) {
+                this.currentStage = 'loading';
+                this.loadStartTime = Date.now();
+                this.loadProgress = { current, total };
+                this.reportProgress(config);
+            }
+        }
     }
     reportProgress(config) {
         if (!config.onProgress || !this.generationStartTime)
@@ -899,4 +1292,47 @@ export class DiffusionServerManager extends ServerManager {
         }
     }
 }
+function medianOf(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function countForcedFlags(combo) {
+    let count = 0;
+    if (combo.clipOnCpu !== undefined)
+        count++;
+    if (combo.vaeOnCpu !== undefined)
+        count++;
+    if (combo.offloadToCpu !== undefined)
+        count++;
+    if (combo.diffusionFlashAttention !== undefined)
+        count++;
+    return count;
+}
+export function pickRecommended(runs, tolerancePct) {
+    const bySize = new Map();
+    for (const run of runs) {
+        if (run.status !== 'ok' || run.timeTakenMs === undefined) {
+            continue;
+        }
+        const key = `${run.size.width}x${run.size.height}`;
+        const list = bySize.get(key);
+        if (list) {
+            list.push(run);
+        }
+        else {
+            bySize.set(key, [run]);
+        }
+    }
+    const recommended = {};
+    for (const [key, okRuns] of bySize) {
+        const fastest = okRuns.reduce((a, b) => (b.timeTakenMs < a.timeTakenMs ? b : a));
+        const threshold = fastest.timeTakenMs * (1 + tolerancePct / 100);
+        const winner = okRuns
+            .filter((run) => run.timeTakenMs <= threshold)
+            .sort((a, b) => countForcedFlags(a.combo) - countForcedFlags(b.combo) || a.timeTakenMs - b.timeTakenMs)[0];
+        recommended[key] = winner.combo;
+    }
+    return recommended;
+}
 //# sourceMappingURL=DiffusionServerManager.js.map