Upload 4 files

!0000-a1111-fix/CHANGES.md

@@ -0,0 +1,98 @@
+# Что изменилось и почему
+
+Всё ниже проверено кодом, а не на словах: тестовые скрипты и их вывод — в
+конце файла. Каждый пункт можно перепроверить самостоятельно.
+
+## Новое: `extensions/!0000-a1111-fix/scripts/backend_watchdog.py`
+
+Главный кусок. Отвечает на исходный вопрос ("зависает + пропадает API"),
+которого `fix.js` в принципе не касался, потому что тот живёт только в
+браузере.
+
+- Патчит `modules.fifo_lock.FIFOLock` **на уровне класса** (не инстанса —
+  `with queue_lock:` вызывает `type(queue_lock).__enter__`, инстанс-патч
+  `queue_lock.acquire = ...` для `with` был бы просто проигнорирован).
+  `queue_lock` — один и тот же объект, которым и кнопка Generate в UI
+  (`modules/ui.py:417`), и каждый `/sdapi/v1/*` роут (`modules/api/api.py`)
+  сериализуют вызовы. Если что-то держит его дольше `A1111_FIX_LOCK_WARN_SECONDS`
+  (по умолчанию 20с), в лог идёт: кто держит, с какой точки был взят лок,
+  сколько вызовов стоит в очереди, и живой stack trace потока-держателя —
+  то есть прямо строка кода, на которой всё встало.
+- Оборачивает `modules.script_loading.load_module`, засекая время импорта
+  каждого расширения по отдельности (по полному пути, не по имени файла —
+  так `xy_grid.py` из разных расширений не сливаются в одну запись).
+  Если импорт идёт дольше `A1111_FIX_IMPORT_WARN_SECONDS` (по умолчанию
+  15с) — предупреждение прямо во время зависания, а не только постфактум.
+- Отдаёт то же самое через `GET /internal/a1111-fix/status` (JSON), и
+  печатает топ самых медленных импортов один раз в лог при старте.
+- Всё обёрнуто в try/except на каждом уровне: если в другом форке A1111
+  что-то из этого не совпадает по сигнатуре — модуль один раз пишет об
+  этом в лог и отключает соответствующую часть, а не роняет запуск.
+
+## Исправлено: `modules/ui_gradio_extensions.py`
+
+`_FIX_MARKERS` проверял вхождение подстроки `"fix.js"` в путь **любого**
+скрипта — значит `polyfix.js` или `ie11-fix.js` из чужого расширения
+ошибочно попадали в категорию `fix_extension`. Заменено на точное
+сравнение имени папки расширения (`0000-a1111-fix`, с учётом
+опционального `!`-префикса). Всё остальное в файле не тронуто — там
+проблем не было.
+
+## Исправлено: `extensions/!0000-a1111-fix/metadata.ini`
+
+- `canvas-zoom` / `sd-webui-canvas-zoom` не совпадали с реальной папкой
+  встроенного расширения в этом репозитории — она называется
+  `canvas-zoom-and-pan`. Directive молча ни на что не влиял. Добавлено
+  верное имя через синтаксис `alt1|alt2|alt3` (выбирает первую реально
+  установленную альтернативу, см. `modules/extensions.py:get_script_requirements`).
+- Добавлена секция `[scripts/backend_watchdog.py]` с `Before`, перечисляющим
+  все папки из `extensions-builtin/` явно — по-другому раньше builtin'ов
+  забраться нельзя: A1111 полностью сканирует `extensions-builtin/`
+  раньше, чем вообще заглядывает в `extensions/`, независимо от имени
+  папки.
+- Добавлены комментарии: почему `Name =` в `[Extension]` не влияет на
+  сопоставление (реально используется имя папки — это баг/особенность
+  самого A1111, не этого файла), и почему `Before` для `fix.js`
+  не строго обязателен для того, как сейчас устроены сами патчи.
+
+## Дополнено: `extensions/!0000-a1111-fix/javascript/fix.js`
+
+Добавлена `window.__a1111FixBackendStatus()` — фетчит
+`/internal/a1111-fix/status` и печатает единую картину (лок + импорты).
+`window.__a1111FixReport()` теперь дополнительно вызывает её (fire-and-forget),
+но остаётся **синхронной** и возвращает то же самое, что раньше — ничего
+из существующего кода, читающего результат сразу, не сломано. Если
+`backend_watchdog.py` не установлен или сервер недоступен — один
+короткий лог, без исключений.
+
+## Проверено (не только прочитано — выполнено)
+
+- `backend_watchdog.py`: 26/26 проверок в `run_test.py`, включая настоящий
+  `modules/fifo_lock.py` из этого репозитория (не мок) — подтверждён и
+  сам факт перехвата `with queue_lock:`, и то, что реальная взаимная
+  исключительность не сломана, и что watchdog реально ловит долгий hold
+  и зависший импорт вживую, до его завершения.
+- `ui_gradio_extensions.py`: 7/7 проверок в `run_kind_test.py`, реальный
+  импорт файла через `importlib` (как это делает сам A1111), включая оба
+  ложных срабатывания (`polyfix.js`, `prefix.js`), которые раньше
+  давали `fix_extension`, а теперь — `user_extension`.
+- `metadata.ini`: распарсен настоящим `configparser`, плюс воспроизведена
+  логика `get_script_requirements` — оба `Before`-блока резолвятся в
+  ожидаемые имена.
+- `fix.js`: `node --check` на синтаксис + рантайм-smoke-тест в Node
+  (`fixjs_smoke_test.mjs`, 10/10), включая ветку "backend недоступен".
+
+## Как включить и на что смотреть
+
+1. Скопировать `extensions/!0000-a1111-fix/` и `modules/ui_gradio_extensions.py`
+   поверх своей установки, перезапустить webui.
+2. В консоли сервера при старте появится
+   `[a1111-fix][backend] backend watchdog active (...)` и, если что-то
+   долго импортировалось — рейтинг самых медленных расширений.
+3. Когда (если) снова случится зависание с потерей API — не гадать: либо
+   смотреть лог сервера (запись появится сама, watchdog-поток не ждёт
+   вашего запроса), либо дернуть `GET /internal/a1111-fix/status`, либо
+   в браузерной консоли `__a1111FixReport()` — там же теперь и backend-часть.
+4. Пороги подкручиваются без правки кода:
+   `A1111_FIX_LOCK_WARN_SECONDS`, `A1111_FIX_IMPORT_WARN_SECONDS`,
+   `A1111_FIX_WATCHDOG_INTERVAL`.

