Upload 8 files

sd-webui-timemachine-fixed/javascript/init.js

@@ -0,0 +1,56 @@
+(function(NAME) {
+
+    const name = NAME.toLowerCase().replaceAll(/\s/g, '');
+    
+    let _r = 0;
+    function to_gradio(v) {
+        // force call `change` event on gradio
+        return [v.toString(), (_r++).toString()];
+    }
+    
+    function js2py(type, gradio_field, value) {
+        // set `value` to gradio's field
+        // (1) Click gradio's button.
+        // (2) Gradio will fire js callback to retrieve value to be set.
+        // (3) Gradio will fire another js callback to notify the process has been completed.
+        return new Promise(resolve => {
+            const callback_name = `${name}-${type}-${gradio_field}`;
+            
+            // (2)
+            globalThis[callback_name] = () => {
+                
+                delete globalThis[callback_name];
+                
+                // (3)
+                const callback_after = callback_name + '_after';
+                globalThis[callback_after] = () => {
+                    delete globalThis[callback_after];
+                    resolve();
+                };
+                
+                return to_gradio(value);
+            };
+            
+            // (1)
+            gradioApp().querySelector(`#${callback_name}_set`).click();
+        });
+    }
+
+    function id(mode, s) {
+        const v = `${name}-${mode}`;
+        return s === undefined ? v : `${v}-${s}`;
+    }
+
+    if (!globalThis[name]) {
+        globalThis[name] = {};
+    }
+
+    const obj = globalThis[name];
+    obj.id = id;
+    obj.js2py = js2py;
+    obj.init = true;
+
+    console.log(`[${NAME}] initialized`)
+    document.dispatchEvent(new CustomEvent(`${name}_init`, { detail: obj }));
+
+})('TimeMachine');

sd-webui-timemachine-fixed/javascript/timemachine.js

