Upload 4 files

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

@@ -0,0 +1,462 @@
+(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,
+                };
+            });
+        }
+
+        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');
+            }
+            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,13 @@
+[Extension]
+Name = 0000-a1111-fix
+
+; Notes:
+; - real canonical name in current A1111 branches is usually derived from folder name.
+; - the folder prefix !0000- still keeps this extension very early alphabetically.
+; - Before targets below are harmless if the target extension does not exist.
+;
+; We keep tabs/controlnet/canvas targets because FIX-3 specifically hardens accordion
+; behavior and FIX-2/4 should be active before heavy JS extensions register callbacks.
+
+[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

!!!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