Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/brightness/fixtures/suite.mjs

Raw
// `just ui-test brightness`: the registry brightness feature in the real Bar inside
// nested niri, driven by real pointer and keyboard against the feature's Brightness
// double: manual and stacked levels, compositor focus return, adaptive buckets and
// motion, threshold editing, and the DDC setup stages. Stages and outcomes enter
// through the pure double; production processes and authorization are not exercised.
// The suite contract (snapshot shape, helpers) is documented in .system/RULES.md.
import Brightness from '../brightness.js';

const names = {
    slider: 'fixture display brightness',
    global: 'all displays brightness',
    working: 'working monitor brightness',
    second: 'second monitor brightness',
    broken: 'failed monitor brightness',
    builtIn: 'built-in brightness',
    preset: 'all displays brightness 75%',
    solePreset: 'brightness 75%',
    adaptiveToggle: 'adaptive',
    setup: 'set up monitor control',
    cancel: 'cancel setup',
    retry: 'retry setup',
    ready: 'monitor control ready',
    showSteps: 'show steps',
    hideSteps: 'hide steps',
};
const bucketNames = ['dark', 'dim', 'bright', 'sunlight'];
const stageIds = ['preflight', 'authorization', 'installation', 'detection', 'reading', 'verification', 'ready'];
// Each expanded stage as the panel words it, beside its state.
const stageText = (id, status) => `${Brightness.stageLabel(id)} · ${status}`;
// The collapsed one-line summary of a running step.
const stepText = id => `step ${stageIds.indexOf(id) + 1} of ${stageIds.length} · ${Brightness.stageLabel(id)}`;