@@ -0,0 +1,957 @@
+(function (NAME) {
+
+    const name = NAME.toLowerCase().replaceAll(/\s/g, '');
+
+    if (globalThis[name]?.init) init(name, globalThis[name]);
+    else document.addEventListener(`${name}_init`, e => init(name, e.detail), { once: true });
+
+    async function init(name, lib) { await load_modules(lib); await main(name, lib); }
+
+    function load_modules(lib) {
+        return new Promise(resolve => {
+            function load() {
+                if (lib.module_loaded) return true;
+                const app = gradioApp();
+                if (!app || app === document) return false;
+                const jscont = app.querySelector('#' + lib.id('js_modules'));
+                if (!jscont) return false;
+                const [base_path, ...scripts] = jscont.textContent.trim().split('\n').map(x => x.trim());
+                jscont.textContent = '';
+                const df = document.createDocumentFragment();
+                for (let src of scripts) {
+                    const s = document.createElement('script');
+                    s.async = true; s.type = 'module'; s.src = `file=${src}`; df.appendChild(s);
+                }
+                app.appendChild(df);
+                lib.import = s => import(`/file=${base_path}/javascript/modules/${s}`);
+                lib.module_loaded = true; resolve(); return true;
+            }
+            (function try_load() { if (!load()) setTimeout(try_load, 500); })();
+        });
+    }
+
+    async function main(name, lib) {
+        await lib.import('chart.umd.js');
+        main2(name, lib, 'txt2img');
+        main2(name, lib, 'img2img');
+    }
+
+    async function main2(name, lib, mode) {
+        // Ждём появления аккордеона в DOM
+        await new Promise(resolve => {
+            (function try_get() {
+                const el = gradioApp().querySelector('#' + lib.id(mode, 'accordion'));
+                el ? resolve(el) : setTimeout(try_get, 500);
+            })();
+        });
+
+        let initialized = false;
+
+        function tryInit() {
+            if (initialized) return;
+            const container = gradioApp().querySelector('#' + lib.id(mode, 'container'));
+            // offsetParent === null если элемент скрыт (display:none)
+            if (container && container.offsetParent !== null) {
+                initialized = true;
+                main3(name, lib, mode);
+            }
+        }
+
+        // Попытка сразу (Gradio 4.x: контент уже в DOM, просто скрыт)
+        tryInit();
+
+        // MutationObserver для Gradio 3.x (контент добавляется при открытии)
+        const acc = gradioApp().querySelector('#' + lib.id(mode, 'accordion'));
+        if (acc) {
+            new MutationObserver(() => tryInit())
+                .observe(acc, { childList: true, subtree: true, attributes: true });
+        }
+
+        // Опрос как запасной вариант (ловит CSS-изменения видимости)
+        // Останавливается как только граф инициализирован или через 60 сек
+        const deadline = Date.now() + 60000;
+        const poll = setInterval(() => {
+            if (initialized || Date.now() > deadline) { clearInterval(poll); return; }
+            tryInit();
+        }, 300);
+    }
+
+    function main3(name, lib, mode) {
+        const id  = s => lib.id(mode, s);
+        const $   = x => Array.from(gradioApp().querySelectorAll(x)).at(-1);
+        const $$  = x => gradioApp().querySelector(x);
+
+        const enabled         = $$(`#${id('enabled')} input[type=checkbox]`);
+        const generate_button = $$(`#${mode}_generate`);
+        const step_ele        = $$(`#${mode}_steps input[type=number]`);
+        const oneShotEl       = $$(`#${id('one_shot')} input[type=checkbox]`);
+        const cutoffEl        = $$(`#${id('cutoff')} input[type=number]`);
+
+        // ── Главный график ──────────────────────────────────
+        const canvas  = document.createElement('canvas');
+        canvas.width  = 512; canvas.height = 512;
+
+        const plugins = createPlugins(canvas, step_ele, cutoffEl);
+        const chart   = new Chart(canvas.getContext('2d'), {
+            type: 'scatter', data: createInitialData(),
+            options: createChartOption(), plugins,
+        });
+        $('#' + id('container')).appendChild(canvas);
+
+        // ── Per-segment mode: right-click on line → menu ─────────
+        const SEG_MODES = ['Linear', 'Ease In', 'Ease Out', 'Ease In-Out', 'Cubic', 'Exponential', 'Step'];
+
+        function _findSegment(c, ev) {
+            const rect = c.canvas.getBoundingClientRect();
+            const x = c.scales.x.getValueForPixel(ev.clientX - rect.left);
+            const data = c.data.datasets[0].data;
+            for (let i = 0; i < data.length - 1; i++) {
+                if (data[i].x <= x && x <= data[i + 1].x) return { idx: i, pt: data[i] };
+            }
+            return null;
+        }
+
+        let _segMenuCloser = null;
+        function _closeSegMenu() {
+            const old = document.getElementById(id('segmenu')); if (old) old.remove();
+            if (_segMenuCloser) { document.removeEventListener('click', _segMenuCloser); _segMenuCloser = null; }
+        }
+
+        function _showSegMenu(c, seg, ev) {
+            _closeSegMenu();
+            const div = document.createElement('div');
+            div.id = id('segmenu');
+            div.style.cssText = 'position:fixed;background:#1a1a2e;border:1px solid #ff8c00;border-radius:8px;padding:4px 0;z-index:99999;font-size:13px;box-shadow:0 4px 20px rgba(0,0,0,.6);min-width:150px';
+            _segMenuCloser = () => _closeSegMenu();
+            document.addEventListener('click', _segMenuCloser, {once:true});
+
+            SEG_MODES.forEach(m => {
+                const el = document.createElement('div');
+                el.textContent = m;
+                const active = seg.pt.mode === m || (!seg.pt.mode && m === 'Linear');
+                el.style.cssText = `padding:4px 16px;cursor:pointer;color:${active?'#ff8c00':'#ddd'};font-weight:${active?'bold':'normal'}`;
+                el.addEventListener('mouseenter', () => { el.style.background = '#ff8c0022'; });
+                el.addEventListener('mouseleave', () => { el.style.background = 'transparent'; });
+                el.addEventListener('click', e => { e.stopPropagation();
+                    if (m === 'Linear') delete seg.pt.mode; else seg.pt.mode = m;
+                    c.update(); saveState(c); triggerSync(c); _closeSegMenu();
+                });
+                div.appendChild(el);
+            });
+
+            const sep = document.createElement('div');
+            sep.style.cssText = 'height:1px;background:#444;margin:3px 8px';
+            div.appendChild(sep);
+
+            const clear = document.createElement('div');
+            clear.textContent = '— Use global';
+            clear.style.cssText = 'padding:4px 16px;cursor:pointer;color:#999;font-style:italic';
+            clear.addEventListener('mouseenter', () => { clear.style.background = '#ff8c0022'; });
+            clear.addEventListener('mouseleave', () => { clear.style.background = 'transparent'; });
+            clear.addEventListener('click', e => { e.stopPropagation();
+                delete seg.pt.mode; c.update(); saveState(c); triggerSync(c); _closeSegMenu();
+            });
+            div.appendChild(clear);
+
+            div.style.left = Math.min(ev.clientX, window.innerWidth - 170) + 'px';
+            div.style.top  = Math.min(ev.clientY, window.innerHeight - div.offsetHeight) + 'px';
+            document.body.appendChild(div);
+        }
+
+        canvas.addEventListener('contextmenu', e => {
+            e.preventDefault();
+            if (plugins[0].lastRemoved) { plugins[0].lastRemoved = false; return; }
+            const seg = _findSegment(chart, e);
+            if (seg) _showSegMenu(chart, seg, e);
+        }, true);
+
+        // σ-аппроксимация (реальные через HTTP, fallback Karras)
+        let showSigma = false, approxSigmas = [];
+
+        function getScheduler() {
+            const el = $$(`#${id('scheduler')} select`);
+            return el?.value || 'Use sampler default';
+        }
+
+        function getSampler() {
+            const el = $$(`#${mode}_sampling select`);
+            return el?.value || '';
+        }
+        function getA1111Scheduler() {
+            const el = $$(`#${mode}_scheduler select`);
+            return el?.value || '';
+        }
+
+        async function _fetchRealSigmas(scheduler, steps) {
+            try {
+                let url = `/timemachine/sigmas?scheduler=${encodeURIComponent(scheduler)}&steps=${steps}`;
+                const sampler = getSampler();
+                if (sampler) url += `&sampler=${encodeURIComponent(sampler)}`;
+                const a1111sched = getA1111Scheduler();
+                if (a1111sched) url += `&a1111_scheduler=${encodeURIComponent(a1111sched)}`;
+                const res = await fetch(url);
+                if (!res.ok) return null;
+                const data = await res.json();
+                return Array.isArray(data.sigmas) ? data.sigmas : null;
+            } catch(e) {
+                return null;
+            }
+        }
+
+        function _karrasApprox(n) {
+            const [sMin, sMax, rho] = [0.1, 14.6, 7];
+            const sig = Array.from({length: n}, (_, i) => {
+                const t = i / Math.max(1, n-1);
+                return Math.pow(Math.pow(sMax,1/rho)+t*(Math.pow(sMin,1/rho)-Math.pow(sMax,1/rho)), rho);
+            });
+            sig.push(0);
+            return sig;
+        }
+
+        function updateSigmaApprox(n, scheduler) {
+            approxSigmas = _karrasApprox(n);
+            _fetchRealSigmas(scheduler, n).then(real => {
+                if (real && real.length >= n) {
+                    // real has n+1 sigmas (including trailing 0)
+                    approxSigmas = real.slice(0, n + 1);
+                    if (showSigma) { chart?.update(); if (hr_chart) hr_chart?.update(); }
+                }
+            });
+        }
+
+        // Динамические callbacks Chart.js
+        chart.options.scales.y.ticks.callback = v => {
+            if (!showSigma || v < 1 || v > approxSigmas.length-1) return v;
+            const s = approxSigmas[Math.round(v)-1];
+            return s == null ? v : s < 0.01 ? '0' : s < 1 ? s.toFixed(3) : s.toFixed(1);
+        };
+        chart.options.plugins.tooltip.callbacks.title = ctxs => ctxs.map(c => {
+            const pos = c.parsed.y;
+            if (!showSigma) return `${c.parsed.x} → ${pos}`;
+            const s = approxSigmas[Math.round(pos)-1];
+            return `step ${c.parsed.x} → ${pos}${s != null ? ` (σ≈${s.toFixed(3)})` : ''}`;
+        });
+
+        // Interp tension
+        function getInterpMode() {
+            return $$(`#${id('interpolation')} select`)?.value || 'Linear';
+        }
+        function updateChartStyle(c = chart) {
+            const mode = getInterpMode();
+            const ds   = c.data.datasets[0];
+            if (mode === 'Step') {
+                ds.stepped = 'before'; ds.cubicInterpolationMode = 'default'; ds.tension = 0;
+            } else if (mode === 'Monotone') {
+                ds.stepped = false; ds.cubicInterpolationMode = 'monotone'; ds.tension = 0;
+            } else if (mode === 'Smooth (spline)') {
+                ds.stepped = false; ds.cubicInterpolationMode = 'default'; ds.tension = 0.4;
+            } else {
+                ds.stepped = false; ds.cubicInterpolationMode = 'default'; ds.tension = 0;
+            }
+            c.update();
+        }
+        const interpEl = $$(`#${id('interpolation')} select`);
+        if (interpEl) interpEl.addEventListener('change', () => updateChartStyle());
+        const schedEl = $$(`#${id('scheduler')} select`);
+        if (schedEl) schedEl.addEventListener('change', () => {
+            updateSigmaApprox(+step_ele.value, getScheduler());
+        });
+        const samplerEl = $$(`#${mode}_sampler select`);
+        if (samplerEl) samplerEl.addEventListener('change', () => {
+            updateSigmaApprox(+step_ele.value, getScheduler());
+        });
+
+        // ── История (Undo/Redo) ──────────────────────────────
+        const MAX_HIST = 20;
+        let hist = [], histIdx = -1;
+
+        function saveState(c) {
+            const snap = JSON.stringify(c.data.datasets[0].data);
+            if (hist[histIdx] === snap) return;
+            hist = hist.slice(0, histIdx+1);
+            hist.push(snap);
+            if (hist.length > MAX_HIST) hist.shift(); else histIdx++;
+        }
+        function undo(c) {
+            if (histIdx > 0) {
+                histIdx--;
+                c.data.datasets[0].data = JSON.parse(hist[histIdx]);
+                c.update(); triggerSync(c);
+            }
+        }
+        function redo(c) {
+            if (histIdx < hist.length-1) {
+                histIdx++;
+                c.data.datasets[0].data = JSON.parse(hist[histIdx]);
+                c.update(); triggerSync(c);
+            }
+        }
+
+        document.addEventListener('keydown', e => {
+            const tag = document.activeElement?.tagName;
+            if (tag==='INPUT'||tag==='TEXTAREA'||document.activeElement?.contentEditable==='true') return;
+            if (!enabled?.checked) return;
+            if (e.ctrlKey && e.key==='z' && !e.shiftKey) { e.preventDefault(); undo(chart); }
+            if (e.ctrlKey && ((e.key==='z' && e.shiftKey)||e.key==='y')) { e.preventDefault(); redo(chart); }
+        });
+
+        // ── Sync + Persist ──────────────────────────────────
+        let syncedData = null, pendingSync = null;
+
+        function _saveToDisk() {
+            try {
+                localStorage.setItem(`tm_curve:${mode}`, JSON.stringify(chart.data.datasets[0].data));
+                if (hr_chart) {
+                    localStorage.setItem(`tm_curve:${mode}:hr`, JSON.stringify(hr_chart.data.datasets[0].data));
+                }
+            } catch(e) { /* quota exceeded, silently ignore */ }
+        }
+
+        function _loadFromDisk() {
+            const saved = localStorage.getItem(`tm_curve:${mode}`);
+            if (saved) {
+                try {
+                    const pts = JSON.parse(saved);
+                    if (Array.isArray(pts) && pts.length >= 2) {
+                        chart.data.datasets[0].data = pts;
+                        updateSteps(chart, +step_ele.value);
+                        syncedData = JSON.stringify(chart.data.datasets[0].data);
+                        return;
+                    }
+                } catch(e) { /* ignore corrupt data */ }
+            }
+        }
+
+        function triggerSync(c, key='tm') {
+            const data = JSON.stringify(c.data.datasets[0].data);
+            if (key==='tm' && data===syncedData) return;
+            if (key==='tm_hr' && data===hr_syncedData) return;
+            const prom = lib.js2py(mode, key, data).then(() => {
+                if (key==='tm')    { syncedData    = data; pendingSync    = null; }
+                if (key==='tm_hr') { hr_syncedData = data; hr_pendingSync = null; }
+            }).catch(() => {
+                if (key==='tm')    pendingSync    = null;
+                if (key==='tm_hr') hr_pendingSync = null;
+            });
+            if (key==='tm')    pendingSync    = prom;
+            if (key==='tm_hr') hr_pendingSync = prom;
+            _saveToDisk();
+        }
+
+        // Hook плагина
+        const plugin = plugins[0];
+        const _oEnd = plugin.endDrag.bind(plugin);
+        plugin.endDrag = (c,a)=>{ _oEnd(c,a); saveState(c); triggerSync(c); };
+        const _oAdd = plugin.addPoint.bind(plugin);
+        plugin.addPoint = (c,a)=>{ _oAdd(c,a); saveState(c); triggerSync(c); };
+        const _oDel = plugin.removePoint.bind(plugin);
+        plugin.removePoint = (c,a)=>{ _oDel(c,a); saveState(c); triggerSync(c); };
+
+        // Инициализация
+        updateSteps(chart, +step_ele.value);
+        updateSigmaApprox(+step_ele.value, getScheduler());
+        _loadFromDisk();
+        saveState(chart);
+
+        let debounceTimer;
+        step_ele.addEventListener('input', () => {
+            updateSteps(chart, +step_ele.value);
+        updateSigmaApprox(+step_ele.value, getScheduler());
+            saveState(chart);
+            if (cutoffEl) cutoffEl.setAttribute('max', +step_ele.value);
+            clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(() => triggerSync(chart), 150);
+        });
+
+        // Обновление линии cutoff при изменении значения
+        if (cutoffEl) {
+            cutoffEl.addEventListener('input', () => {
+                chart.update();
+                if (hr_chart) hr_chart.update();
+            });
+        }
+
+        // ── HR Fix график ────────────────────────────────────
+        let hr_chart = null, hr_syncedData = null, hr_pendingSync = null;
+        const hr_container = $$('#' + id('hr_container'));
+
+        if (hr_container) {
+            const hr_step_raw = $$(`#${mode}_hires_steps input[type=number]`);
+            const hr_step     = hr_step_raw || step_ele;
+
+            const hr_canvas = document.createElement('canvas');
+            hr_canvas.width = 512; hr_canvas.height = 512;
+            const hr_plugins = createPlugins(hr_canvas, hr_step, cutoffEl);
+
+            hr_chart = new Chart(hr_canvas.getContext('2d'), {
+                type: 'scatter', data: createInitialData(),
+                options: createChartOption(), plugins: hr_plugins,
+            });
+
+            hr_chart.options.scales.y.ticks.callback = v => {
+                if (!showSigma || v < 1 || v > approxSigmas.length-1) return v;
+                const s = approxSigmas[Math.round(v)-1];
+                return s == null ? v : s < 1 ? s.toFixed(3) : s.toFixed(1);
+            };
+            hr_chart.options.plugins.tooltip.callbacks.title = ctxs => ctxs.map(c => {
+                const pos = c.parsed.y;
+                if (!showSigma) return `HR step ${c.parsed.x} → ${pos}`;
+                const s = approxSigmas[Math.round(pos)-1];
+                return `HR step ${c.parsed.x} → ${pos}${s != null ? ` (σ≈${s.toFixed(3)})` : ''}`;
+            });
+
+            hr_container.appendChild(hr_canvas);
+            updateSteps(hr_chart, +hr_step.value || +step_ele.value);
+
+            // Load persisted HR curve
+            const savedHr = localStorage.getItem(`tm_curve:${mode}:hr`);
+            if (savedHr) {
+                try {
+                    const pts = JSON.parse(savedHr);
+                    if (Array.isArray(pts) && pts.length >= 2) {
+                        hr_chart.data.datasets[0].data = pts;
+                        updateSteps(hr_chart, +hr_step.value || +step_ele.value);
+                        hr_syncedData = JSON.stringify(hr_chart.data.datasets[0].data);
+                    }
+                } catch(e) { /* ignore */ }
+            }
+
+            const hr_plugin = hr_plugins[0];
+            const _hoEnd = hr_plugin.endDrag.bind(hr_plugin);
+            hr_plugin.endDrag = (c,a)=>{ _hoEnd(c,a); triggerSync(c,'tm_hr'); };
+            const _hoAdd = hr_plugin.addPoint.bind(hr_plugin);
+            hr_plugin.addPoint = (c,a)=>{ _hoAdd(c,a); triggerSync(c,'tm_hr'); };
+            const _hoDel = hr_plugin.removePoint.bind(hr_plugin);
+            hr_plugin.removePoint = (c,a)=>{ _hoDel(c,a); triggerSync(c,'tm_hr'); };
+
+            hr_step.addEventListener('input', () => {
+                updateSteps(hr_chart, +hr_step.value || +step_ele.value);
+                triggerSync(hr_chart, 'tm_hr');
+            });
+
+            // Синхронизируем tension HR графика с основным
+            if (interpEl) interpEl.addEventListener('change', () => updateChartStyle(hr_chart));
+        }
+
+        // ── Generate button ─────────────────────────────────
+        let generating = false;
+        gradioApp().addEventListener('click', async e => {
+            if (e.target !== generate_button) return;
+            if (!enabled?.checked) return;
+            if (generating) { generating = false; return; }
+
+            const mainData = JSON.stringify(chart.data.datasets[0].data);
+            const hrData   = hr_chart ? JSON.stringify(hr_chart.data.datasets[0].data) : null;
+            const needMain = mainData !== syncedData;
+            const needHR   = hrData !== null && hrData !== hr_syncedData;
+
+            if (needMain || needHR) {
+                e.preventDefault(); e.stopPropagation();
+                await Promise.all([
+                    needMain ? (pendingSync    || lib.js2py(mode,'tm',   mainData).then(()=>syncedData   =mainData)) : Promise.resolve(),
+                    needHR   ? (hr_pendingSync || lib.js2py(mode,'tm_hr',hrData  ).then(()=>hr_syncedData=hrData  )) : Promise.resolve(),
+                ]);
+                generating = true; generate_button.click();
+            }
+        }, true);
+
+        // ── Нижняя панель ───────────────────────────────────
+        const PRESETS = {
+            'Linear (Default)': n => [{x:1,y:1},{x:n,y:n}],
+            'Detail Enhancer':  n => [{x:1,y:1},{x:Math.max(2,Math.round(n*.25)),y:Math.round(n*.7)},{x:n,y:n}],
+            'Composition Lock': n => [{x:1,y:1},{x:Math.round(n*.75),y:Math.max(2,Math.round(n*.25))},{x:n,y:n}],
+            'Time Travel':      n => [{x:1,y:1},{x:Math.round(n*.35),y:Math.round(n*.35)},{x:Math.round(n*.5),y:Math.max(1,Math.round(n*.15))},{x:Math.round(n*.65),y:Math.round(n*.35)},{x:n,y:n}],
+            'Early Burst':      n => [{x:1,y:1},{x:Math.round(n*.5),y:Math.round(n*.9)},{x:n,y:n}],
+        };
+
+        function makeBtn(label, title, onClick) {
+            const b = document.createElement('button');
+            b.textContent = label; b.type = 'button'; b.title = title || label;
+            b.style.cssText = 'padding:3px 10px;border-radius:4px;cursor:pointer;font-size:12px';
+            b.addEventListener('click', onClick); return b;
+        }
+
+        const bar = document.createElement('div');
+        bar.style.cssText = 'display:flex;gap:6px;align-items:center;margin:6px 0 0;flex-wrap:wrap;font-size:13px';
+
+        // ── Пресеты (built-in + custom из localStorage) ─────
+        function _storageKeys(prefix) {
+            const keys = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const k = localStorage.key(i);
+                if (k && k.startsWith(prefix)) keys.push(k);
+            }
+            return keys;
+        }
+
+        function _loadCustomPresets() {
+            const out = {};
+            for (const k of _storageKeys('tm_presets:')) {
+                const name = k.slice('tm_presets:'.length);
+                try {
+                    const raw = JSON.parse(localStorage.getItem(k));
+                    let pts, savedN;
+                    if (Array.isArray(raw)) {
+                        pts = raw;
+                        savedN = Math.max(...pts.map(p => p.x));
+                    } else if (raw && Array.isArray(raw.points) && raw.points.length >= 2) {
+                        pts = raw.points;
+                        savedN = raw.savedN || Math.max(...pts.map(p => p.x));
+                    } else {
+                        continue;
+                    }
+                    if (pts.length >= 2) {
+                        out[name] = (n) => {
+                            if (n === savedN || savedN <= 1) return pts;
+                            const scale = (n - 1) / (savedN - 1);
+                            return pts.map(p => ({
+                                ...p,
+                                x: Math.max(1, Math.min(n, Math.round(1 + (p.x - 1) * scale))),
+                            }));
+                        };
+                    }
+                } catch(e) { /* ignore */ }
+            }
+            return out;
+        }
+
+        function _rebuildPresetDropdown() {
+            while (presetSel.firstChild) presetSel.removeChild(presetSel.firstChild);
+            // Built-in
+            Object.keys(PRESETS).forEach(n => {
+                const o = document.createElement('option'); o.value = n; o.textContent = n;
+                presetSel.appendChild(o);
+            });
+            // Custom
+            const custom = _loadCustomPresets();
+            const cKeys = Object.keys(custom);
+            if (cKeys.length) {
+                const grp = document.createElement('optgroup'); grp.label = '-- Saved --';
+                cKeys.forEach(n => {
+                    const o = document.createElement('option'); o.value = n; o.textContent = n;
+                    grp.appendChild(o);
+                });
+                presetSel.appendChild(grp);
+            }
+            // Store custom map on the select for the apply handler
+            presetSel._custom = custom;
+        }
+
+        const presetSel = document.createElement('select');
+        presetSel.style.cssText = 'padding:3px 6px;border-radius:4px;cursor:pointer;flex:1;min-width:120px';
+        _rebuildPresetDropdown();
+
+        const applyBtn = makeBtn('Apply', 'Применить пресет', () => {
+            const name = presetSel.value;
+            const fn = PRESETS[name] || presetSel._custom[name];
+            if (!fn) return;
+            const n = Math.max(2, +step_ele.value);
+            chart.data.datasets[0].data = fn(n);
+            updateSteps(chart, n);
+            saveState(chart); updateChartStyle(); triggerSync(chart);
+        });
+
+        const savePresetBtn = makeBtn('Save', 'Сохранить как пресет', () => {
+            const name = prompt('Название пресета:', '');
+            if (!name) return;
+            try {
+                const pts = chart.data.datasets[0].data.map(p => ({...p}));
+                localStorage.setItem(`tm_presets:${name}`, JSON.stringify({
+                    savedN: Math.max(2, +step_ele.value),
+                    points: pts,
+                }));
+            } catch(e) { alert('Не удалось сохранить пресет (превышен лимит localStorage).'); return; }
+            _rebuildPresetDropdown();
+            presetSel.value = name;
+        });
+
+        const delPresetBtn = makeBtn('Del', 'Удалить выбранный пресет', () => {
+            const name = presetSel.value;
+            if (!presetSel._custom[name]) return;
+            if (!confirm(`Удалить пресет "${name}"?`)) return;
+            localStorage.removeItem(`tm_presets:${name}`);
+            _rebuildPresetDropdown();
+        });
+
+        const resetBtn = makeBtn('Reset', 'Сбросить кривую к прямой', () => {
+            const n = Math.max(2, +step_ele.value);
+            chart.data.datasets[0].data = [{x:1,y:1},{x:n,y:n}];
+            saveState(chart); updateChartStyle(); triggerSync(chart);
+        });
+
+        // Undo / Redo
+        const undoBtn = makeBtn('Undo', 'Отменить (Ctrl+Z)', () => undo(chart));
+        const redoBtn = makeBtn('Redo', 'Повторить (Ctrl+Shift+Z)', () => redo(chart));
+
+        // Separator
+        const sep = () => { const s = document.createElement('span'); s.textContent='|'; s.style.opacity='.3'; return s; };
+
+        // Export
+        const exportBtn = makeBtn('Export', 'Сохранить кривую в JSON', () => {
+            const n = prompt('Название пресета:', 'my_curve') || 'my_curve';
+            const data = {
+                name: n, version: 1,
+                points: chart.data.datasets[0].data,
+                interpolation: getInterpMode(),
+            };
+            const blob = new Blob([JSON.stringify(data, null, 2)], {type:'application/json'});
+            const url  = URL.createObjectURL(blob);
+            const a    = document.createElement('a');
+            a.href = url; a.download = `${n.replace(/\s+/g,'_')}.json`; a.click();
+            URL.revokeObjectURL(url);
+        });
+
+        // Import
+        const importBtn = makeBtn('Import', 'Загрузить кривую из JSON', () => {
+            const inp = document.createElement('input');
+            inp.type = 'file'; inp.accept = '.json';
+            inp.addEventListener('change', () => {
+                const file = inp.files[0]; if (!file) return;
+                const reader = new FileReader();
+                reader.onload = ev => {
+                    try {
+                        const d = JSON.parse(ev.target.result);
+                        if (!Array.isArray(d.points)) return;
+                        const n = Math.max(2, +step_ele.value);
+                        const pts = d.points.filter(p => p.x>=1&&p.x<=n&&p.y>=1&&p.y<=n);
+                        chart.data.datasets[0].data = pts;
+                        updateSteps(chart, n);
+                        saveState(chart); triggerSync(chart);
+                    } catch(err) { console.error('[TimeMachine] Import error:', err); }
+                };
+                reader.readAsText(file);
+            });
+            inp.click();
+        });
+
+        // Show sigma
+        const sigmaBtn = makeBtn('Sigma', 'Показать σ-значения на оси Y (реальные через HTTP, fallback Karras)', () => {
+            showSigma = !showSigma;
+            sigmaBtn.textContent = showSigma ? 'Step' : 'Sigma';
+            chart.update(); if (hr_chart) hr_chart.update();
+        });
+
+        // ── Panel system ───────────────────────────────────────���────────
+        let _panelDiv = null;
+        function _closePanel() { if (_panelDiv) { _panelDiv.remove(); _panelDiv = null; } }
+
+        function _openPanel(title, buildFn) {
+            _closePanel();
+            const d = document.createElement('div');
+            d.id = id('panel');
+            d.style.cssText = 'padding:8px;margin:4px 0;border:1px solid rgba(255,140,0,0.3);border-radius:6px;background:rgba(255,140,0,0.05);font-size:13px';
+            const h = document.createElement('div');
+            h.style.cssText = 'font-weight:bold;margin-bottom:6px';
+            h.textContent = title;
+            d.appendChild(h);
+            buildFn(d);
+            $('#' + id('container')).appendChild(d);
+            _panelDiv = d;
+        }
+
+        // ── Gen… (procedural curves) ────────────────────────────────────
+        const genBtn = makeBtn('Gen…', 'Сгенерировать кривую (синус / случайная)', () => {
+            let prevData = chart.data.datasets[0].data.slice();
+            function getN() { return Math.max(2, +step_ele.value); }
+
+            function _sine(freq, amp) {
+                const n = getN();
+                const pts = [{x:1,y:1}];
+                for (let x = 2; x < n; x++) {
+                    const t = (x-1)/(n-1);
+                    const mid = 1 + (n-1)*t;
+                    const y = Math.round(mid + amp*(n-1)*Math.sin(2*Math.PI*freq*t));
+                    pts.push({x, y: Math.max(1, Math.min(n, y))});
+                }
+                pts.push({x:n, y:n});
+                return pts;
+            }
+
+            function _walk(stepSz, seed) {
+                const n = getN();
+                let rng = seed || Date.now();
+                function rand() { rng ^= rng<<13; rng ^= rng>>17; rng ^= rng<<5; return (rng>>>0)/4294967296; }
+                const pts = [{x:1,y:1}];
+                let y = 1;
+                for (let x = 2; x < n; x++) {
+                    y += (rand()-0.5)*2*stepSz;
+                    y = Math.max(1, Math.min(n, Math.round(y)));
+                    pts.push({x, y});
+                }
+                pts.push({x:n, y:n});
+                return pts;
+            }
+
+            _openPanel('Generate Curve', panel => {
+                const row1 = document.createElement('div');
+                row1.style.cssText = 'display:flex;gap:6px;align-items:center;margin-bottom:4px';
+                const sel = document.createElement('select');
+                sel.innerHTML = '<option>Sine</option><option>Random walk</option>';
+
+                const p1Label = document.createElement('span');
+                p1Label.style.cssText = 'width:55px;text-align:right';
+                const p1 = document.createElement('input');
+                p1.type = 'range'; p1.min = 0.5; p1.max = 10; p1.step = 0.5; p1.value = 2;
+
+                const p2Label = document.createElement('span');
+                p2Label.style.cssText = 'width:55px;text-align:right';
+                const p2 = document.createElement('input');
+                p2.type = 'range'; p2.min = 0; p2.max = 1; p2.step = 0.05; p2.value = 0.3;
+
+                function updateLabels() {
+                    if (sel.value === 'Sine') {
+                        p1Label.textContent = `Freq: ${p1.value}`;
+                        p1.min = 0.5; p1.max = 10; p1.step = 0.5;
+                        p2Label.textContent = `Amp: ${p2.value}`;
+                        p2.min = 0; p2.max = 1; p2.step = 0.05;
+                    } else {
+                        p1Label.textContent = `Step: ${p1.value}`;
+                        p1.min = 0.1; p1.max = 5; p1.step = 0.1;
+                        p2Label.textContent = `Seed: ${p2.value}`;
+                        p2.min = 0; p2.max = 9999; p2.step = 1;
+                    }
+                }
+
+                function preview() {
+                    const n = getN();
+                    const pts = sel.value === 'Sine' ? _sine(+p1.value, +p2.value) : _walk(+p1.value, +p2.value);
+                    chart.data.datasets[0].data = pts;
+                    updateSteps(chart, n);
+                    chart.update();
+                }
+
+                sel.addEventListener('change', () => { updateLabels(); preview(); });
+                p1.addEventListener('input', () => { updateLabels(); preview(); });
+                p2.addEventListener('input', () => { updateLabels(); preview(); });
+                updateLabels(); preview();
+
+                const apply = makeBtn('Apply', '', () => {
+                    saveState(chart); updateChartStyle(); triggerSync(chart);
+                    _closePanel();
+                });
+                const cancel = makeBtn('Cancel', '', () => {
+                    const n = getN();
+                    chart.data.datasets[0].data = prevData;
+                    updateSteps(chart, n); chart.update();
+                    _closePanel();
+                });
+                row1.append(sel, p1Label, p1, p2Label, p2, apply, cancel);
+                panel.appendChild(row1);
+            });
+        });
+
+        // ── Rasterize control points → dense array of length n ───────
+        const _WEIGHT = {
+            'Ease In':     t => t * t,
+            'Ease Out':    t => 1 - (1-t)*(1-t),
+            'Ease In-Out': t => t*t*(3-2*t),
+            'Cubic':       t => t*t*t,
+            'Exponential': t => Math.pow(2,t)-1,
+            'Step':        t => 0,
+        };
+
+        function _rasterize(pts, n) {
+            const sorted = [...pts].sort((a,b)=>a.x-b.x);
+            const out = [];
+            let si = 0;
+            for (let x = 1; x <= n; x++) {
+                while (si < sorted.length-2 && sorted[si+1].x <= x) si++;
+                const p0 = sorted[si], p1 = sorted[Math.min(si+1, sorted.length-1)];
+                let y;
+                if (p0.x === p1.x) { y = p0.y; }
+                else {
+                    const mode = p0.mode || '';
+                    const t = (x-p0.x)/(p1.x-p0.x);
+                    if (mode === 'Step') { y = p0.y; }
+                    else {
+                        const w = _WEIGHT[mode] || (t => t);
+                        y = p0.y + w(t) * (p1.y - p0.y);
+                    }
+                }
+                out.push({x, y: Math.max(1, Math.min(n, Math.round(y)))});
+            }
+            return out;
+        }
+
+        // ── Blend… ──────────────────────────────────────────────────────
+        const blendBtn = makeBtn('Blend…', 'Смешать два пресета', () => {
+            const n = Math.max(2, +step_ele.value);
+            let prevData = chart.data.datasets[0].data.slice();
+            const allPresets = {...PRESETS, ...presetSel._custom};
+            const names = Object.keys(allPresets);
+
+            _openPanel('Blend Presets', panel => {
+                const row = document.createElement('div');
+                row.style.cssText = 'display:flex;gap:6px;align-items:center;flex-wrap:wrap';
+
+                const sA = document.createElement('select');
+                const sB = document.createElement('select');
+                names.forEach(name => { sA.innerHTML += `<option>${name}</option>`; sB.innerHTML += `<option>${name}</option>`; });
+                if (names.length > 1) sB.selectedIndex = 1;
+
+                const sl = document.createElement('input');
+                sl.type = 'range'; sl.min = 0; sl.max = 100; sl.value = 50;
+                const slLabel = document.createElement('span');
+                slLabel.style.cssText = 'width:40px';
+
+                function _getPresetFn(name) { return PRESETS[name] || presetSel._custom[name]; }
+
+                function _blend() {
+                    const fnA = _getPresetFn(sA.value);
+                    const fnB = _getPresetFn(sB.value);
+                    if (!fnA || !fnB) return null;
+                    const cA = fnA(n), cB = fnB(n);
+                    const denseA = _rasterize(cA, n);
+                    const denseB = _rasterize(cB, n);
+                    const t = +sl.value / 100;
+                    slLabel.textContent = `${sl.value}%`;
+                    return denseA.map((pt, i) => ({
+                        x: pt.x,
+                        y: Math.round(pt.y*(1-t) + denseB[i].y*t),
+                    }));
+                }
+
+                function preview() { const pts = _blend(); if (pts) { chart.data.datasets[0].data = pts; updateSteps(chart, n); chart.update(); } }
+
+                sA.addEventListener('change', preview);
+                sB.addEventListener('change', preview);
+                sl.addEventListener('input', preview);
+                preview();
+
+                const apply = makeBtn('Apply', '', () => { saveState(chart); updateChartStyle(); triggerSync(chart); _closePanel(); });
+                const cancel = makeBtn('Cancel', '', () => { chart.data.datasets[0].data = prevData; updateSteps(chart, n); chart.update(); _closePanel(); });
+
+                row.append(sA, sB, sl, slLabel, apply, cancel);
+                panel.appendChild(row);
+            });
+        });
+
+        bar.append(presetSel, applyBtn, savePresetBtn, delPresetBtn, resetBtn, sep(), undoBtn, redoBtn, sep(), exportBtn, importBtn, sep(), sigmaBtn, genBtn, blendBtn);
+        $('#' + id('container')).appendChild(bar);
+
+        // ── One-shot: автосброс Enabled после генерации ────────────────
+        // Паттерн из script.js A1111: следим за interruptBtn.style.display
+        if (oneShotEl) {
+            const interruptBtn = gradioApp().querySelector(`#${mode}_interrupt`);
+            if (interruptBtn) {
+                let wasGen = false;
+                new MutationObserver(() => {
+                    const isGen = interruptBtn.style.display === 'block';
+                    if (isGen && !wasGen) {
+                        wasGen = true;
+                    } else if (!isGen && wasGen) {
+                        wasGen = false;
+                        if (oneShotEl.checked && enabled?.checked) {
+                            enabled.checked = false;
+                            enabled.dispatchEvent(new Event('change', { bubbles: true }));
+                        }
+                    }
+                }).observe(interruptBtn, { attributes: true, attributeFilter: ['style'] });
+            }
+        }
+    }
+
+    // ── Общие функции ────────────────────────────────────────────────
+
+    function createInitialData() {
+        return { datasets: [{
+            type:'line', showLine:true, tension:0,
+            backgroundColor:'rgba(255,140,0,.6)', borderColor:'rgba(255,140,0,.6)',
+            borderWidth:2, borderCapStyle:'round', borderJoinStyle:'round',
+            borderDash:[], borderDashOffset:0,
+            pointBorderColor:'rgba(255,140,0,.6)', pointBackgroundColor:'rgba(255,140,0,.6)',
+            pointBorderWidth:1, pointHoverBorderWidth:10, pointRadius:5, pointHitRadius:10,
+            fill:false, data:[],
+        }]};
+    }
+
+    function createChartOption() {
+        return {
+            responsive:false,
+            events:['mouseup','mousedown','mousemove','mouseout','click','touchstart','touchmove'],
+            scales:{
+                x:{type:'linear',display:true,title:{display:true,text:'timesteps'},ticks:{major:{enabled:true}},min:0,max:100,stepSize:10},
+                y:{type:'linear',display:true,title:{display:true,text:'actual timesteps'},ticks:{major:{enabled:true}},min:0,max:100,stepSize:10},
+            },
+            chartArea:{backgroundColor:'rgba(255,255,255,1)'},
+            animation:{duration:100},
+            plugins:{legend:{display:false},tooltip:{callbacks:{
+                title:ctxs=>ctxs.map(c=>`${c.parsed.x} → ${c.parsed.y}`), label:()=>'',
+            }}},
+        };
+    }
+
+    function createPlugins(canvas, step_ele, cutoffEl) {
+        const plugins = [{
+            id:'dragpoint',
+            beforeEvent(chart, args) {
+                const t = args.event.type;
+                if (t === 'mousedown') {
+                    const btn = args.event.native.button;
+                    if      (btn===0) this.startDrag(chart, args);
+                    else if (btn===2) this.removePoint(chart, args);
+                } else if (t==='mouseup'||t==='mouseout') {
+                    if (this.dragctx.item) this.endDrag(chart, args);
+                } else if (t==='mousemove') {
+                    if (this.dragctx.item) this.onDrag(chart, args);
+                }
+            },
+            afterDraw(chart) {
+                const ctx = chart.ctx; ctx.save();
+                // Cutoff line
+                const cs = cutoffEl ? +cutoffEl.value : 0;
+                if (cs > 0) {
+                    const xa = chart.scales.x, ya = chart.scales.y, x = xa.getPixelForValue(cs);
+                    ctx.beginPath(); ctx.setLineDash([6, 4]); ctx.strokeStyle = 'rgba(220,50,50,0.6)';
+                    ctx.lineWidth = 2; ctx.moveTo(x, ya.top); ctx.lineTo(x, ya.bottom); ctx.stroke();
+                }
+                // Per-segment mode indicators
+                const data = chart.data.datasets[0].data;
+                for (let i = 0; i < data.length - 1; i++) {
+                    const mode = data[i].mode;
+                    if (!mode) continue;
+                    const x0 = chart.scales.x.getPixelForValue(data[i].x);
+                    const y0 = chart.scales.y.getPixelForValue(data[i].y);
+                    const x1 = chart.scales.x.getPixelForValue(data[i+1].x);
+                    const y1 = chart.scales.y.getPixelForValue(data[i+1].y);
+                    const mx = (x0+x1)/2, my = (y0+y1)/2;
+                    ctx.beginPath(); ctx.arc(mx, my, 5, 0, 2*Math.PI);
+                    ctx.fillStyle = '#ff8c00'; ctx.fill();
+                    ctx.strokeStyle = '#fff'; ctx.lineWidth = 1; ctx.stroke();
+                    ctx.fillStyle = '#fff';
+                    ctx.font = 'bold 8px sans-serif';
+                    ctx.textAlign = 'center'; ctx.textBaseline = 'middle';
+                    ctx.fillText(mode[0], mx, my);
+                }
+                ctx.restore();
+            },
+            dragctx:{item:null, max_steps:()=>Math.max(1,+step_ele.value)},
+            lastRemoved:false,
+            startDrag(chart,args){const item=this.getItem(chart,args);if(item)this.dragctx.item=item;else this.addPoint(chart,args);},
+            onDrag(chart,args){const y=this.getY(chart,args);const{datasetIndex,index}=this.dragctx.item;const item=chart.data.datasets[datasetIndex].data[index];if(item.y!==y){item.y=y;chart.update();}},
+            endDrag(chart){this.dragctx.item=null;},
+            addPoint(chart,args){const x=this.getX(chart,args),y=this.getY(chart,args);const found=chart.data.datasets[0].data.find(v=>v.x===x);if(found){if(found.y!==y){found.y=y;chart.update();}}else this.addItem(chart,{x,y});},
+            removePoint(chart,args){const item_=this.getItem(chart,args);if(item_){const{datasetIndex,index}=item_;const item=chart.data.datasets[datasetIndex].data[index];if(1<item.x&&item.x<this.dragctx.max_steps()){this.lastRemoved=true;chart.data.datasets[datasetIndex].data.splice(index,1);chart.update();}}},
+            getX(chart,args){const xx=chart.scales.x.getValueForPixel(args.event.native.clientX-chart.canvas.getBoundingClientRect().left);return Math.max(1,Math.min(Math.round(xx),this.dragctx.max_steps()));},
+            getY(chart,args){const yy=chart.scales.y.getValueForPixel(args.event.native.clientY-chart.canvas.getBoundingClientRect().top);return Math.max(1,Math.min(Math.round(yy),this.dragctx.max_steps()));},
+            getItem(chart,args){const items=chart.getElementsAtEventForMode(args.event,'nearest',{intersect:true},false);return items.length===0?null:items[0];},
+            addItem(chart,xy,donotupdate){chart.data.datasets[0].data.push(xy);chart.data.datasets[0].data.sort((a,b)=>a.x-b.x);if(!donotupdate)chart.update();},
+        }];
+
+        return plugins;
+    }
+
+    function updateSteps(chart, max_steps) {
+        max_steps = Math.max(2, max_steps);
+        chart.options.scales.x.max = max_steps+1;
+        chart.options.scales.y.max = max_steps+1;
+        const data = chart.data.datasets[0].data;
+        const new_data = [];
+        for (const pt of data) if(1<=pt.x&&pt.x<=max_steps) new_data.push({...pt, y:Math.min(pt.y,max_steps)});
+        if (!new_data.find(c=>c.x===1))         new_data.unshift({x:1,        y:1});
+        if (!new_data.find(c=>c.x===max_steps)) new_data.push   ({x:max_steps,y:max_steps});
+        chart.data.datasets[0].data = new_data;
+        chart.update();
+    }
+
+})('TimeMachine');