!0000-a1111-fix/javascript/fix.js

@@ -0,0 +1,506 @@
+(function () {
+    'use strict';
+
+    const FIX_TAG = '[a1111-fix]';
+    const FIX_VERSION = 'v5.2-hardened';
+
+    if (window.__a1111_fix_v52_applied) {
+        console.warn(FIX_TAG, 'already applied, skipping duplicate load');
+        return;
+    }
+    window.__a1111_fix_v52_applied = true;
+
+    const wrappedCache = new WeakMap();
+    const crashLogOnce = new WeakMap();
+    const slowLogOnce = new WeakMap();
+
+    function markWeakOnce(store, callback, kind) {
+        if (typeof callback !== 'function') return false;
+        let kinds = store.get(callback);
+        if (!kinds) {
+            kinds = new Set();
+            store.set(callback, kinds);
+        }
+
+        if (kinds.has(kind)) return false;
+        kinds.add(kind);
+        return true;
+    }
+
+    function isWrappedForKind(callback, kind) {
+        return !!(
+            callback &&
+            typeof callback === 'function' &&
+            callback.__a1111_fix_wrapped === true &&
+            callback.__a1111_fix_kind === kind &&
+            typeof callback.__a1111_fix_original === 'function'
+        );
+    }
+
+    function getWrappedCallback(callback, kind, slowThresholdMs) {
+        if (typeof callback !== 'function') return callback;
+        if (isWrappedForKind(callback, kind)) return callback;
+
+        let sourceCallback = callback;
+        if (
+            callback.__a1111_fix_wrapped === true &&
+            callback.__a1111_fix_kind === kind &&
+            typeof callback.__a1111_fix_original === 'function'
+        ) {
+            sourceCallback = callback.__a1111_fix_original;
+        }
+
+        let perKind = wrappedCache.get(sourceCallback);
+        if (!perKind) {
+            perKind = Object.create(null);
+            wrappedCache.set(sourceCallback, perKind);
+        }
+
+        if (perKind[kind]) return perKind[kind];
+
+        const wrapped = function (arg) {
+            const t0 = performance.now();
+            try {
+                return sourceCallback(arg);
+            } catch (e) {
+                if (markWeakOnce(crashLogOnce, sourceCallback, kind)) {
+                    console.error(FIX_TAG, kind + ' callback crashed:', sourceCallback.name || '(anonymous)', e);
+                }
+            } finally {
+                const elapsed = performance.now() - t0;
+                if (elapsed > slowThresholdMs && markWeakOnce(slowLogOnce, sourceCallback, kind)) {
+                    console.warn(
+                        FIX_TAG,
+                        'SLOW ' + kind + ': "' + (sourceCallback.name || '(anonymous)') + '" took ' + elapsed.toFixed(0) + 'ms'
+                    );
+                }
+            }
+        };
+
+        wrapped.__a1111_fix_wrapped = true;
+        wrapped.__a1111_fix_original = sourceCallback;
+        wrapped.__a1111_fix_kind = kind;
+        perKind[kind] = wrapped;
+        return wrapped;
+    }
+
+    function wrapQueue(queue, kind, slowThresholdMs) {
+        if (!Array.isArray(queue)) return 0;
+
+        let wrappedCount = 0;
+        for (let i = 0; i < queue.length; i++) {
+            if (typeof queue[i] === 'function' && !isWrappedForKind(queue[i], kind)) {
+                queue[i] = getWrappedCallback(queue[i], kind, slowThresholdMs);
+                wrappedCount++;
+            }
+        }
+        return wrappedCount;
+    }
+
+    function patchQueuePush(queue, kind, slowThresholdMs) {
+        if (!Array.isArray(queue) || queue.__a1111_fix_push_patched) return false;
+
+        const originalPush = queue.push;
+        if (typeof originalPush !== 'function') return false;
+
+        queue.push = function (...items) {
+            const wrappedItems = items.map((item) =>
+                typeof item === 'function' ? getWrappedCallback(item, kind, slowThresholdMs) : item
+            );
+            return originalPush.apply(this, wrappedItems);
+        };
+        queue.__a1111_fix_push_patched = true;
+        return true;
+    }
+
+    function safeGradioApp() {
+        try {
+            if (typeof window.gradioApp === 'function') {
+                return window.gradioApp();
+            }
+        } catch (e) {
+            console.warn(FIX_TAG, 'gradioApp() failed while resolving accordion:', e);
+        }
+        return document;
+    }
+
+    function applyFix1() {
+        const originalSchedule = window.scheduleAfterUiUpdateCallbacks;
+        if (typeof originalSchedule !== 'function' ||
+            typeof window.executeCallbacks !== 'function' ||
+            !Array.isArray(window.uiAfterUpdateCallbacks)) {
+            console.warn(FIX_TAG, 'scheduleAfterUiUpdateCallbacks/executeCallbacks/uiAfterUpdateCallbacks not found, skipping FIX-1');
+            return;
+        }
+
+        if (originalSchedule.__a1111_fix_afterupdate_patched) {
+            console.warn(FIX_TAG, 'FIX-1 already patched, skipping duplicate apply');
+            return;
+        }
+
+        const MAX_WAIT_MS = 1000;
+        let maxWaitTimer = null;
+        let running = false;
+
+        function clearMaxWaitTimer() {
+            if (maxWaitTimer) {
+                clearTimeout(maxWaitTimer);
+                maxWaitTimer = null;
+            }
+        }
+
+        function runAfterUpdateNow() {
+            clearMaxWaitTimer();
+
+            const timeoutId = window.uiAfterUpdateTimeout;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                window.uiAfterUpdateTimeout = null;
+            }
+
+            if (running) return;
+            running = true;
+            try {
+                if (typeof window.executeCallbacks === 'function') {
+                    window.executeCallbacks(window.uiAfterUpdateCallbacks);
+                }
+            } finally {
+                running = false;
+            }
+        }
+
+        if (!window.executeCallbacks.__a1111_fix_afterupdate_guard) {
+            const previousExecuteCallbacks = window.executeCallbacks;
+            const guardedExecuteCallbacks = function (queue, arg) {
+                if (queue === window.uiAfterUpdateCallbacks) {
+                    clearMaxWaitTimer();
+                }
+                return previousExecuteCallbacks(queue, arg);
+            };
+            guardedExecuteCallbacks.__a1111_fix_afterupdate_guard = true;
+            guardedExecuteCallbacks.__a1111_fix_afterupdate_guard_original = previousExecuteCallbacks;
+            window.executeCallbacks = guardedExecuteCallbacks;
+        }
+
+        const patchedSchedule = function (...args) {
+            const result = originalSchedule.apply(this, args);
+
+            if (!maxWaitTimer) {
+                maxWaitTimer = setTimeout(runAfterUpdateNow, MAX_WAIT_MS);
+            }
+
+            return result;
+        };
+        patchedSchedule.__a1111_fix_afterupdate_patched = true;
+        patchedSchedule.__a1111_fix_afterupdate_original = originalSchedule;
+        window.scheduleAfterUiUpdateCallbacks = patchedSchedule;
+
+        console.log(FIX_TAG, 'FIX-1: bounded after-update max-wait=' + MAX_WAIT_MS + 'ms applied (wrapper mode)');
+    }
+
+    function applyFix2() {
+        const configs = [
+            { queueName: 'uiLoadedCallbacks', registerName: 'onUiLoaded', slowThresholdMs: 100 },
+            { queueName: 'uiAfterUpdateCallbacks', registerName: 'onAfterUiUpdate', slowThresholdMs: 100 },
+            { queueName: 'uiUpdateCallbacks', registerName: 'onUiUpdate', slowThresholdMs: 50 },
+            { queueName: 'optionsChangedCallbacks', registerName: 'onOptionsChanged', slowThresholdMs: 50 },
+            { queueName: 'optionsAvailableCallbacks', registerName: 'onOptionsAvailable', slowThresholdMs: 50 },
+            { queueName: 'uiTabChangeCallbacks', registerName: 'onUiTabChange', slowThresholdMs: 50 },
+        ];
+
+        const activeConfigs = [];
+        const summary = [];
+
+        for (const cfg of configs) {
+            const queue = window[cfg.queueName];
+            const register = window[cfg.registerName];
+            if (!Array.isArray(queue) || typeof register !== 'function') {
+                continue;
+            }
+
+            const existingCount = wrapQueue(queue, cfg.registerName, cfg.slowThresholdMs);
+            patchQueuePush(queue, cfg.registerName, cfg.slowThresholdMs);
+
+            if (!register.__a1111_fix_register_patched) {
+                const originalRegister = register;
+                const patchedRegister = function (callback) {
+                    return originalRegister(getWrappedCallback(callback, cfg.registerName, cfg.slowThresholdMs));
+                };
+                patchedRegister.__a1111_fix_register_patched = true;
+                patchedRegister.__a1111_fix_register_original = originalRegister;
+                window[cfg.registerName] = patchedRegister;
+            }
+
+            activeConfigs.push(cfg);
+            summary.push(cfg.registerName + '=' + existingCount);
+        }
+
+        if (activeConfigs.length === 0) {
+            console.warn(FIX_TAG, 'no callback queues found, skipping FIX-2');
+            return;
+        }
+
+        if (typeof window.executeCallbacks === 'function' && !window.executeCallbacks.__a1111_fix_patched) {
+            const originalExecuteCallbacks = window.executeCallbacks;
+            const patchedExecuteCallbacks = function (queue, arg) {
+                for (const cfg of activeConfigs) {
+                    if (queue === window[cfg.queueName]) {
+                        wrapQueue(queue, cfg.registerName, cfg.slowThresholdMs);
+                        break;
+                    }
+                }
+                return originalExecuteCallbacks(queue, arg);
+            };
+            patchedExecuteCallbacks.__a1111_fix_patched = true;
+            patchedExecuteCallbacks.__a1111_fix_original = originalExecuteCallbacks;
+            window.executeCallbacks = patchedExecuteCallbacks;
+        }
+
+        console.log(FIX_TAG, 'FIX-2: callback guards applied to', summary.join(', '));
+    }
+
+    function applyFix3() {
+        if (typeof window.inputAccordionChecked !== 'function') {
+            console.warn(FIX_TAG, 'inputAccordionChecked not found, skipping FIX-3');
+            return;
+        }
+
+        const warnedOnce = new Set();
+
+        function isRealAccordion(el) {
+            return !!(
+                el &&
+                el.visibleCheckbox instanceof HTMLInputElement &&
+                typeof el.onVisibleCheckboxChange === 'function'
+            );
+        }
+
+        function resolveRealAccordion(id) {
+            const app = safeGradioApp();
+            const direct = app.getElementById ? app.getElementById(id) : null;
+            if (isRealAccordion(direct)) return direct;
+
+            const dotted = app.getElementById ? app.getElementById('.' + id) : null;
+            if (isRealAccordion(dotted)) return dotted;
+
+            if (direct && typeof direct.querySelector === 'function') {
+                const nestedCheckbox = direct.querySelector('.input-accordion-checkbox');
+                if (nestedCheckbox) {
+                    const parentAccordion = nestedCheckbox.closest('.input-accordion');
+                    if (isRealAccordion(parentAccordion)) return parentAccordion;
+                }
+            }
+
+            return null;
+        }
+
+        window.inputAccordionChecked = function (id, checked) {
+            const realEl = resolveRealAccordion(id);
+            if (!realEl) {
+                if (!warnedOnce.has(id)) {
+                    warnedOnce.add(id);
+                    const app = safeGradioApp();
+                    const direct = app.getElementById ? app.getElementById(id) : null;
+                    const dotted = app.getElementById ? app.getElementById('.' + id) : null;
+                    console.error(
+                        FIX_TAG, 'FIX-3: cannot resolve accordion for id:', id,
+                        '\n  direct el:', direct,
+                        '\n  direct.visibleCheckbox:', direct && direct.visibleCheckbox,
+                        '\n  direct.visibleCheckbox instanceof HTMLInputElement:',
+                            direct && (direct.visibleCheckbox instanceof HTMLInputElement),
+                        '\n  dotted el:', dotted
+                    );
+                }
+                return;
+            }
+
+            realEl.visibleCheckbox.checked = checked;
+            realEl.onVisibleCheckboxChange();
+        };
+
+        console.log(FIX_TAG, 'FIX-3: resilient accordion resolver applied');
+    }
+
+    function applyFix4() {
+        window.__a1111ScriptRegistry = window.__a1111ScriptRegistry || {
+            mode: 'unknown',
+            scripts: {},
+            loaded: {},
+            errors: {},
+            injected_order: [],
+        };
+
+        function registerScriptElement(el) {
+            if (!el || el.tagName !== 'SCRIPT') return;
+            if (typeof window.__a1111RegisterScript === 'function') {
+                window.__a1111RegisterScript(el);
+                return;
+            }
+
+            const src = el.getAttribute('src') || '';
+            window.__a1111ScriptRegistry.scripts[src] = {
+                role: el.getAttribute('data-a1111-role') || 'unknown',
+                mode: el.getAttribute('data-a1111-mode') || 'unknown',
+                path: el.getAttribute('data-a1111-path') || src,
+                basedir: el.getAttribute('data-a1111-basedir') || '',
+            };
+            if (!window.__a1111ScriptRegistry.injected_order.includes(src)) {
+                window.__a1111ScriptRegistry.injected_order.push(src);
+            }
+        }
+
+        window.addEventListener('error', function (event) {
+            const target = event && event.target;
+            if (target && target.tagName === 'SCRIPT') {
+                registerScriptElement(target);
+                const src = target.getAttribute('src') || '';
+                window.__a1111ScriptRegistry.errors[src] = true;
+                return;
+            }
+
+            const filename = event && event.filename;
+            if (filename) {
+                console.error(FIX_TAG, 'window error from script:', filename, event.error || event.message || event);
+            }
+        }, true);
+
+        window.addEventListener('unhandledrejection', function (event) {
+            console.error(FIX_TAG, 'unhandled promise rejection:', event.reason || event);
+        });
+
+        function summarizeRegistry() {
+            const registry = window.__a1111ScriptRegistry || {};
+            const scripts = registry.scripts || {};
+            const loaded = registry.loaded || {};
+            const errors = registry.errors || {};
+            const order = registry.injected_order || [];
+
+            const ok = [];
+            const failed = [];
+            const pending = [];
+
+            for (const src of order.length ? order : Object.keys(scripts)) {
+                const meta = scripts[src] || {};
+                const item = {
+                    src,
+                    role: meta.role || 'unknown',
+                    mode: meta.mode || 'unknown',
+                    path: meta.path || src,
+                };
+
+                if (errors[src]) {
+                    failed.push(item);
+                } else if (loaded[src]) {
+                    ok.push(item);
+                } else {
+                    pending.push(item);
+                }
+            }
+
+            return { ok, failed, pending, mode: registry.mode || 'unknown' };
+        }
+
+        function summarizeCallbacks() {
+            const groups = [
+                ['uiLoadedCallbacks', 'onUiLoaded'],
+                ['uiAfterUpdateCallbacks', 'onAfterUiUpdate'],
+                ['uiUpdateCallbacks', 'onUiUpdate'],
+                ['optionsChangedCallbacks', 'onOptionsChanged'],
+                ['optionsAvailableCallbacks', 'onOptionsAvailable'],
+                ['uiTabChangeCallbacks', 'onUiTabChange'],
+            ];
+            return groups.map(([queueName, registerName]) => {
+                const queue = window[queueName];
+                return {
+                    queue: queueName,
+                    register: registerName,
+                    present: Array.isArray(queue),
+                    count: Array.isArray(queue) ? queue.length : 0,
+                };
+            });
+        }
+
+        // Backend half of the picture. scripts/backend_watchdog.py exposes
+        // this endpoint if it's installed and managed to attach; if it's
+        // missing or unreachable this just logs one line and moves on, it
+        // never throws. Kept as a separate function (returns a Promise) so
+        // __a1111FixReport() below can stay synchronous -- existing callers
+        // that read its return value immediately, like the load-event
+        // handler a bit further down, keep working unchanged.
+        window.__a1111FixBackendStatus = function () {
+            return fetch('/internal/a1111-fix/status')
+                .then(function (resp) {
+                    if (!resp.ok) throw new Error('HTTP ' + resp.status);
+                    return resp.json();
+                })
+                .then(function (status) {
+                    console.log(FIX_TAG, 'backend status:', status);
+                    if (status.queue_lock && status.queue_lock.held) {
+                        console.warn(
+                            FIX_TAG,
+                            'queue_lock has been held for', status.queue_lock.held_for_seconds + 's',
+                            'by', status.queue_lock.owner_thread,
+                            '(' + status.queue_lock.waiters_now, 'call(s) queued behind it) -- ' +
+                            'this blocks BOTH the UI Generate button and /sdapi/v1/* right now.'
+                        );
+                    }
+                    if (status.currently_importing) {
+                        console.warn(FIX_TAG, 'backend is still importing:', status.currently_importing);
+                    }
+                    if (Array.isArray(status.slowest_imports) && status.slowest_imports.length) {
+                        console.table(status.slowest_imports);
+                    }
+                    return status;
+                })
+                .catch(function (err) {
+                    // Not fatal -- scripts/backend_watchdog.py may not be
+                    // installed, or the server may genuinely be unreachable
+                    // right now, which is itself useful information.
+                    console.log(FIX_TAG, 'backend status unavailable:', err.message);
+                    return null;
+                });
+        };
+
+        window.__a1111FixReport = function () {
+            const report = summarizeRegistry();
+            const callbacks = summarizeCallbacks();
+            console.log(FIX_TAG, 'loader mode =', report.mode);
+            console.log(FIX_TAG, 'loaded scripts =', report.ok.length, 'failed =', report.failed.length, 'pending =', report.pending.length);
+            console.table(callbacks);
+
+            if (report.failed.length) {
+                console.warn(FIX_TAG, 'failed scripts:');
+                console.table(report.failed);
+            }
+            if (report.pending.length) {
+                console.warn(FIX_TAG, 'pending/unconfirmed scripts:');
+                console.table(report.pending);
+            }
+            if (!report.failed.length && !report.pending.length) {
+                console.log(FIX_TAG, 'all tracked scripts loaded cleanly');
+            }
+
+            window.__a1111FixBackendStatus();
+
+            return { ...report, callbacks };
+        };
+
+        window.addEventListener('load', function () {
+            setTimeout(function () {
+                const report = window.__a1111FixReport();
+                if (report.failed.length || report.pending.length) {
+                    console.warn(FIX_TAG, 'FIX-4: loader diagnostics detected script issues; inspect __a1111FixReport() output');
+                }
+            }, 1500);
+        }, { once: true });
+
+        console.log(FIX_TAG, 'FIX-4: loader diagnostics ready');
+    }
+
+    applyFix1();
+    applyFix2();
+    applyFix3();
+    applyFix4();
+
+    console.log(FIX_TAG, FIX_VERSION, 'ready');
+})();

