Upload fix.js

!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 (Array.isArray(status.currently_importing) && status.currently_importing.length) {
+                        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');
+})();