sd-webui-timemachine-fixed/scripts/timemachine.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+
+import os
+import json
+import bisect
+from typing import Any, List, Callable
+
+import gradio as gr
+
+from modules.processing import StableDiffusionProcessing
+from modules import scripts, extensions, script_callbacks
+from fastapi.responses import JSONResponse
+
+from scripts.timemachinelib import sampler as sampler_utils
+from scripts.timemachinelib.xyz import init_xyz
+
+NAME         = 'TimeMachine'
+_UNSUPPORTED = sampler_utils.UNSUPPORTED_SAMPLERS
+
+
+class Script(scripts.Script):
+
+    def title(self):
+        return NAME
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        ext = _get_self_extension()
+        if ext is not None and not is_img2img:
+            js_ = [f'{x.path}?{os.path.getmtime(x.path)}'
+                   for x in ext.list_files('javascript/modules', '.js')]
+            js_.insert(0, ext.path)
+            gr.HTML(value='\n'.join(js_), elem_id=f'{NAME.lower()}-js_modules')
+
+        mode = 'img2img' if is_img2img else 'txt2img'
+        id_  = lambda x: f'{NAME.lower()}-{mode}-{x}'
+        js_  = lambda s: f'globalThis["{id_(s)}"]'
+
+        with gr.Accordion(NAME, open=False, elem_id=id_('accordion')):
+            with gr.Row():
+                enabled = gr.Checkbox(label='Enabled', value=False, elem_id=id_('enabled'))
+                scheduler = gr.Dropdown(
+                    label='Scheduler', choices=sampler_utils.get_scheduler_choices(),
+                    value='Use sampler default', elem_id=id_('scheduler'))
+                interp_mode = gr.Dropdown(
+                    label='Interpolation', choices=['Linear', 'Smooth (spline)', 'Step', 'Monotone', 'Ease In', 'Ease Out', 'Ease In-Out', 'Cubic', 'Exponential'],
+                    value='Linear', elem_id=id_('interpolation'))
+
+            with gr.Row():
+                cutoff_steps = gr.Number(
+                    label='Cutoff step (0=off)', value=0, minimum=0, maximum=150,
+                    step=1, elem_id=id_('cutoff'))
+                hr_cutoff_cb = gr.Checkbox(
+                    label='HR Cutoff', value=True, elem_id=id_('hr_cutoff'))
+                one_shot = gr.Checkbox(
+                    label='One-shot', value=False, elem_id=id_('one_shot'))
+
+            gr.HTML(elem_id=id_('container'))
+
+            with gr.Accordion('HR Fix Curve (txt2img only)', open=False,
+                              elem_id=id_('hr_accordion')):
+                hr_enabled = gr.Checkbox(
+                    label='Use separate curve for HR pass', value=False,
+                    elem_id=id_('hr_enabled'))
+                gr.HTML(elem_id=id_('hr_container'))
+
+            with gr.Group(visible=False):
+                sink    = gr.HTML(value='')
+                tm      = _js2py('tm',    id_, js_, sink)
+                hr_sink = gr.HTML(value='')
+                tm_hr   = _js2py('tm_hr', id_, js_, hr_sink)
+
+        return [enabled, scheduler, interp_mode, tm, hr_enabled, tm_hr, cutoff_steps, hr_cutoff_cb, one_shot]
+
+    def process_batch(
+        self,
+        p: StableDiffusionProcessing,
+        enabled: bool,
+        scheduler: str,
+        interp_mode: str,
+        tm: str,
+        hr_enabled: bool,
+        tm_hr: str,
+        cutoff_steps: int = 0,
+        hr_cutoff_enabled: bool = True,
+        one_shot: bool = False,
+        **kwargs,
+    ):
+        if not enabled:
+            return
+        if not tm or not tm.strip():
+            return
+        if p.sampler_name in _UNSUPPORTED:
+            msg = (f'⚠ {p.sampler_name!r} несовместим: '
+                   f'принимает sigma_min/max/n, не массив sigmas. '
+                   f'Используйте: Euler, DPM++ 2M, DPM++ SDE, Heun, LMS и др.')
+            print(f'\n[TimeMachine] {msg}\n')
+            gr.Warning(f'[TimeMachine] {msg}')
+            return
+
+        vs = _parse_points(tm)
+        if vs is None:
+            return
+
+        if len(vs) < 2 or 1 not in vs or p.steps not in vs:
+            points = [{'x': k, 'y': v['y'], 'mode': v.get('mode')} for k, v in sorted(vs.items())]
+            msg = (f'Кривая должна содержать точки x=1 и x={p.steps} '
+                   f'(текущие x: {[p["x"] for p in points]})')
+            print(f'[TimeMachine] {msg}')
+            gr.Warning(f'[TimeMachine] {msg}')
+            return
+
+        steps_float = _interpolate(vs, p.steps, interp_mode)
+        if len(steps_float) != p.steps:
+            return
+
+        cs = int(cutoff_steps)
+        steps_float = _apply_cutoff(steps_float, cs, p.steps)
+
+        if scheduler == 'Use sampler default':
+            sched_name = sampler_utils.get_default_scheduler_for(p)
+        else:
+            from modules import sd_schedulers
+            sched_name = next(
+                (s.name for s in sd_schedulers.schedulers if s.label == scheduler),
+                'karras')
+
+        override_main = sampler_utils.build_sigma_override(steps_float, sched_name)
+        override_hr   = _build_hr_override(p, hr_enabled, tm_hr, interp_mode, sched_name, cs, hr_cutoff_enabled)
+
+        if override_hr is not None:
+            def combined(n: int):
+                return override_hr(n) if getattr(p, 'is_hr_pass', False) else override_main(n)
+            p.sampler_noise_scheduler_override = combined
+        else:
+            p.sampler_noise_scheduler_override = override_main
+
+        p._timemachine_override_set = True
+        p.extra_generation_params.update({
+            f'{NAME} Enabled':       True,
+            f'{NAME} Interpolation': interp_mode,
+            f'{NAME} Steps':         [round(t, 3) for t in steps_float],
+            f'{NAME} Scheduler':     sched_name,
+            f'{NAME} Cutoff':        cs,
+            f'{NAME} One-shot':      one_shot,
+        })
+
+    def postprocess_batch(self, p, *args, **kwargs):
+        if getattr(p, '_timemachine_override_set', False):
+            p.sampler_noise_scheduler_override = None
+            p._timemachine_override_set = False
+
+
+# ── Интерполяция ──────────────────────────────────────────
+
+def _sliding_pairs(xs):
+    for i in range(len(xs) - 1):
+        yield xs[i], xs[i + 1]
+
+
+def _find_segment(xs: list, step: int) -> int:
+    i = bisect.bisect_right(xs, step) - 1
+    return max(0, min(i, len(xs) - 2))
+
+
+_WEIGHT_FUNCS: dict[str, Callable[[float], float]] = {
+    'Ease In':       lambda t: t * t,
+    'Ease Out':      lambda t: 1.0 - (1.0 - t) * (1.0 - t),
+    'Ease In-Out':   lambda t: t * t * (3.0 - 2.0 * t),
+    'Cubic':         lambda t: t ** 3,
+    'Exponential':   lambda t: 2.0 ** t - 1.0,
+}
+_GLOBAL_MODES = frozenset({'Smooth (spline)', 'Step', 'Monotone'})
+
+
+def _interpolate_segments(vs: dict, n: int, default_mode: str = 'Linear', ignore_per_segment: bool = False) -> List[float]:
+    default_weight_fn = _WEIGHT_FUNCS.get(default_mode, lambda t: t)
+    steps: List[float] = []
+    for min_x, max_x in _sliding_pairs(sorted(vs.keys())):
+        min_y, max_y = float(vs[min_x]['y']), float(vs[max_x]['y'])
+        seg_mode = default_mode if ignore_per_segment else (vs[min_x].get('mode') or default_mode)
+        if seg_mode == 'Step':
+            for step in range(min_x, max_x):
+                steps.append(min_y)
+        else:
+            wfn = _WEIGHT_FUNCS.get(seg_mode, default_weight_fn)
+            for step in range(min_x, max_x):
+                t = (step - min_x) / (max_x - min_x)
+                steps.append(min_y + wfn(t) * (max_y - min_y))
+    steps.append(float(vs[n]['y']))
+    return steps
+
+
+def _interpolate(vs: dict, n: int, mode: str) -> List[float]:
+    if mode == 'Smooth (spline)': return _compute_remapped_steps_spline(vs, n)
+    if mode == 'Step':            return _compute_remapped_steps_step(vs, n)
+    if mode == 'Monotone':        return _compute_remapped_steps_monotone(vs, n)
+    return _interpolate_segments(vs, n, mode)
+
+
+def _compute_remapped_steps_step(vs: dict, n: int) -> List[float]:
+    return _interpolate_segments(vs, n, default_mode='Step', ignore_per_segment=True)
+
+
+def _compute_remapped_steps_monotone(vs: dict, n: int) -> List[float]:
+    xs = sorted(vs.keys())
+    ys = [float(vs[x]['y']) for x in xs]
+    k  = len(xs)
+
+    if k == 2:
+        return _interpolate_segments(vs, n, ignore_per_segment=True)
+
+    h     = [xs[i+1] - xs[i]          for i in range(k-1)]
+    delta = [(ys[i+1]-ys[i]) / h[i]   for i in range(k-1)]
+
+    m = [0.0] * k
+    m[0]   = delta[0]
+    m[k-1] = delta[k-2]
+    for i in range(1, k-1):
+        p = (delta[i-1]*h[i] + delta[i]*h[i-1]) / (h[i-1]+h[i])
+        if delta[i-1]*delta[i] <= 0:
+            m[i] = 0.0
+        else:
+            sign = 1.0 if p >= 0 else -1.0
+            m[i] = sign * min(abs(p), 2*abs(delta[i-1]), 2*abs(delta[i]))
+
+    steps: List[float] = []
+    for step in range(1, n+1):
+        seg = _find_segment(xs, step)
+        x0, x1 = xs[seg], xs[seg+1]
+        h_s = x1 - x0
+        t   = max(0.0, min(1.0, (step-x0)/h_s if h_s>0 else 1.0))
+        t2, t3 = t*t, t*t*t
+        y = ((2*t3-3*t2+1)*ys[seg] + (t3-2*t2+t)*h_s*m[seg]
+           + (-2*t3+3*t2)*ys[seg+1] + (t3-t2)*h_s*m[seg+1])
+        steps.append(max(1.0, min(float(n), y)))
+    return steps
+
+
+def _catmull_rom(t: float, p0: float, p1: float, p2: float, p3: float) -> float:
+    t2 = t * t; t3 = t2 * t
+    return 0.5 * (2*p1 + (-p0+p2)*t + (2*p0-5*p1+4*p2-p3)*t2 + (-p0+3*p1-3*p2+p3)*t3)
+
+
+def _compute_remapped_steps_spline(vs: dict, n: int) -> List[float]:
+    xs = sorted(vs.keys()); ys = [float(vs[x]['y']) for x in xs]; k = len(xs)
+    y_ext = [2*ys[0]-ys[1]] + ys + [2*ys[-1]-ys[-2]]
+    steps: List[float] = []
+    for step in range(1, n+1):
+        seg = _find_segment(xs, step)
+        x0, x1 = xs[seg], xs[seg+1]
+        t = max(0., min(1., (step-x0)/(x1-x0) if x1>x0 else 1.))
+        i = seg+1
+        y = _catmull_rom(t, y_ext[i-1], y_ext[i], y_ext[i+1], y_ext[i+2])
+        steps.append(max(1., min(float(n), y)))
+    return steps
+
+
+def _apply_cutoff(sf: list[float], cs: int, total: int, blend: int = 4) -> list[float]:
+    """Плавный cutoff: W=blend шагов смешиваем кривую → identity, дальше чистая identity."""
+    if cs <= 0 or cs >= total:
+        return sf
+    out = sf[:]
+    blend_end = min(cs + blend, total)
+    blend_steps = blend_end - cs
+    for i in range(cs, blend_end):
+        alpha = (i - cs + 1) / blend_steps if blend_steps > 0 else 1.0
+        out[i] = out[i] * (1.0 - alpha) + float(i + 1) * alpha
+    for i in range(blend_end, total):
+        out[i] = float(i + 1)
+    return out
+
+
+def _build_hr_override(p, hr_enabled: bool, tm_hr: str, interp_mode: str, sched_name: str,
+                       cutoff_steps: int = 0, hr_cutoff_enabled: bool = True):
+    """Строит override для HR-прохода если все условия выполнены."""
+    if not hr_enabled:
+        return None
+    if not getattr(p, 'enable_hr', False):
+        return None
+    if not tm_hr or not tm_hr.strip():
+        return None
+
+    hr_steps = getattr(p, 'hr_second_pass_steps', 0)
+    if hr_steps <= 0:
+        hr_steps = p.steps
+
+    vs_hr = _parse_points(tm_hr)
+    if vs_hr is None:
+        return None
+
+    if len(vs_hr) < 2 or 1 not in vs_hr or hr_steps not in vs_hr:
+        msg = (f'HR кривая должна содержать x=1 и x={hr_steps} '
+               f'(x: {sorted(vs_hr.keys())})')
+        print(f'[TimeMachine] {msg}')
+        gr.Warning(f'[TimeMachine] {msg}')
+        return None
+
+    sf = _interpolate(vs_hr, hr_steps, interp_mode)
+    if len(sf) != hr_steps:
+        return None
+
+    if hr_cutoff_enabled and cutoff_steps > 0:
+        if hr_steps <= cutoff_steps:
+            hr_cs = max(1, round(cutoff_steps * hr_steps / p.steps))
+        else:
+            hr_cs = cutoff_steps
+        sf = _apply_cutoff(sf, hr_cs, hr_steps)
+
+    return sampler_utils.build_sigma_override(sf, sched_name)
+
+
+# ── Вспомогательные ──────────────────────────────────────
+
+def _parse_points(json_str: str) -> dict[int, dict] | None:
+    try:
+        pts = json.loads(json_str)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(pts, list):
+        return None
+    try:
+        result: dict[int, dict] = {}
+        for v in pts:
+            if isinstance(v, dict) and 'x' in v and 'y' in v:
+                x = int(v['x'])
+                result[x] = {
+                    'y': int(v['y']),
+                    'mode': v.get('mode') or None,
+                }
+        return result
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def _get_self_extension():
+    self_path = os.path.abspath(__file__)
+    for ext in extensions.active():
+        if self_path.startswith(os.path.abspath(ext.path) + os.sep):
+            return ext
+
+
+def _js2py(name: str, id_: Callable, js_: Callable, sink: Any):
+    v_set  = gr.Button(elem_id=id_(f'{name}_set'))
+    v      = gr.Textbox(elem_id=id_(name))
+    v_sink = gr.Textbox()
+    v_set.click(fn=None, _js=js_(name), outputs=[v, v_sink])
+    v_sink.change(fn=None, _js=js_(f'{name}_after'), outputs=[sink])
+    return v
+
+
+init_xyz(Script, NAME)
+sampler_utils.register_ni_samplers()
+
+
+# ── FastAPI: real sigmas for JS ──────────────────────────────
+
+def _resolve_scheduler_label(label: str) -> str:
+    """Конвертирует label из UI во внутреннее имя."""
+    if label in ('Use sampler default', 'Automatic', 'automatic'):
+        return label
+    from modules import sd_schedulers
+    return next((s.name for s in sd_schedulers.schedulers if s.label == label), 'karras')
+
+
+def _on_app_started(demo, app):
+    @app.get("/timemachine/sigmas")
+    def get_sigmas(scheduler: str = 'karras', steps: int = 20,
+                   sampler: str | None = None, a1111_scheduler: str | None = None):
+        try:
+            if scheduler == 'Use sampler default':
+                if a1111_scheduler and a1111_scheduler != 'Automatic':
+                    scheduler = _resolve_scheduler_label(a1111_scheduler)
+                else:
+                    scheduler = sampler_utils.get_default_scheduler_for(
+                        sampler_name=sampler, scheduler_name='Automatic')
+            sigmas = sampler_utils.compute_sigmas(steps, scheduler)
+            return {"sigmas": sigmas.tolist()}
+        except Exception as e:
+            print(f'[TimeMachine] sigmas API error: {e}')
+            return JSONResponse(content={"sigmas": []}, status_code=500)
+
+script_callbacks.on_app_started(_on_app_started)