!0000-a1111-fix/metadata.ini

@@ -0,0 +1,55 @@
+[Extension]
+Name = 0000-a1111-fix
+
+; Notes:
+; - the real canonical name A1111 uses to match Before/After targets is
+;   always the lowercased FOLDER name, not the "Name =" field above.
+;   modules/extensions.py:ExtensionMetadata.__init__ reads "Name" and then,
+;   a couple of lines later, unconditionally overwrites it with the folder
+;   name -- so "Name =" here is documentation only, it has zero effect on
+;   matching. Rename the FOLDER, not this line, if you ever need to change
+;   how other extensions can reference this one.
+; - the "!0000-" folder prefix forces early alphabetical sort, but that only
+;   wins against other entries inside extensions/. A1111 scans
+;   extensions-builtin/ to completion before it ever looks inside
+;   extensions/ (modules/extensions.py:list_extensions), so a builtin
+;   extension is always earlier in the natural, unconstrained order no
+;   matter what this folder is named. The Before= lines below are what
+;   actually overrides that, via the topological sort in
+;   modules/scripts.py:list_scripts().
+; - Before/After targets are matched by EXACT, case-insensitive folder name.
+;   A non-matching name fails silently (no error, the edge is just never
+;   created) -- verify names against the real extensions/ and
+;   extensions-builtin/ directories instead of guessing. "canvas-zoom" used
+;   to be a guess here and did not match the extension actually shipped in
+;   this repo, which is named canvas-zoom-and-pan.
+; - "name1|name2|name3" (pipe, no surrounding spaces) picks whichever of the
+;   alternatives is actually installed and ignores the rest -- see
+;   modules/extensions.py:get_script_requirements. Used below for
+;   third-party extensions whose exact folder name can vary by how the user
+;   installed them.
+
+; javascript/fix.js
+; Kept for defense in depth, but not strictly load-bearing for FIX-1/2/3 as
+; currently written: they patch GLOBAL functions (scheduleAfterUiUpdateCallbacks,
+; executeCallbacks, inputAccordionChecked) by reassignment, and FIX-2
+; additionally re-wraps any callback queue right before it runs, regardless
+; of when things were registered. Both patterns only require fix.js to have
+; executed at all before DOMContentLoaded, which holds for any sync or defer
+; <script> tag no matter its position. Ordering would only matter if some
+; other extension captured a direct reference to the original function at
+; its own parse time instead of calling window.xxx(...) fresh on use --
+; uncommon, but the entries below cost nothing if unused.
+[javascript/fix.js]
+Before = sd-webui-tabs-extension|sd-webui-tabs-extension-main sd-webui-controlnet|sd-webui-controlnet-main canvas-zoom|sd-webui-canvas-zoom|canvas-zoom-and-pan
+
+; scripts/backend_watchdog.py
+; This one DOES need to run before other extensions' Python: it times each
+; extension's import as it happens, and it needs to be watching before an
+; import starts in order to catch a slow or stuck one live. Builtin
+; extensions are otherwise unreachable by any folder-naming trick (see
+; note above), so they are listed explicitly and exhaustively -- this is
+; every folder currently under extensions-builtin/ in this repo. Add to
+; this list if a future A1111 version ships additional builtin extensions.
+[scripts/backend_watchdog.py]
+Before = ldsr lora scunet swinir canvas-zoom-and-pan extra-options-section hypertile mobile postprocessing-for-training prompt-bracket-checker soft-inpainting

