Upload 2 files

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

@@ -0,0 +1,286 @@
+(function () {
+    'use strict';
+
+    // =========================================================================
+    // 0000-a1111-fix/javascript/fix.js  —  v4.2
+    //
+    // Порядок загрузки гарантируется двумя механизмами:
+    //
+    // 1. Имя '!0000-a1111-fix' — A1111 сортирует user extensions alphabetically
+    //    (sorted(os.listdir(...))), '!' ставит нас первыми среди пользовательских
+    //    расширений.
+    //
+    // 2. metadata.ini [javascript/fix.js] Before = sd-webui-tabs-extension ...
+    //    A1111 строит topological sort через list_scripts() и учитывает
+    //    Before/After зависимости для JS-файлов.
+    //
+    // Что НЕ покрывается:
+    //   Builtin extensions (extensions-builtin/) грузятся ДО пользовательских.
+    //   Три builtin используют onUiLoaded: canvas-zoom-and-pan, mobile,
+    //   prompt-bracket-checker. Все три исторически короткие, но реальная длительность зависит от среды.
+    //   Источник медленных callbacks — пользовательские расширения (ControlNet и др.).
+    //
+    // Четыре исправления:
+    //
+    // [FIX-0] Idempotence guard.
+    //   Гарантирует однократное применение патча при любых условиях.
+    //
+    // [FIX-1] scheduleAfterUiUpdateCallbacks — bounded debounce, max-wait 1000ms.
+    //   Оригинал (script.js:111-115): clearTimeout + setTimeout 200ms.
+    //   При 50+ расширениях DOM мутирует 2-5 сек непрерывно — uiAfterUpdateTimeout
+    //   сбрасывается каждый раз, uiAfterUpdateCallbacks так и не вызываются.
+    //   Фикс: добавляем maxWaitTimer, который форсирует вызов через MAX_WAIT_MS
+    //   независимо от новых мутаций. uiAfterUpdateTimeout продолжает жить как
+    //   глобал core (совместимость сохранена).
+    //   Re-entry guard защищает от рекурсии если callback сам вызывает мутацию.
+    //
+    // [FIX-2] onUiLoaded timing — полный охват existing + future callbacks.
+    //   Оригинал (script.js:60-62): uiLoadedCallbacks.push(callback).
+    //   executeCallbacks (script.js:95-102) — синхронный, не cancelable.
+    //   v3: оборачивал только БУДУЩИЕ вызовы onUiLoaded — builtin callbacks
+    //       уже в uiLoadedCallbacks ДО нашего патча → не покрыты.
+    //   v4: оборачиваем уже существующие элементы uiLoadedCallbacks + будущие.
+    //   Symbol(WRAPPED) предотвращает двойную обёртку при любом сценарии.
+    //   Логирование только первого краша на callback (Set по имени).
+    //
+    // [FIX-3] inputAccordionChecked — resilient resolver для tabs extension.
+    //   tabs_parser.js (строки 92-100): если accordion.id не null и не
+    //   начинается с "component-":
+    //     content.id = accordion.id;
+    //     accordion.id = '.' + accordion.id;
+    //     content.visibleCheckbox = {};           <- plain Object, НЕ HTMLInputElement
+    //     content.onVisibleCheckboxChange = () => {};
+    //   Кроме того, в оригинальный accordion вставляется клонированный checkbox
+    //   (строки 73-85) — т.е. .input-accordion-checkbox остаётся В accordion'е.
+    //
+    //   Resolver (resolveRealAccordion) проверяет три пути:
+    //     1. getElementById(id)                → если реальный accordion (не перемещён)
+    //     2. getElementById('.' + id)          → tabs: оригинальный accordion переименован
+    //     3. querySelector .input-accordion-checkbox внутри el → fallback на случай
+    //        если tabs extension изменит схему именования id в будущих версиях
+    //   Log-once через Set предотвращает spam в консоли.
+    // =========================================================================
+
+
+    // ─── [FIX-0] Idempotence guard ───────────────────────────────────────────
+
+    if (window.__a1111_fix_v4_applied) {
+        console.warn('[a1111-fix] already applied, skipping duplicate load');
+        return;
+    }
+    window.__a1111_fix_v4_applied = true;
+
+
+    // ─── [FIX-1] scheduleAfterUiUpdateCallbacks — bounded debounce ──��────────
+
+    function applyFix1() {
+        if (typeof scheduleAfterUiUpdateCallbacks === 'undefined' ||
+            typeof executeCallbacks === 'undefined' ||
+            typeof uiAfterUpdateCallbacks === 'undefined') {
+            console.warn('[a1111-fix] scheduleAfterUiUpdateCallbacks/executeCallbacks/uiAfterUpdateCallbacks not found, skipping FIX-1');
+            return;
+        }
+
+        const DEBOUNCE_MS = 200;
+        const MAX_WAIT_MS = 1000;
+
+        let debounceTimer = null;
+        let maxWaitTimer = null;
+        let running = false;
+
+        function runAfterUpdateCallbacks() {
+            // Используем собственный debounce-таймер вместо смешивания bare global
+            // uiAfterUpdateTimeout и window.uiAfterUpdateTimeout.
+            clearTimeout(debounceTimer);
+            clearTimeout(maxWaitTimer);
+            debounceTimer = null;
+            maxWaitTimer = null;
+
+            if (running) return;
+            running = true;
+            try {
+                executeCallbacks(uiAfterUpdateCallbacks);
+            } finally {
+                running = false;
+            }
+        }
+
+        window.scheduleAfterUiUpdateCallbacks = function () {
+            clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(runAfterUpdateCallbacks, DEBOUNCE_MS);
+
+            if (!maxWaitTimer) {
+                maxWaitTimer = setTimeout(runAfterUpdateCallbacks, MAX_WAIT_MS);
+            }
+        };
+
+        console.log('[a1111-fix] FIX-1: bounded debounce max-wait=' + MAX_WAIT_MS + 'ms applied');
+    }
+
+
+    // ─── [FIX-2] onUiLoaded timing — existing + future callbacks ─────────────
+
+    function applyFix2() {
+        if (typeof onUiLoaded === 'undefined' || typeof uiLoadedCallbacks === 'undefined') {
+            console.warn('[a1111-fix] onUiLoaded or uiLoadedCallbacks not found, skipping FIX-2');
+            return;
+        }
+
+        const SLOW_THRESHOLD_MS = 100;
+        const WRAPPED = Symbol('a1111FixWrapped');
+        // WeakSet по исходному callback (не по имени): Set<string> глушил бы все
+        // '(anonymous)' callbacks или однофамильцев — один краш скрывал бы другие.
+        const crashedOnce = new WeakSet();
+
+        function wrapCallback(callback) {
+            if (typeof callback !== 'function') return callback;
+            if (callback[WRAPPED]) return callback;  // уже обёрнут — не дублируем
+
+            const wrapped = function (arg) {
+                const t0 = performance.now();
+                try {
+                    return callback(arg);
+                } catch (e) {
+                    // Не бросаем исключение дальше: core executeCallbacks (script.js:95-102)
+                    // сам ловит ошибки и пишет console.error — двойное логирование не нужно.
+                    // WeakSet по callback — каждый упавший callback логируется ровно один раз.
+                    if (!crashedOnce.has(callback)) {
+                        crashedOnce.add(callback);
+                        console.error('[a1111-fix] onUiLoaded callback crashed:', callback.name || '(anonymous)', e);
+                    }
+                } finally {
+                    const elapsed = performance.now() - t0;
+                    if (elapsed > SLOW_THRESHOLD_MS) {
+                        console.warn(
+                            '[a1111-fix] SLOW onUiLoaded: "' + (callback.name || '(anonymous)') + '" took ' + elapsed.toFixed(0) + 'ms'
+                        );
+                    }
+                }
+            };
+
+            wrapped[WRAPPED] = true;
+            wrapped.__a1111_fix_original = callback;
+            return wrapped;
+        }
+
+        // 1) Уже зарегистрированные callbacks (builtin extensions и ранние user extensions)
+        //    uiLoadedCallbacks — глобальный массив (script.js:29), изменяем на месте.
+        let existingCount = 0;
+        for (let i = 0; i < uiLoadedCallbacks.length; i++) {
+            if (typeof uiLoadedCallbacks[i] === 'function') {
+                uiLoadedCallbacks[i] = wrapCallback(uiLoadedCallbacks[i]);
+                existingCount++;
+            }
+        }
+
+        // 2) Будущие callbacks через onUiLoaded(fn)
+        const _originalOnUiLoaded = window.onUiLoaded;
+        window.onUiLoaded = function (callback) {
+            _originalOnUiLoaded(wrapCallback(callback));
+        };
+
+        console.log(
+            '[a1111-fix] FIX-2: timing applied to ' + existingCount + ' existing + all future onUiLoaded callbacks'
+        );
+    }
+
+
+    // ─── [FIX-3] inputAccordionChecked — resilient accordion resolver ─────────
+
+    function applyFix3() {
+        if (typeof inputAccordionChecked === 'undefined') {
+            console.warn('[a1111-fix] inputAccordionChecked not found, skipping FIX-3');
+            return;
+        }
+
+        const warnedOnce = new Set();
+
+        /**
+         * Проверка, является ли el реальным setupAccordion-элементом.
+         * Реальный accordion после setupAccordion (inputAccordion.js:41-43):
+         *   accordion.visibleCheckbox = visibleCheckbox (document.createElement('INPUT'))
+         *   accordion.onVisibleCheckboxChange = function() {...}
+         * Стаб tabs_parser.js (строки 98-100):
+         *   content.visibleCheckbox = {}  <- plain Object
+         *   content.onVisibleCheckboxChange = () => {}  <- no-op
+         */
+        function isRealAccordion(el) {
+            return !!(
+                el &&
+                el.visibleCheckbox instanceof HTMLInputElement &&
+                typeof el.onVisibleCheckboxChange === 'function'
+            );
+        }
+
+        /**
+         * Три пути поиска реального accordion'а:
+         *
+         * 1. getElementById(id) — стандартный путь, работает если tabs extension
+         *    не трогал этот accordion (нет isInput, или id начинается с "component-").
+         *
+         * 2. getElementById('.' + id) — tabs_parser.js переименовывает оригинальный
+         *    accordion: accordion.id = '.' + originalId (строка 94).
+         *
+         * 3. querySelector('.input-accordion-checkbox') внутри el — tabs_parser.js
+         *    вставляет клонированный checkbox в content (строки 73-85), но оригинальный
+         *    .input-accordion-checkbox остаётся внутри переименованного accordion.
+         *    Этот путь — fallback на случай изменения схемы id в будущих версиях.
+         */
+        function resolveRealAccordion(id) {
+            const direct = gradioApp().getElementById(id);
+            if (isRealAccordion(direct)) return direct;
+
+            // tabs extension: accordion переименован в '.' + id
+            const dotted = gradioApp().getElementById('.' + id);
+            if (isRealAccordion(dotted)) return dotted;
+
+            // Fallback: поиск .input-accordion-checkbox в ближайшем контейнере
+            // На случай изменения схемы tabs extension или нестандартных layouts
+            if (direct) {
+                const nestedCheckbox = direct.querySelector('.input-accordion-checkbox');
+                if (nestedCheckbox) {
+                    // Поднимаемся к ближайшему .input-accordion
+                    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 direct = gradioApp().getElementById(id);
+                    console.error(
+                        '[a1111-fix] 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:', gradioApp().getElementById('.' + id)
+                    );
+                }
+                return;
+            }
+
+            realEl.visibleCheckbox.checked = checked;
+            realEl.onVisibleCheckboxChange();
+        };
+
+        console.log('[a1111-fix] FIX-3: resilient accordion resolver applied');
+    }
+
+
+    // ─── Apply ────────────────────────────────────────────────────────────────
+
+    applyFix1();
+    applyFix2();
+    applyFix3();
+
+    console.log('[a1111-fix] v4.3 ready');
+
+})();

!!!0000-a1111-fix/metadata.ini

@@ -0,0 +1,22 @@
+[Extension]
+Name = 0000-a1111-fix
+
+; Порядок загрузки JS через topological sort A1111.
+;
+; Примечание по canonical name:
+; В официальной wiki A1111 поле Name описано как canonical name.
+; Но в загруженном dev-tree (modules/extensions.py) self.canonical_name
+; перезаписывается именем папки (extension_dirname), а не берётся из Name.
+; Поэтому на практике в этой ветке реальный canonical name = имя папки.
+; Поле Name здесь оставлено для читаемости, но не влияет на Before/After логику.
+;
+; tabs extension устанавливается двумя способами:
+;   git clone -> папка называется "sd-webui-tabs-extension"
+;   скачать zip с GitHub -> папка называется "sd-webui-tabs-extension-main"
+;
+; Перечисляем оба варианта. Несуществующие Before-цели A1111 молча игнорирует
+; (scripts.py: если scripts.get() и loaded_extensions_scripts.get() вернули None —
+; пропускается без ошибки).
+
+[javascript/fix.js]
+Before = sd-webui-tabs-extension sd-webui-tabs-extension-main