export default async function brightnessSuite({ assert, snapshot, open, check, click, input, key, screenshot, within, call, fixture, delay, focusedWindow }) {
    const brightness = value => value.features.brightness;
    const service = value => brightness(value).service;
    const control = (value, name) => brightness(value).controls[name === 'setup' ? 'configure light' : names[name]] || value.features.config.controls[names[name]];
    const bucket = (value, index) => brightness(value).controls[`${bucketNames[index]} ambient bucket`];
    const buckets = value => bucketNames.map((name, index) => bucket(value, index));
    const thresholdInput = value => Object.entries(brightness(value).controls).find(([name]) => name.endsWith(' threshold'))?.[1];
    const editorVisible = value => !!thresholdInput(value);
    const textHas = (value, text) => [...brightness(value).texts, ...value.features.config.texts].includes(text);
    const percentShown = value => brightness(value).texts.some(text => /^\d+%$/.test(text));
    const displayIds = value => service(value).displays.map(row => row.id).join(',');
    const display = (value, id) => service(value).displays.find(row => row.id === id);
    // Every row the service reports renders as a display card named after it.
    const rowsRendered = value => service(value).displays.every(row => brightness(value).controls[String(row.name)]);
    const displayFrames = value => service(value).displays.filter(row => row.controllable).map(row => brightness(value).controls[String(row.name)]?.rect);
    const setState = state => call('brightness', 'setState', state);

    function insidePanel(rect, value) {
        const panel = value.features[value.popup.name].surface;
        return rect && panel && rect.x >= panel.x && rect.y >= panel.y && rect.x + rect.width <= panel.x + panel.width && rect.y + rect.height <= panel.y + panel.height;
    }

    // Tab until the named control holds focus, then wait until the panel reveals it.
    async function focusControl(name) {
        for (let step = 0; step < 24; step++) {
            if (control(snapshot(), name)?.focused) {
                return await check(`keyboard reveals brightness ${name}`, value => {
                    const rect = control(value, name)?.rect;
                    const panel = value.features[value.popup.name].surface;
                    return rect && panel && rect.y >= panel.y && rect.y + rect.height <= panel.y + panel.height;
                });
            }
            key('Tab');
            await delay(50);
        }
        assert.fail(`brightness ${name} was not keyboard reachable`);
    }

    // A point on the output but off the popup card, for outside dismissal.
    function outsideRect(state) {
        const card = state.popup.card;
        const candidates = [
            { x: state.width - 14, y: state.height - 14, width: 6, height: 6 },
            { x: 8, y: state.height - 14, width: 6, height: 6 },
            { x: state.width - 14, y: 40, width: 6, height: 6 },
        ];
        const result = candidates.find(rect => rect.x + rect.width < card.x || rect.x > card.x + card.width || rect.y + rect.height < card.y || rect.y > card.y + card.height);
        assert(result && within(result, state.width, state.height), 'mapped output must contain an outside-click target');
        return result;
    }

    let state = snapshot();
    assert.equal(state.chips.brightness.label, 'light', 'registry bar label');
    assert.equal(state.chips.brightness.active, false, 'registry bar activity');
    assert.equal(service(state).sensorMonitoring, false, 'closed brightness without adaptive mode probes no sensor');

    // Manual control of the double's single display.
    state = await open('brightness', value => control(value, 'slider')?.rect);
    await check('one controllable display opens on its own slider without an all-displays slider', value =>
        control(value, 'slider')?.focused && !control(value, 'global') && control(value, 'solePreset')?.enabled);
    state = await check('open brightness probes the ambient sensor', value => service(value).sensorMonitoring);
    state = await check('manual presets show their level under the icon', value =>
        ['25%', '50%', '75%', '100%'].every(text => textHas(value, text)));
    assert(!textHas(state, 'brightness'), 'the panel does not repeat the chip name');
    click({ ...control(state, 'slider').rect, width: control(state, 'slider').rect.width * 1.5 });
    state = await check('brightness pointer updates the display', value => service(value).writes === 1 && service(value).level > 0.7);
    key('Right');
    state = await check('brightness keyboard updates the same display', value => service(value).writes === 2);
    call('brightness', 'externalUpdate');
    state = await check('brightness follows external updates after local actions without writeback', value => control(value, 'slider')?.value === 0.25 && service(value).writes === 2);
    await screenshot('brightness-live');
    const formerSlider = control(state, 'slider').rect;
    call('brightness', 'setAvailable', false);
    state = await check('unavailable display removes its slider and percentage, says why, and offers no futile setup', value =>
        !control(value, 'slider') && !control(value, 'global') && !percentShown(value) && !control(value, 'setup') &&
        textHas(value, 'this display does not accept brightness changes; check its cable and the monitor menu'));
    await screenshot('brightness-unavailable');
    // The row stays where the slider was, now without one: a click there writes
    // nothing. Escape follows the click, so the closed popup proves it was handled.
    const unavailableRow = brightness(state).controls['fixture display']?.rect;
    const formerCenter = { x: formerSlider.x + formerSlider.width / 2, y: formerSlider.y + formerSlider.height / 2 };
    assert(unavailableRow && formerCenter.x >= unavailableRow.x && formerCenter.x <= unavailableRow.x + unavailableRow.width &&
        formerCenter.y >= unavailableRow.y && formerCenter.y <= unavailableRow.y + unavailableRow.height, 'the unavailable row lies where the slider was');
    click(formerSlider);
    key('Escape');
    await check('a click where the slider was writes nothing', value => !value.popup.open && service(value).writes === 2);

    for (const docked of [false, true]) {
        const outputs = [{ name: 'LVDS-1', model: 'internal panel' }];
        if (docked) outputs.push({ name: 'HDMI-A-1', model: 'external monitor' });
        const displays = Brightness.displayRows({ present: true, level: 0.5 }, outputs, {});
        setState({
            displays,
            global: Brightness.globalState(displays),
            setup: { needed: displays.some(row => row.kind === 'ddc' && !row.controllable), available: true },
        });
        if (!docked)
            await open('brightness', value => control(value, 'builtIn')?.rect);
        await check(docked ? 'docked laptop offers DDC only for its external monitor' : 'internal laptop panel has backlight control without DDC setup', value =>
            control(value, 'builtIn')?.enabled && !!control(value, 'setup') === docked && rowsRendered(value) && !control(value, 'global') &&
            displayIds(value) === (docked ? 'backlight,ddc:HDMI-A-1' : 'backlight') &&
            (!docked || (display(value, 'ddc:HDMI-A-1').name === 'external monitor' && textHas(value, 'external monitor'))));
        await screenshot(docked ? 'brightness-docked' : 'brightness-laptop');
    }
    const differingDisplays = [
        { id: 'ddc:HDMI-A-1', name: 'working monitor', controllable: true, level: 0.4, issue: '' },
        { id: 'ddc:DP-1', name: 'second monitor', controllable: true, level: 0.8, issue: '' },
    ];
    setState({
        displays: differingDisplays,
        global: Brightness.globalState(differingDisplays),
        setup: { needed: false, available: true },
    });
    state = await check('different confirmed brightness levels form one stacked global control', value =>
        control(value, 'global')?.levels.join(',') === '0.4,0.8' && !textHas(value, 'mixed'));
    await screenshot('brightness-stacked');
    const beforeGlobalWrite = service(state).writes;
    click({ ...control(state, 'global').rect, width: control(state, 'global').rect.width * 1.5 });
    state = await check('shared drag sets the same absolute brightness on all controllable displays', value =>
        service(value).writes === beforeGlobalWrite + 1 && service(value).global.mode === 'synced' &&
        service(value).displays.every(row => row.level > 0.7 && row.level === service(value).displays[0].level) &&
        control(value, 'global').levels.length === 0);
    await screenshot('brightness-synced');

    // Focus returns to the application that was active before the popup opened.
    key('Escape');
    await check('close manual brightness before establishing application focus', value => !value.popup.open);
    await check('closed brightness stops probing the ambient sensor', value => !service(value).sensorMonitoring);
    fixture('focus-target');
    let focusTargetId;
    await check('nested compositor focuses the previous application before opening brightness', value => {
        const focused = focusedWindow();
        if (focused?.title !== 'focus target' || !value.focusTargetActive) return false;
        focusTargetId = focused.id;
        return true;
    });
    state = await open('brightness', value => control(value, 'global')?.rect);

    const adaptiveDisplays = [
        { id: 'ddc:HDMI-A-1', name: 'working monitor', controllable: true, level: 0.4, issue: '' },
        { id: 'ddc:DP-1', name: 'second monitor', controllable: true, level: 0.8, issue: '' },
    ];
    const adaptiveState = {
        displays: adaptiveDisplays,
        global: Brightness.globalState(adaptiveDisplays),
        setup: { needed: false, available: true, ready: true, expanded: false, running: false },
        adaptive: {
            enabled: true,
            available: true,
            active: true,
            currentBucket: 1,
            raw: 50,
            thresholds: [25, 100, 300],
            buckets: bucketNames.map((label, index) => ({
                id: label,
                label,
                target: [0.25, 0.5, 0.75, 1][index],
                targets: {
                    'ddc:HDMI-A-1': [0.25, 0.5, 0.75, 1][index],
                    'ddc:DP-1': [0.25, 0.5, 0.75, 1][index],
                },
            })),
            error: '',
            persistenceError: '',
        },
    };
    setState(adaptiveState);
    state = await check('adaptive brightness defaults checked with four ambient buckets', value =>
        control(value, 'adaptiveToggle')?.enabled && control(value, 'adaptiveToggle').checked &&
        service(value).adaptive?.enabled && service(value).adaptive.currentBucket === 1 &&
        buckets(value).every(button => button?.rect) &&
        buckets(value).filter(button => button.checked).length === 1 &&
        bucket(value, 1).checked && bucket(value, 1).enabled);
    assert.equal(bucket(state, 1).rect.height, bucket(state, 0).rect.height);
    state = await check('adaptive-ready shows both display controls inside the viewport without scrolling', value =>
        displayFrames(value).length === 2 && displayFrames(value).every(rect => insidePanel(rect, value)) &&
        insidePanel(control(value, 'adaptiveToggle').rect, value));
    await screenshot('brightness-adaptive-ready');

    // Real Qt animation + real nested input, not service-level target checks.
    const working = value => control(value, 'working')?.value;
    const global = value => control(value, 'global')?.value;
    const motionState = level => {
        const displays = adaptiveDisplays.map(row => ({ ...row, level }));
        return { ...adaptiveState, displays, global: Brightness.globalState(displays) };
    };
    fixture('motion-on');
    setState(motionState(0.25));
    await check('motion-enabled brightness settles at its initial displayed level', value =>
        Math.abs(working(value) - 0.25) < 0.001 && Math.abs(global(value) - 0.25) < 0.001);
    for (let frame = 0; frame < 8; frame++) {
        if (frame === 0 || frame === 4)
            setState(motionState(frame === 0 ? 0.75 : 0.25));
        if (frame === 0)
            await check('adaptive UI shows intermediate levels before convergence', value =>
                working(value) > 0.25 && working(value) < 0.75 && global(value) > 0.25 && global(value) < 0.75);
        await screenshot(`brightness-motion-${String(frame).padStart(2, '0')}`, 0);
        await delay(40);
    }
    await check('adaptive UI converges after the eased transition', value => Math.abs(working(value) - 0.25) < 0.001);
    state = await focusControl('working');
    const beforeKeyboardMotion = service(state).writes;
    setState(motionState(0.75));
    await check('keyboard interruption starts during an active tween', value => working(value) > 0.25 && working(value) < 0.75);
    key('Right');
    await check('keyboard input interrupts easing and confirms immediately without extra writes', value => {
        const confirmed = display(value, 'ddc:HDMI-A-1')?.level;
        return service(value).writes === beforeKeyboardMotion + 1 && Math.abs(working(value) - confirmed) < 0.001;
    });
    setState(motionState(0.25));
    await check('pointer interruption has a settled starting level', value => Math.abs(working(value) - 0.25) < 0.001);
    const beforePointerMotion = service(snapshot()).writes;
    setState(motionState(0.75));
    state = await check('pointer interruption starts during an active tween', value => working(value) > 0.25 && working(value) < 0.75);
    click({ ...control(state, 'working').rect, width: control(state, 'working').rect.width * 1.5 });
    await check('pointer input interrupts easing and confirms immediately without extra writes', value => {
        const confirmed = display(value, 'ddc:HDMI-A-1')?.level;
        return service(value).writes === beforePointerMotion + 1 && Math.abs(working(value) - confirmed) < 0.001;
    });
    fixture('motion-off');
    setState(motionState(0.3));
    await check('low-power motion-off updates displayed values without a tween', value => working(value) === 0.3 && global(value) === 0.3);
    setState(adaptiveState);
    state = await check('motion-only updates never dispatch native intents or replace learned targets', value =>
        service(value).writes === beforePointerMotion + 1 && service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === 0.5);

    // Learning: manual writes teach only the current ambient bucket.
    const adaptiveWrites = service(state).writes;
    click({ ...control(state, 'global').rect, width: control(state, 'global').rect.width * 1.5 });
    state = await check('shared adaptive pointer write learns only the current ambient bucket', value =>
        service(value).writes === adaptiveWrites + 1 && service(value).displays.every(row => row.level > 0.7) &&
        service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] > 0.7 &&
        service(value).adaptive.buckets[1].targets['ddc:DP-1'] > 0.7 &&
        service(value).adaptive.buckets[0].targets['ddc:HDMI-A-1'] === 0.25);
    const sharedTargets = service(state).adaptive.buckets[1].targets;
    state = await focusControl('working');
    key('Right');
    state = await check('per-display adaptive keyboard write learns only that display in the current bucket', value =>
        service(value).writes === adaptiveWrites + 2 &&
        service(value).adaptive.currentBucket === 1 &&
        service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] > sharedTargets['ddc:HDMI-A-1'] &&
        service(value).adaptive.buckets[1].targets['ddc:DP-1'] === sharedTargets['ddc:DP-1']);
    const learnedTargets = service(state).adaptive.buckets[1].targets;
    call('brightness', 'setAmbient', 2);
    await check('external ambient change applies confirmed targets without teaching the new bucket', value =>
        service(value).adaptive.currentBucket === 2 && service(value).adaptive.raw === 200 &&
        service(value).adaptive.buckets[2].targets['ddc:HDMI-A-1'] === 0.75 &&
        service(value).displays.every(row => row.level === 0.75));
    call('brightness', 'setAmbient', 1);
    state = await check('external ambient return restores confirmed learned display values', value =>
        service(value).adaptive.currentBucket === 1 && service(value).adaptive.raw === 50 &&
        service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === learnedTargets['ddc:HDMI-A-1'] &&
        service(value).adaptive.buckets[1].targets['ddc:DP-1'] === learnedTargets['ddc:DP-1'] &&
        display(value, 'ddc:HDMI-A-1').level === learnedTargets['ddc:HDMI-A-1'] &&
        display(value, 'ddc:DP-1').level === learnedTargets['ddc:DP-1']);
    await screenshot('brightness-adaptive-mixed-learned');

    // Threshold editing on an inactive bucket.
    const inactiveTargets = service(state).adaptive.buckets[3].targets;
    click(bucket(state, 3).rect);
    state = await check('inactive ambient bucket opens a threshold editor without changing selection', value =>
        editorVisible(value) && thresholdInput(value).rect && bucket(value, 3).focused &&
        buckets(value).filter(button => button.checked).length === 1 && bucket(value, 1).checked && !bucket(value, 3).checked);
    key('Tab');
    state = await check('Tab enters the inactive bucket threshold field', value => thresholdInput(value)?.focused);
    key('ctrl+a');
    input('type', '350');
    // Leaving loses nothing: the open editor and its draft survive close and reopen.
    click(snapshot().chips.brightness.rect);
    await check('chip closes brightness with an unconfirmed threshold draft', value => !value.popup.open);
    state = await open('brightness', value => thresholdInput(value)?.rect);
    state = await check('reopened brightness restores the threshold editor and its draft', value =>
        brightness(value).retained.expandedBucket === 3 && brightness(value).retained.lowerDraft === '350' &&
        thresholdInput(value)?.filled && service(value).adaptive.thresholds.join(',') === '25,100,300');
    await screenshot('brightness-threshold-retained');
    for (let step = 0; step < 24 && !thresholdInput(snapshot())?.focused; step++) {
        key('Tab');
        await delay(50);
    }
    state = await check('Tab returns to the retained threshold field', value => thresholdInput(value)?.focused);
    key('Return');
    state = await check('threshold Enter confirms an inactive bucket boundary without teaching its target', value =>
        service(value).adaptive.thresholds.join(',') === '25,100,350' &&
        service(value).adaptive.buckets[3].targets['ddc:HDMI-A-1'] === inactiveTargets['ddc:HDMI-A-1'] &&
        thresholdInput(value)?.focused);
    key('ctrl+a');
    input('type', '25');
    key('Return');
    await check('out-of-order threshold input preserves the confirmed boundary', value =>
        service(value).adaptive.thresholds.join(',') === '25,100,350' && textHas(value, 'thresholds must stay ordered'));
    // The field takes digits only, so typed text never outgrows it.
    key('ctrl+a');
    input('type', 'invalid7');
    await check('threshold field rejects letters and keeps typed digits', value => brightness(value).retained.lowerDraft === '7');
    key('ctrl+a');
    key('BackSpace');
    key('Return');
    state = await check('invalid threshold draft preserves confirmed thresholds and reveals readable feedback', value =>
        service(value).adaptive.thresholds.join(',') === '25,100,350' && textHas(value, 'enter a whole number') &&
        ['sunlight:', 'light from', '· now 50'].every(text => textHas(value, text)) &&
        insidePanel(brightness(value).items.thresholdWarning?.rect, value) && insidePanel(thresholdInput(value)?.rect, value));
    await screenshot('brightness-threshold-editor');
    key('Tab');
    await check('expanded brightness content remains keyboard reachable inside the viewport', value =>
        value.popup.open && editorVisible(value) && control(value, 'working')?.focused && insidePanel(control(value, 'working').rect, value));
    key('Tab');
    await check('expanded brightness reaches the last display without clipping its control', value =>
        value.popup.open && editorVisible(value) && control(value, 'second')?.focused && insidePanel(control(value, 'second').rect, value));
    await screenshot('brightness-threshold-expanded-reachable');
    key('shift+Tab');
    await check('reverse Tab returns from the last display to the first', value => control(value, 'working')?.focused);
    key('shift+Tab');
    await check('reverse Tab returns to the threshold field before local Escape', value => thresholdInput(value)?.focused);
    key('Escape');
    state = await check('Escape from threshold input closes the editor and returns focus to its bucket', value =>
        value.popup.open && value.popup.name === 'brightness' && !editorVisible(value) && bucket(value, 3).focused);
    key('Escape');
    await check('next Escape dismisses adaptive brightness', value => !value.popup.open && value.popup.lastCloseReason === 'escape-key');
    await check('enabled adaptive mode keeps probing the sensor while brightness is closed', value => service(value).sensorMonitoring);
    await check('nested compositor returns keyboard focus to the previously active application', value => {
        const focused = focusedWindow();
        return value.focusTargetActive && focused?.id === focusTargetId && focused.title === 'focus target';
    });

    // Manual and adaptive modes, sensor and DDC availability.
    state = await open('brightness', value => control(value, 'adaptiveToggle')?.rect);
    // Reopening preserves scroll; reveal the header before pointer activation.
    state = await focusControl('adaptiveToggle');
    click(control(state, 'adaptiveToggle').rect);
    state = await check('manual mode restores percentage presets', value =>
        !service(value).adaptive.enabled && control(value, 'preset')?.rect && control(value, 'preset').enabled);
    click(control(state, 'preset').rect);
    state = await check('manual percentage preset sets every controllable display', value =>
        service(value).displays.every(row => row.level === 0.75));
    click(control(state, 'adaptiveToggle').rect);
    state = await check('adaptive toggle restores confirmed learned targets', value =>
        service(value).adaptive.enabled && service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === learnedTargets['ddc:HDMI-A-1']);
    call('brightness', 'setSensorAvailable', false);
    state = await check('sensor unplug disables adaptive without discarding confirmed values', value =>
        !control(value, 'adaptiveToggle').enabled && service(value).adaptive.enabled &&
        service(value).adaptive.thresholds.join(',') === '25,100,350' &&
        service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === learnedTargets['ddc:HDMI-A-1']);
    await screenshot('brightness-adaptive-unavailable');
    call('brightness', 'setSensorAvailable', true);
    await check('sensor replug restores the selected adaptive mode', value =>
        control(value, 'adaptiveToggle').enabled && service(value).adaptive.enabled && service(value).adaptive.active);
    call('brightness', 'setDdcReady', false);
    state = await check('DDC not ready removes adaptive and fake brightness values', value =>
        !control(value, 'adaptiveToggle') && !brightness(value).items.adaptiveStatus && !control(value, 'global') && !control(value, 'preset') && !percentShown(value));
    await screenshot('brightness-adaptive-ddc-unavailable');

    // DDC setup: stages and outcomes from the pure double.
    const setupState = {
        displays: [
            { id: 'ddc:HDMI-A-1', name: 'working monitor', controllable: false, issue: 'needs setup' },
            { id: 'ddc:DP-1', name: 'failed monitor', controllable: false, issue: 'needs setup' },
        ],
        global: { mode: 'none', level: 0, levels: [] },
        setup: {
            needed: true, available: true, expanded: false, running: false,
            stages: stageIds.map(id => ({ id, status: 'waiting', error: '' })),
        },
    };
    setState(setupState);
    state = await check('detected external displays expose setup without global controls or invented values', value =>
        brightness(value).controls['configure light']?.enabled && !control(value, 'global') && !control(value, 'preset') &&
        !control(value, 'working') && !control(value, 'broken') && rowsRendered(value) &&
        displayIds(value) === 'ddc:HDMI-A-1,ddc:DP-1' &&
        !brightness(value).texts.some(text => /^(?:\d+%|n\/a)$/.test(text)));
    assert.equal(service(state).setups, 0, 'discovery cannot start setup');
    await screenshot('brightness-setup-needed');
    click(brightness(state).controls['configure light'].rect);
    state = await check('Light routes its declaration to Config without sensor demand', value =>
        value.popup.name === 'config' && value.popup.windowActive &&
        value.features.config.service.selectedSection === 'light' && control(value, 'setup')?.enabled && !service(value).sensorMonitoring);
    click(control(state, 'setup').rect);
    state = await check('explicit setup starts observable preflight in one summary line and disables duplicate submission', value =>
        service(value).setups === 1 && !control(value, 'setup').enabled && control(value, 'cancel')?.enabled &&
        insidePanel(control(value, 'cancel').rect, value) && control(value, 'showSteps')?.enabled &&
        textHas(value, stepText('preflight')) && !stageIds.some(id => textHas(value, stageText(id, 'waiting'))));
    click(control(state, 'setup').rect);
    assert.equal(service(snapshot()).setups, 1);
    // Past the tooltip delay, the pointer still on the disabled action shows no tooltip over the summary.
    await delay(800);
    assert(!control(snapshot(), 'setup').tooltip, 'the disabled setup action shows no tooltip over the summary');
    await screenshot('brightness-preflight');
    click(control(state, 'showSteps').rect);
    state = await check('show steps expands every stage as running or waiting', value =>
        control(value, 'hideSteps') && textHas(value, stageText('preflight', 'running')) &&
        stageIds.slice(1).every(id => textHas(value, stageText(id, 'waiting'))));
    await screenshot('brightness-preflight-steps');
    for (const stage of ['authorization', 'installation', 'detection']) {
        call('brightness', 'advanceSetup', stage);
        state = await check(`mock ${stage} stage is visibly running after completed predecessors`, value =>
            textHas(value, stageText(stage, 'running')) && stageIds.slice(0, stageIds.indexOf(stage)).every(id => textHas(value, stageText(id, 'done'))));
        await screenshot(`brightness-${stage}`);
    }
    click(control(state, 'cancel').rect);
    state = await check('cancel intent renders a neutral cancellation and retains completed installation', value =>
        service(value).cancellations === 1 && control(value, 'retry')?.enabled && !control(value, 'cancel') &&
        textHas(value, stageText('installation', 'done')) && textHas(value, stageText('detection', 'cancelled')) &&
        textHas(value, 'find monitors cancelled') && !value.features.config.texts.some(text => /· failed|failed ·/.test(text)));
    await screenshot('brightness-cancelled-steps');
    state = await focusControl('hideSteps');
    key('Return');
    state = await check('keyboard hide steps collapses setup to its cancelled summary', value =>
        control(value, 'showSteps')?.focused && textHas(value, 'find monitors cancelled') &&
        !textHas(value, stageText('installation', 'done')) && value.features.config.texts.filter(text => text.includes('cancelled')).length === 1);
    await screenshot('brightness-cancelled');
    state = await focusControl('retry');
    click(control(state, 'retry').rect);
    state = await check('retry routes once and summarises refreshed preflight', value =>
        service(value).retries === 1 && service(value).setups === 2 && textHas(value, stepText('preflight')) && !control(value, 'retry'));
    for (const stage of ['authorization', 'installation', 'detection', 'reading', 'verification']) {
        call('brightness', 'advanceSetup', stage);
        await check(`retry summarises ${stage} status`, value => textHas(value, stepText(stage)) && !textHas(value, stageText(stage, 'running')));
    }
    const partial = JSON.parse(JSON.stringify(setupState));
    partial.displays[0] = { ...partial.displays[0], controllable: true, level: 0.4, issue: '' };
    partial.displays[1].issue = 'read failed';
    partial.global = { mode: 'synced', level: 0.4, levels: [0.4] };
    partial.setup = {
        ...partial.setup, expanded: true, running: false, error: 'some displays unavailable',
        stages: stageIds.map((id, index) => ({ id, status: index < 4 ? 'done' : index === 4 ? 'failed' : 'waiting', error: index === 4 ? 'read failed' : '' })),
    };
    setState(partial);
    state = await check('failed read shows its stage details and leaves the working monitor and presets usable with stage retry', value =>
        service(value).displays[0].controllable && !service(value).displays[1].controllable &&
        control(value, 'retry')?.enabled && textHas(value, 'read brightness failed · read failed') && textHas(value, 'some displays unavailable') &&
        !textHas(value, stageText('detection', 'done')));
    await screenshot('brightness-partial-read-failure');
    state = await open('brightness', value => control(value, 'working')?.rect);
    assert(control(state, 'working')?.enabled && !control(state, 'broken') && !control(state, 'global') && control(state, 'solePreset')?.enabled);
    const writesBefore = service(state).writes;
    state = await focusControl('working');
    click(control(state, 'working').rect);
    key('Right');
    state = await check('working display accepts pointer and keyboard while failed monitor retains no value', value =>
        service(value).writes === writesBefore + 2 && service(value).lastDisplay === 'ddc:HDMI-A-1' &&
        service(value).displays[0].level > 0.4 && service(value).displays[1].level === undefined &&
        service(value).global.mode === 'synced' &&
        service(value).global.level === service(value).displays[0].level &&
        service(value).global.levels.length === 1 && service(value).global.levels[0] === service(value).displays[0].level);
    await screenshot('brightness-partial-controls');
    click(control(state, 'solePreset').rect);
    await check('quarter-step preset routes global intent without granting failed monitor control', value =>
        service(value).writes === writesBefore + 3 && service(value).displays[0].level === 0.75 && !control(value, 'broken') &&
        service(value).global.mode === 'synced' && service(value).global.level === 0.75 &&
        service(value).global.levels.join(',') === '0.75');
    click(brightness(snapshot()).controls['configure light'].rect);
    await check('partial setup deep link retains Config selection', value => value.popup.name === 'config' && value.popup.windowActive && control(value, 'retry')?.enabled);
    state = await focusControl('retry');
    click(control(state, 'retry').rect);
    await check('partial failure retry routes from visible action', value => service(value).retries === 2 && textHas(value, stepText('preflight')));
    call('brightness', 'advanceSetup', 'ready');
    state = await check('successful fixture setup collapses to a neutral reopenable ready state', value =>
        control(value, 'ready')?.enabled && !control(value, 'cancel') && !control(value, 'showSteps') &&
        !textHas(value, stageText('preflight', 'done')) && !textHas(value, stepText('preflight')));
    await screenshot('brightness-ready-compact');
    click(control(state, 'ready').rect);
    state = await check('ready action reopens all completed stages without another setup', value =>
        stageIds.every(id => textHas(value, stageText(id, 'done'))) && service(value).setups === 3 && !control(value, 'showSteps'));
    await screenshot('brightness-ready-expanded');
    key('Escape');
    await check('Escape dismisses expanded brightness setup', value => !value.popup.open);
    state = await open('config', value => control(value, 'ready')?.rect);
    click(outsideRect(state));
    await check('outside pointer dismisses brightness after reopen', value => !value.popup.open);
    setState(null);

    // The shared slider's other callers on the same fixture: normal power must
    // not turn their opt-out controls into animations.
    fixture('motion-on');
    const audioSlider = value => value.features.audio.controls['fixture output output volume'];
    const audio = value => value.features.audio.service;
    state = await open('audio', value => audioSlider(value)?.rect);
    let writes = audio(state).volumeWrites;
    click({ ...audioSlider(state).rect, width: audioSlider(state).rect.width * 1.4 });
    state = await check('audio shared slider retains immediate pointer control', value =>
        audio(value).volumeWrites > writes && audio(value).volume > 0.65 && Math.abs(audioSlider(value).value * 1.5 - audio(value).volume) < 0.006);
    writes = audio(state).volumeWrites;
    key('Right');
    state = await check('audio shared slider retains immediate keyboard control', value =>
        audio(value).volumeWrites === writes + 1 && audio(value).volume > 0.7 && Math.abs(audioSlider(value).value * 1.5 - audio(value).volume) < 0.006);
    writes = audio(state).volumeWrites;
    call('audio', 'externalUpdate');
    await check('external audio updates redraw without user intents or tweening', value =>
        audio(value).volume === 0.8 && Math.abs(audioSlider(value).value - 80 / 150) < 0.001 && audio(value).volumeWrites === writes);
    await screenshot('brightness-audio-slider-regression');
    fixture('motion-off');
}