sd-webui-timemachine-fixed/scripts/timemachinelib/__init__.py

@@ -0,0 +1,16 @@
+from .sampler import (
+    build_sigma_override,
+    compute_sigmas,
+    get_default_scheduler_for,
+    get_scheduler_choices,
+    register_ni_samplers,
+    UNSUPPORTED_SAMPLERS,
+)
+from .xyz import init_xyz
+
+__all__ = [
+    'build_sigma_override', 'compute_sigmas',
+    'get_default_scheduler_for', 'get_scheduler_choices',
+    'register_ni_samplers', 'UNSUPPORTED_SAMPLERS',
+    'init_xyz',
+]

sd-webui-timemachine-fixed/scripts/timemachinelib/sampler.py

@@ -0,0 +1,299 @@
+# timemachinelib/sampler.py — v3.1 (bugfix)
+#
+# Исправления:
+#   - scheduler.need_inner_model → getattr (AttributeError на нестандартных планировщиках)
+#   - scheduler.default_rho     → getattr
+#   - opts.rho/sigma_min/sigma_max/use_old_karras → getattr (отсутствуют в ряде версий)
+#   - Удалён неиспользуемый Optional
+
+from __future__ import annotations
+
+import math
+
+import torch
+from modules import sd_schedulers, devices
+from modules.shared import opts
+
+
+def _build_model_wrap():
+    """k-diffusion denoiser wrapper. Поддерживает SD1/SD2/SDXL/SD3."""
+    from modules import shared
+    import k_diffusion.external
+
+    sd_model = shared.sd_model
+    if hasattr(sd_model, 'create_denoiser'):
+        return sd_model.create_denoiser()
+
+    param    = getattr(sd_model, 'parameterization', 'eps')
+    cls      = (k_diffusion.external.CompVisVDenoiser
+                if param == 'v' else k_diffusion.external.CompVisDenoiser)
+    quantize = getattr(opts, 'enable_quantization', False)
+    return cls(sd_model, quantize=quantize)
+
+
+def compute_sigmas(n: int, scheduler_name: str, model_wrap=None) -> torch.Tensor:
+    """Генерирует n+1 сигм (убывающие, последний = 0)."""
+    if model_wrap is None:
+        model_wrap = _build_model_wrap()
+
+    m_sigma_min = model_wrap.sigmas[0].item()
+    m_sigma_max = model_wrap.sigmas[-1].item()
+
+    # BUG-FIX: getattr вместо прямого обращения — атрибуты могут отсутствовать
+    if getattr(opts, 'use_old_karras_scheduler_sigmas', False):
+        sigma_min, sigma_max = 0.1, 10.0
+    else:
+        raw_min = getattr(opts, 'sigma_min', 0)
+        raw_max = getattr(opts, 'sigma_max', 0)
+        sigma_min = raw_min if raw_min != 0 else m_sigma_min
+        sigma_max = raw_max if raw_max != 0 else m_sigma_max
+
+    scheduler = sd_schedulers.schedulers_map.get(scheduler_name)
+    if scheduler is None or scheduler.function is None:
+        return model_wrap.get_sigmas(n).cpu()
+
+    kwargs: dict = {'sigma_min': sigma_min, 'sigma_max': sigma_max, 'device': devices.cpu}
+
+    # BUG-FIX: getattr с fallback — у нестандартных планировщиков атрибут может отсутствовать
+    if getattr(scheduler, 'need_inner_model', False):
+        kwargs['inner_model'] = model_wrap
+
+    default_rho = getattr(scheduler, 'default_rho', -1)
+    rho         = getattr(opts, 'rho', 0)
+    if default_rho != -1 and rho != 0 and rho != default_rho:
+        kwargs['rho'] = rho
+
+    return scheduler.function(n=n, **kwargs).cpu()
+
+
+def _lerp_sigma(full_sigmas: torch.Tensor, t: float) -> torch.Tensor:
+    """
+    Линейная интерполяция сигмы для дробной позиции t ∈ [1.0, max_idx].
+    t=1.0 → full_sigmas[0] (макс. шум)
+    t=max_idx → full_sigmas[max_idx-1] (мин. ненулевой шум)
+    """
+    n    = len(full_sigmas) - 1           # кол-во ненулевых позиций
+    lo   = max(0, int(math.floor(t)) - 1) # 0-based нижняя граница
+    hi   = min(lo + 1, n - 1)             # 0-based верхняя (не выходим за 0-элемент)
+    frac = t - math.floor(t)
+    return full_sigmas[lo] * (1.0 - frac) + full_sigmas[hi] * frac
+
+
+def build_sigma_override(steps_float: list[float], scheduler_name: str):
+    """
+    Возвращает функцию для p.sampler_noise_scheduler_override.
+
+    steps_float  — float позиции (1-based) в sigma-расписании, одна на каждый UI-шаг.
+    scheduler_name — имя планировщика ('karras', 'exponential', ...)
+    """
+    max_idx = math.ceil(max(steps_float))
+
+    def override(n: int) -> torch.Tensor:
+        """n = p.steps (или +1 при discard_next_to_last_sigma)."""
+        model_wrap  = _build_model_wrap()
+        full_sigmas = compute_sigmas(max_idx, scheduler_name, model_wrap)
+
+        selected = [_lerp_sigma(full_sigmas, t) for t in steps_float]
+
+        delta = n - len(selected)
+        if delta > 0:
+            last    = selected[-1]
+            min_sig = full_sigmas[-2]          # минимальная ненулевая
+            for i in range(1, delta + 1):
+                alpha = i / (delta + 1)
+                selected.append(last * (1.0 - alpha) + min_sig * alpha)
+        elif delta < 0:
+            selected = selected[:n]
+
+        return torch.cat([torch.stack(selected), full_sigmas[-1:]])
+
+    return override
+
+
+def get_default_scheduler_for(p=None, *, sampler_name=None, scheduler_name=None, is_hr_pass=False) -> str:
+    """Резолвит scheduler: сначала p.scheduler (реальный выбор Schedule type),
+    только если 'Automatic' — дефолт, зашитый в конфиге сэмплера.
+    Реплицирует modules/sd_samplers_kdiffusion.py:86-88."""
+    if p is not None:
+        scheduler_name = (p.hr_scheduler if is_hr_pass else p.scheduler) or 'Automatic'
+        sampler_name = p.sampler_name
+    sched = scheduler_name or 'Automatic'
+    if sched == 'Automatic' and sampler_name:
+        from modules import sd_samplers
+        config = sd_samplers.find_sampler_config(sampler_name)
+        sched = (config.options.get('scheduler') if config else None) or 'karras'
+    return sched
+
+
+def get_scheduler_choices() -> list[str]:
+    """Список планировщиков для UI-дропдауна."""
+    skip = {'automatic', 'Automatic'}
+    return ['Use sampler default'] + [
+        s.label
+        for s in sd_schedulers.schedulers
+        if s.name not in skip and s.label not in skip and s.function is not None
+    ]
+
+
+UNSUPPORTED_SAMPLERS = {'DPM fast', 'DPM adaptive'}
+
+
+# ═══════════════════════════════════════════════════════════════
+# Noise Injection (NI) семплеры
+#
+# Физическая идея: когда σ растёт между шагами (Time Travel),
+# латент находится «слишком чистым» для текущего уровня шума.
+# Правильное решение — добавить шум: x += √(σ²_{k+1} − σ²_k) · ε
+#
+# Кастомные циклы обязательны: стандартные сэмплеры k-diffusion
+# не знают о noise injection, и обёртка модели не может обновить
+# x во внешней функции (см. NIModelWrapper — удалена как ошибочная).
+# ═══════════════════════════════════════════════════════════════
+
+import tqdm as _tqdm
+from modules import sd_samplers, sd_samplers_common
+import modules.sd_samplers_kdiffusion as K
+
+
+class TimeMachineEulerNI:
+    """
+    Euler + Noise Injection. Кастомный цикл — NI модифицирует x
+    напрямую, затем вычисляется стандартный Euler-шаг.
+    """
+    @torch.no_grad()
+    def __call__(self, model, x, sigmas, extra_args=None, callback=None, disable=None,
+                 s_churn=0., s_tmin=0., s_tmax=float('inf'), s_noise=1., **kwargs):
+        extra_args  = extra_args or {}
+        s_in        = x.new_ones([x.shape[0]])
+        last_sigma: float | None = None
+        n_steps     = len(sigmas) - 1
+
+        for i in _tqdm.tqdm(range(n_steps), disable=disable):
+            sigma_curr = sigmas[i]
+            sigma_next = sigmas[i + 1]
+
+            # ── Noise Injection (σ выросла → добавить шум) ──────────
+            sv = sigma_curr.item()
+            if last_sigma is not None and sv > last_sigma:
+                delta_var = sv ** 2 - last_sigma ** 2
+                if delta_var > 0:
+                    x = x + torch.randn_like(x) * math.sqrt(delta_var)
+            last_sigma = sv
+
+            # ── s_churn (ε-буст для exploration) ─────────────────────
+            gamma = min(s_churn / n_steps, math.sqrt(2) - 1) if s_tmin <= sv <= s_tmax else 0.
+            sigma_hat = sigma_curr * (gamma + 1)
+            if gamma > 0:
+                eps = torch.randn_like(x) * s_noise
+                x = x + eps * math.sqrt(sigma_hat ** 2 - sv ** 2)
+
+            # ── Euler шаг ────────────────────────────────────────────
+            denoised = model(x, sigma_hat * s_in, **extra_args)
+            if callback is not None:
+                callback({'x': x, 'i': i, 'sigma': sigma_hat,
+                          'sigma_hat': sigma_hat, 'denoised': denoised})
+
+            d = (x - denoised) / sigma_hat
+            dt = sigma_next - sigma_hat
+            x = x + d * dt
+
+        return x
+
+
+class TimeMachineDPM2MNI:
+    """
+    DPM++ 2M + Noise Injection.
+
+    Кастомный цикл: при NI кеш old_denoised сбрасывается,
+    иначе второй порядок использует значение с неверного состояния.
+    """
+    @torch.no_grad()
+    def __call__(self, model, x, sigmas, extra_args=None, callback=None, disable=None, **kwargs):
+        extra_args  = extra_args or {}
+        s_in        = x.new_ones([x.shape[0]])
+        sigma_fn    = lambda t: t.neg().exp()
+        t_fn        = lambda s: s.log().neg()
+        old_denoised = None
+        last_sigma: float | None = None
+
+        for i in _tqdm.tqdm(range(len(sigmas) - 1), disable=disable):
+            sigma_curr = sigmas[i]
+            sigma_next = sigmas[i + 1]
+
+            # ── Noise Injection ───────────────────────────��──────────
+            sv = sigma_curr.item()
+            if last_sigma is not None and sv > last_sigma:
+                delta_var = sv ** 2 - last_sigma ** 2
+                if delta_var > 0:
+                    x = x + torch.randn_like(x) * math.sqrt(delta_var)
+                old_denoised = None          # кеш невалиден после re-noise
+            last_sigma = sv
+
+            # ── DPM++ 2M шаг ─────────────────────────────────────────
+            denoised = model(x, sigma_curr * s_in, **extra_args)
+            if callback is not None:
+                callback({'x': x, 'i': i, 'sigma': sigma_curr,
+                          'sigma_hat': sigma_curr, 'denoised': denoised})
+
+            t, t_next = t_fn(sigma_curr), t_fn(sigma_next)
+            h = t_next - t
+
+            if old_denoised is None or sigma_next == 0 or h == 0:
+                # Euler: первый шаг, после NI-сброса, последний шаг,
+                # или flat sigma (h=0 — деление на ноль в 2M формулах)
+                x = (sigma_fn(t_next) / sigma_fn(t)) * x - (-h).expm1() * denoised
+            else:
+                # DPM++ 2M второй порядок
+                h_last = t - t_fn(sigmas[i - 1])
+                r = h_last / h
+                denoised_d = (1 + 1 / (2 * r)) * denoised - (1 / (2 * r)) * old_denoised
+                x = (sigma_fn(t_next) / sigma_fn(t)) * x - (-h).expm1() * denoised_d
+
+            old_denoised = denoised
+
+        return x
+
+
+# ─────────────────────────────────────────────────────────────────
+# Регистрация NI семплеров в A1111 с поддержкой s_churn
+# ─────────────────────────────────────────────────────────────────
+
+class _TMSampler(K.KDiffusionSampler):
+    """
+    Обёртка над KDiffusionSampler, которая форсирует extra_params
+    для s_churn/s_tmin/s_tmax/s_noise (родной A1111 маппинг
+    sampler_extra_params не работает для TM-сэмплеров, т.к.
+    ключуется по строковому имени функции, а у нас — объект).
+    """
+    def __init__(self, func, sd_model, options=None):
+        super().__init__(func, sd_model, options)
+        self.extra_params = ['s_churn', 's_tmin', 's_tmax', 's_noise']
+
+
+def register_ni_samplers() -> None:
+    """
+    Добавляет 'TM Euler (NI)' и 'TM DPM++ 2M (NI)' в список семплеров A1111.
+    Используются совместно с TimeMachine: sigma override задаёт расписание,
+    NI добавляет физически правильный шум при backward-шагах.
+    Без TimeMachine ведут себя идентично Euler / DPM++ 2M (NI не срабатывает).
+    """
+    ni_entries = [
+        ('TM Euler (NI)',     TimeMachineEulerNI(),  ['k_tm_euler_ni'],    {}),
+        ('TM DPM++ 2M (NI)', TimeMachineDPM2MNI(),  ['k_tm_dpmpp2m_ni'], {'scheduler': 'karras'}),
+    ]
+    added = False
+    for label, func, aliases, options in ni_entries:
+        if label not in [x.name for x in sd_samplers.all_samplers]:
+            # default-аргументы f= и o= фиксируют текущие значения в closure
+            data = sd_samplers_common.SamplerData(
+                label,
+                lambda model, f=func, o=options: _TMSampler(f, model, options=o),
+                aliases,
+                options,
+            )
+            sd_samplers.all_samplers.append(data)
+            added = True
+
+    if added:
+        sd_samplers.set_samplers()
+        sd_samplers.all_samplers_map = {x.name: x for x in sd_samplers.all_samplers}

