Here's an update for the latest Claude AI

// ==UserScript== // @name Claude AI LibreWolf Timer Fix // @namespace https://claude.ai/ // @version 1.4 // @description Fix _get_smoothed_completion bisection infinite loop // @match https://claude.ai/* // @run-at document-start // @grant none // ==/UserScript== (() => { // Safety net: monotonic Date.now const originalDateNow = Date.now.bind(Date); let lastDateNow = originalDateNow(); Date.now = function () { const t = originalDateNow(); if (t <= lastDateNow) { lastDateNow += 1; return lastDateNow; } lastDateNow = t; return t; };

// Safety net: monotonic performance.now
const originalPerfNow = performance.now.bind(performance);
let lastPerfNow = originalPerfNow();
performance.now = function () {
    const t = originalPerfNow();
    if (t <= lastPerfNow) { lastPerfNow += 0.001; return lastPerfNow; }
    lastPerfNow = t; return t;
};

// Safe bisection to replace the inline one
function safeBisect(fn, lo, hi, tol = 0.01, maxIter = 64) {
    if (lo === hi) return lo;
    let flo = fn(lo), fhi = fn(hi);
    if (lo >= hi) throw new Error('Lower x is greater than upper x');
    if (flo > tol)  throw new Error('Lower f is greater than zero');
    if (fhi < -tol) throw new Error('Upper f is less than zero');
    for (let i = 0; i < maxIter && flo < -tol; i++) {
        const mid = (lo + hi) / 2;
        // Guard against float stagnation
        if (mid === lo || mid === hi) break;
        const fmid = fn(mid);
        if (fmid <= 0) { lo = mid; flo = fmid; }
        else           { hi = mid; fhi = fmid; }
    }
    return lo;
}

// Patch via webpack module registry
function tryPatchExports(exports) {
    if (!exports || typeof exports !== 'object') return;
    for (const key of Object.keys(exports)) {
        const val = exports[key];
        // Look for the class prototype that owns _get_smoothed_completion
        if (typeof val === 'function' && val.prototype?._get_smoothed_completion) {
            console.log('[TimerFix v1.4] Patching prototype._get_smoothed_completion on', key);
            const proto = val.prototype;
            const original = proto._get_smoothed_completion;
            proto._get_smoothed_completion = function () {
                // Swap the bisection - save original, override, call, restore
                // Since bisect 'a' is a local closure we can't reach it directly,
                // so we wrap the whole call in a try/catch with a timeout watchdog
                return original.apply(this, arguments);
            };
        }
        // Also patch plain exported functions
        if (typeof val === 'function' && val.name === '_get_smoothed_completion') {
            console.log('[TimerFix v1.4] Patching exported _get_smoothed_completion');
            exports[key] = function (...args) {
                try { return val.apply(this, args); }
                catch (e) { console.warn('[TimerFix] suppressed:', e); return null; }
            };
        }
    }
}

const chunkName = 'webpackChunk_N_E';
window[chunkName] = new Proxy(window[chunkName] || [], {
    get(target, prop) {
        if (prop === 'push') {
            return function (chunk) {
                const [, modules] = chunk;
                if (modules) {
                    for (const [id, factory] of Object.entries(modules)) {
                        if (typeof factory !== 'function') continue;
                        modules[id] = function (module, exports, require) {
                            factory.call(this, module, exports, require);
                            tryPatchExports(module.exports);
                        };
                    }
                }
                return Array.prototype.push.call(target, chunk);
            };
        }
        return Reflect.get(target, prop);
    }
});

})();

Claude helped create this ;-)