!0000-a1111-fix/scripts/backend_watchdog.py

@@ -0,0 +1,381 @@
+"""
+!0000-a1111-fix / scripts/backend_watchdog.py
+
+Backend-side counterpart to javascript/fix.js.
+
+fix.js only ever sees the browser. It cannot detect or explain a genuine
+server-side stall, because a stalled Python process cannot serve anything
+to the browser in the first place -- there is nothing for client-side code
+to observe. This module targets exactly that gap.
+
+Verified against this exact codebase (stable-diffusion-webui, gradio==3.41.2):
+
+  1. modules/call_queue.py defines ONE queue_lock = fifo_lock.FIFOLock().
+     modules/ui.py wraps every "Generate" button in wrap_gradio_gpu_call(),
+     which does `with queue_lock:`. modules/api/api.py stores the SAME lock
+     object as self.queue_lock and wraps txt2imgapi/img2imgapi/etc. in
+     `with self.queue_lock:`. Both the Gradio UI and every /sdapi/v1/* route
+     run in the same process on the same FastAPI app (webui.py) and
+     serialize on this exact lock. If anything holds it too long -- a stuck
+     extension callback in process()/postprocess()/on_cfg_denoiser, a
+     blocking network call, a deadlock on shared.state -- the UI and the
+     HTTP API go unresponsive together. That combination is what this
+     module watches for.
+
+  2. modules/scripts.py:load_scripts() imports every extension script via
+     script_loading.load_module(scriptfile.path), sequentially, on the main
+     thread, before the server exists. A hang here explains "the whole
+     thing never even finishes starting" and can't be caught by anything
+     that only starts after app_started fires -- because app_started never
+     fires until this loop returns. This module times each import live and
+     can point at whichever one is currently stuck.
+
+  3. Both are exposed as one small JSON endpoint so javascript/fix.js's
+     __a1111FixReport() can show one unified picture instead of guessing
+     which layer broke.
+
+Correctness notes (read before touching the locking code):
+  - FIFOLock.__enter__ = acquire is bound at class-definition time, so
+    `with queue_lock:` calls type(queue_lock).__enter__, NOT an
+    instance attribute. Patching queue_lock.acquire on the instance would
+    silently do nothing for `with` statements. Everything here patches the
+    FIFOLock *class*, once, and __enter__/__exit__ explicitly.
+  - The wrapper never adds its own locking around the real acquire/release
+    call -- only plain attribute writes on a small dict-like state object,
+    which is safe under the GIL and can't introduce a new deadlock.
+  - Every entry point is wrapped in try/except; if this fork's internals
+    don't match what's verified above, this module logs once and steps
+    aside instead of blocking startup.
+"""
+
+import io
+import os
+import sys
+import time
+import threading
+import traceback
+
+TAG = "[a1111-fix][backend]"
+
+
+def _env_float(name, default):
+    try:
+        return float(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+
+
+LOCK_WARN_SECONDS = _env_float("A1111_FIX_LOCK_WARN_SECONDS", 20.0)
+IMPORT_WARN_SECONDS = _env_float("A1111_FIX_IMPORT_WARN_SECONDS", 15.0)
+WATCHDOG_INTERVAL_SECONDS = _env_float("A1111_FIX_WATCHDOG_INTERVAL", 2.0)
+
+
+def _log(msg):
+    print(f"{TAG} {msg}", flush=True)
+
+
+def _dump_thread_stack(thread_id, limit=40):
+    if thread_id is None:
+        return "  (no thread id on record)"
+    frame = sys._current_frames().get(thread_id)
+    if frame is None:
+        return "  (thread not found -- it likely finished between the check and the dump)"
+    buf = io.StringIO()
+    traceback.print_stack(frame, limit=limit, file=buf)
+    return buf.getvalue()
+
+
+def _short_caller_site():
+    """Best-effort 'who is trying to acquire this lock' label, used when we
+    later report that the lock has been held too long."""
+    stack = traceback.extract_stack()
+    useful = [f for f in stack if "backend_watchdog.py" not in f.filename]
+    if not useful:
+        return "unknown"
+    f = useful[-1]
+    return f"{os.path.basename(f.filename)}:{f.lineno} in {f.name}"
+
+
+# ---------------------------------------------------------------------------
+# Part 1: queue_lock instrumentation
+# ---------------------------------------------------------------------------
+
+class _LockState:
+    def __init__(self):
+        self.held = False
+        self.instance = None
+        self.owner_thread_id = None
+        self.owner_thread_name = None
+        self.acquired_at = None
+        self.acquire_site = None
+        self.waiters_at_acquire = 0
+        self.last_warned_at = 0.0
+        self.bookkeeping_lock = threading.Lock()  # protects this object only, never queue_lock itself
+
+
+_lock_state = _LockState()
+
+
+def _patch_queue_lock():
+    try:
+        from modules import fifo_lock
+    except Exception as e:
+        _log(f"queue_lock instrumentation skipped: modules.fifo_lock not importable ({e})")
+        return False
+
+    if getattr(fifo_lock.FIFOLock, "_a1111_fix_patched", False):
+        return True  # already patched (e.g. re-exec on UI reload)
+
+    original_acquire = fifo_lock.FIFOLock.acquire
+    original_release = fifo_lock.FIFOLock.release
+
+    def patched_acquire(self, blocking=True):
+        site = _short_caller_site()
+        ok = original_acquire(self, blocking)
+        if ok:
+            with _lock_state.bookkeeping_lock:
+                _lock_state.held = True
+                _lock_state.instance = self
+                _lock_state.owner_thread_id = threading.get_ident()
+                _lock_state.owner_thread_name = threading.current_thread().name
+                _lock_state.acquired_at = time.time()
+                _lock_state.acquire_site = site
+                _lock_state.waiters_at_acquire = len(getattr(self, "_pending_threads", ()) or ())
+        return ok
+
+    def patched_release(self):
+        try:
+            original_release(self)
+        finally:
+            with _lock_state.bookkeeping_lock:
+                _lock_state.held = False
+                _lock_state.instance = None
+                _lock_state.owner_thread_id = None
+                _lock_state.owner_thread_name = None
+                _lock_state.acquired_at = None
+                _lock_state.acquire_site = None
+
+    fifo_lock.FIFOLock.acquire = patched_acquire
+    fifo_lock.FIFOLock.release = patched_release
+    fifo_lock.FIFOLock.__enter__ = patched_acquire
+    fifo_lock.FIFOLock.__exit__ = lambda self, t, v, tb: patched_release(self)
+    fifo_lock.FIFOLock._a1111_fix_patched = True
+    _log("queue_lock instrumented (modules.fifo_lock.FIFOLock patched at class level)")
+    return True
+
+
+def _lock_status_snapshot():
+    with _lock_state.bookkeeping_lock:
+        if not _lock_state.held:
+            return {"held": False}
+        held_for = time.time() - _lock_state.acquired_at
+        live_waiters = _lock_state.waiters_at_acquire
+        inst = _lock_state.instance
+        if inst is not None:
+            live_waiters = len(getattr(inst, "_pending_threads", ()) or ())
+        return {
+            "held": True,
+            "held_for_seconds": round(held_for, 1),
+            "owner_thread": _lock_state.owner_thread_name,
+            "acquired_at_site": _lock_state.acquire_site,
+            "waiters_now": live_waiters,
+        }
+
+
+def _check_lock_watchdog(now):
+    with _lock_state.bookkeeping_lock:
+        if not _lock_state.held:
+            return
+        held_for = now - _lock_state.acquired_at
+        if held_for < LOCK_WARN_SECONDS:
+            return
+        if now - _lock_state.last_warned_at < LOCK_WARN_SECONDS:
+            return  # re-warn periodically, not on every tick
+        _lock_state.last_warned_at = now
+        owner_id = _lock_state.owner_thread_id
+        owner_name = _lock_state.owner_thread_name
+        site = _lock_state.acquire_site
+        inst = _lock_state.instance
+        waiters = len(getattr(inst, "_pending_threads", ()) or ()) if inst is not None else "?"
+
+    stack_text = _dump_thread_stack(owner_id)
+    _log(
+        f"queue_lock has been held for {held_for:.1f}s by thread '{owner_name}' "
+        f"(acquired from {site}); {waiters} other call(s) queued behind it.\n"
+        f"This is the SAME lock used by the UI Generate button AND every "
+        f"/sdapi/v1/* route, so both are blocked right now behind whatever "
+        f"this thread is doing:\n{stack_text}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Part 2: per-extension import timing
+# ---------------------------------------------------------------------------
+
+class _ImportState:
+    def __init__(self):
+        self.current_path = None
+        self.current_started_at = None
+        self.records = []  # list of (path, seconds)
+        self.lock = threading.Lock()
+
+
+_import_state = _ImportState()
+
+
+def _extension_label_for_path(path):
+    """'/srv/webui/extensions/sd-webui-controlnet/scripts/controlnet.py'
+    -> 'sd-webui-controlnet/controlnet.py'. Falls back to the bare filename
+    for anything outside extensions/extensions-builtin (core scripts)."""
+    if not path:
+        return None
+    norm = path.replace("\\", "/")
+    for marker in ("/extensions-builtin/", "/extensions/"):
+        if marker in norm:
+            tail = norm.split(marker, 1)[1]
+            parts = tail.split("/")
+            if len(parts) >= 2:
+                return f"{parts[0]}/{parts[-1]}"
+            return tail
+    return os.path.basename(norm)
+
+
+def _patch_script_loading():
+    try:
+        from modules import script_loading
+    except Exception as e:
+        _log(f"import timing skipped: modules.script_loading not importable ({e})")
+        return False
+
+    if getattr(script_loading, "_a1111_fix_patched", False):
+        return True
+
+    original_load_module = script_loading.load_module
+
+    def timed_load_module(path):
+        with _import_state.lock:
+            _import_state.current_path = path
+            _import_state.current_started_at = time.time()
+        t0 = time.time()
+        try:
+            return original_load_module(path)
+        finally:
+            elapsed = time.time() - t0
+            with _import_state.lock:
+                _import_state.current_path = None
+                _import_state.current_started_at = None
+                _import_state.records.append((path, elapsed))
+            if elapsed >= IMPORT_WARN_SECONDS:
+                _log(f"slow import: {_extension_label_for_path(path)} took {elapsed:.1f}s")
+
+    script_loading.load_module = timed_load_module
+    script_loading._a1111_fix_patched = True
+    _log("import timing instrumented (modules.script_loading.load_module wrapped)")
+    return True
+
+
+def _check_import_watchdog(now):
+    with _import_state.lock:
+        path = _import_state.current_path
+        started = _import_state.current_started_at
+    if path is None or started is None:
+        return
+    elapsed = now - started
+    if elapsed < IMPORT_WARN_SECONDS:
+        return
+    stack_text = _dump_thread_stack(threading.main_thread().ident)
+    _log(
+        f"still importing {_extension_label_for_path(path)} after {elapsed:.1f}s "
+        f"-- main thread is currently here:\n{stack_text}"
+    )
+
+
+def _slowest_imports(top_n=10):
+    with _import_state.lock:
+        records = list(_import_state.records)
+    records.sort(key=lambda r: r[1], reverse=True)
+    out, seen = [], set()
+    for p, s in records:
+        label = _extension_label_for_path(p)
+        if label in seen or s < 0.05:
+            continue
+        seen.add(label)
+        out.append({"extension": label, "seconds": round(s, 2)})
+        if len(out) >= top_n:
+            break
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Part 3: watchdog thread + status endpoint + startup summary
+# ---------------------------------------------------------------------------
+
+def _watchdog_loop():
+    while True:
+        try:
+            now = time.time()
+            _check_lock_watchdog(now)
+            _check_import_watchdog(now)
+        except Exception:
+            _log("watchdog tick raised an exception (continuing):\n" + traceback.format_exc())
+        time.sleep(WATCHDOG_INTERVAL_SECONDS)
+
+
+_route_registered = False
+
+
+def _register_status_route(app):
+    global _route_registered
+    if _route_registered or app is None:
+        return
+    try:
+        @app.get("/internal/a1111-fix/status")
+        def _a1111_fix_status():
+            return {
+                "queue_lock": _lock_status_snapshot(),
+                "currently_importing": _extension_label_for_path(_import_state.current_path),
+                "slowest_imports": _slowest_imports(),
+            }
+        _route_registered = True
+        _log("status endpoint ready: GET /internal/a1111-fix/status")
+    except Exception:
+        _log("could not register status endpoint:\n" + traceback.format_exc())
+
+
+def _print_startup_summary():
+    slow = _slowest_imports(top_n=10)
+    if not slow:
+        return
+    lines = "\n".join(f"  {e['seconds']:>6.2f}s  {e['extension']}" for e in slow)
+    _log(f"slowest extension imports this session:\n{lines}")
+
+
+def _on_app_started(demo, app):
+    _register_status_route(app)
+    _print_startup_summary()
+
+
+def _main():
+    _patch_queue_lock()
+    _patch_script_loading()
+
+    watchdog_thread = threading.Thread(target=_watchdog_loop, name="a1111-fix-watchdog", daemon=True)
+    watchdog_thread.start()
+
+    try:
+        from modules import script_callbacks
+        script_callbacks.on_app_started(_on_app_started)
+    except Exception:
+        _log("could not register on_app_started callback:\n" + traceback.format_exc())
+
+    _log(
+        f"backend watchdog active "
+        f"(lock warn: {LOCK_WARN_SECONDS}s, import warn: {IMPORT_WARN_SECONDS}s, "
+        f"tick: {WATCHDOG_INTERVAL_SECONDS}s)"
+    )
+
+
+try:
+    _main()
+except Exception:
+    _log("failed to initialize -- backend diagnostics disabled:\n" + traceback.format_exc())