sd-webui-timemachine-fixed/scripts/timemachinelib/xyz.py

@@ -0,0 +1,74 @@
+# xyz.py — v7: индексы под UI с 9 компонентами
+# [enabled, scheduler, interp_mode, tm, hr_enabled, tm_hr, cutoff_steps, hr_cutoff, one_shot]
+#   0=enabled  1=scheduler  2=interp  4=hr_enabled  6=cutoff_steps  7=hr_cutoff  8=one_shot
+
+import os
+
+from modules import scripts
+from modules.processing import StableDiffusionProcessingTxt2Img
+
+
+def __set_value(p, script, index, value):
+    args = list(p.script_args)
+    all_s = (scripts.scripts_txt2img.scripts if isinstance(p, StableDiffusionProcessingTxt2Img)
+             else scripts.scripts_img2img.scripts)
+    for idx in [x.args_from for x in all_s if isinstance(x, script)]:
+        if idx is not None:
+            args[idx + index] = value
+    p.script_args = type(p.script_args)(args)
+
+
+def to_bool(v: str):
+    if not v: return False
+    v = v.strip().lower()
+    if v == 'true':  return True
+    if v == 'false': return False
+    try: return bool(int(v))
+    except (ValueError, TypeError):
+        raise ValueError('value must be True/False/1/0')
+
+
+class AxisOptions:
+    def __init__(self, AxisOption, axis_options):
+        self.AxisOption = AxisOption; self.target = axis_options; self.options = []
+    def __enter__(self): self.options.clear(); return self
+    def __exit__(self, *_):
+        for opt in self.options: self.target.append(opt)
+        self.options.clear()
+    def create(self, name, type_fn, action, choices=None):
+        return (self.AxisOption(name, type_fn, action, choices=lambda: choices)
+                if choices else self.AxisOption(name, type_fn, action))
+    def add(self, opt): self.options.append(opt)
+
+
+_xyz_registered = False
+
+def init_xyz(script, ext_name):
+    global _xyz_registered
+    if _xyz_registered: return
+    for data in scripts.scripts_data:
+        if os.path.basename(data.path) not in ('xy_grid.py','xyz_grid.py'): continue
+        if not hasattr(data.module,'AxisOption') or not hasattr(data.module,'axis_options'): continue
+        AO = data.module.AxisOption; ao = data.module.axis_options
+        if not isinstance(AO, type) or not isinstance(ao, list): continue
+        try: _create_options(script, ext_name, AO, ao)
+        except Exception as e:
+            print(f'[TimeMachine] Не удалось зарегистрировать XYZ-опции: {e}')
+    _xyz_registered = True
+
+
+def _create_options(script, ext_name, AO, ao):
+    from scripts.timemachinelib.sampler import get_scheduler_choices
+    with AxisOptions(AO, ao) as opts:
+        def define(param, index, type_fn, choices=None):
+            def fn(p, x, xs): __set_value(p, script, index, x)
+            return opts.create(f'{ext_name} {param}', type_fn, fn, choices)
+        for opt in [
+            define('Enabled',       0, to_bool, ['false','true']),
+            define('Scheduler',     1, str,     get_scheduler_choices()),
+            define('Interpolation', 2, str,     ['Linear','Smooth (spline)','Step','Monotone','Ease In','Ease Out','Ease In-Out','Cubic','Exponential']),
+            define('HR Enabled',    4, to_bool, ['false','true']),
+            define('Cutoff Steps',  6, int),
+            define('HR Cutoff',     7, to_bool, ['false','true']),
+            define('One-shot',      8, to_bool, ['false','true']),
+        ]: opts.add(opt)