codex-chatgpt-control 0.3.0-alpha.1 → 0.5.1-alpha.1

package/dist/src/commands/configuration.js

@@ -0,0 +1,897 @@
+import { enumerateVisibleMenuItems } from "../dom/menus.js";
+import { localeLabels } from "../dom/locale-labels.js";
+import { normalizeForLabelMatch, visibleLabelMatches } from "../dom/label-match.js";
+import { resultError, resultOk } from "../errors.js";
+import { tabIdFromPage } from "../browser/attach.js";
+import { contextFromPage } from "./context.js";
+import { detectExperience, openExperience } from "./experience.js";
+import { setMode } from "./modes.js";
+import { ensurePage } from "./session.js";
+const WORK_AXES = ["model", "effort", "speed"];
+const CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS = 5_000;
+const CONFIGURATION_CONTROL_POLL_MS = 250;
+const CONFIGURATION_AXIS_ORDER = [
+    "model",
+    "intelligence",
+    "effort",
+    "speed",
+    "modelVersion",
+];
+export async function inspectConfiguration(env, args = {}) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const detected = await detectExperience(env, args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs });
+        if (!detected.ok || detected.data === undefined) {
+            return forwardFailure(detected);
+        }
+        if (args.experience !== undefined && detected.data.experience !== args.experience) {
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: {
+                    kind: "selector_drift",
+                    code: "experience_mismatch",
+                    fieldPath: "experience",
+                    message: `Configuration inspection expected ${args.experience}, but the visible composer is ${detected.data.experience}. Call experience.open first or omit the expected experience.`,
+                    resumable: true
+                },
+                context: await contextFromPage(page, {
+                    experience: detected.data.experience,
+                    selectorProfile: detected.data.selectorProfile
+                })
+            };
+        }
+        const experience = detected.data.experience;
+        const rootOpened = experience !== "unknown" && await waitForConfigurationRoot(page, experience, args.timeoutMs);
+        if (rootOpened) {
+            await page.waitForTimeout?.(150);
+        }
+        const workAdvancedOpened = experience !== "work"
+            || (rootOpened && await ensureWorkAdvancedPanel(page));
+        if (experience === "work" && workAdvancedOpened) {
+            await page.waitForTimeout?.(150);
+        }
+        const panel = await readConfigurationPanel(page);
+        const rootItems = rootOpened ? await enumerateVisibleMenuItems(page) : [];
+        const data = configurationInspectionFromSurface(experience, detected.data.selectorProfile, detected.data.evidence, panel, rootItems);
+        if (args.includeOptions !== false && experience === "work" && panel.axisRows.length > 0) {
+            for (const axis of WORK_AXES) {
+                if (!data.availableAxes.includes(axis))
+                    continue;
+                const options = await inspectWorkAxisOptions(env, axis);
+                if (options.length > 0) {
+                    data.options[axis] = options;
+                }
+            }
+            await closeConfigurationMenus(page);
+        }
+        const warnings = [];
+        if (!rootOpened) {
+            warnings.push("No scoped configuration opener was available; inspection is limited to controls already visible in the composer.");
+        }
+        if (experience === "work" && rootOpened && !workAdvancedOpened) {
+            warnings.push("The Work configuration menu opened, but its Advanced model, effort, and speed controls could not be made visible.");
+        }
+        if (!data.verified) {
+            warnings.push("The visible configuration could not be verified from a recognized Chat or Work selector profile.");
+        }
+        return resultOk(data, await contextFromPage(page, {
+            experience: data.experience,
+            selectorProfile: data.selectorProfile
+        }), warnings);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+async function waitForConfigurationRoot(page, experience, timeoutMs) {
+    const discoveryMs = Math.min(timeoutMs ?? CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS, CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS);
+    const attempts = Math.max(1, Math.ceil(Math.max(0, discoveryMs) / CONFIGURATION_CONTROL_POLL_MS));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        if (await openConfigurationRoot(page, experience))
+            return true;
+        if (attempt + 1 < attempts) {
+            await page.waitForTimeout?.(CONFIGURATION_CONTROL_POLL_MS);
+        }
+    }
+    return false;
+}
+export async function applyConfiguration(env, args) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    const strict = args.strict ?? true;
+    try {
+        const desired = normalizeDesiredSelection(args.desired);
+        if (selectionEntries(desired).length === 0) {
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: {
+                    kind: "selector_drift",
+                    code: "configuration_empty",
+                    fieldPath: "desired",
+                    message: "configuration.apply requires at least one desired model, intelligence, effort, speed, or modelVersion value.",
+                    resumable: false
+                },
+                context: await contextFromPage(page)
+            };
+        }
+        if (args.experience !== undefined) {
+            const opened = await openExperience(env, {
+                experience: args.experience,
+                ...(args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs })
+            });
+            if (!opened.ok) {
+                return forwardFailure(opened);
+            }
+        }
+        const beforeResult = await inspectConfiguration(env, {
+            ...(args.experience === undefined ? {} : { experience: args.experience }),
+            includeOptions: true,
+            ...(args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs })
+        });
+        if (!beforeResult.ok || beforeResult.data === undefined) {
+            return forwardFailure(beforeResult);
+        }
+        const before = beforeResult.data;
+        if (before.experience === "unknown") {
+            return configurationFailure(page, before, desired, [], "The visible surface is not recognizable as Chat or Work.", "experience_unknown");
+        }
+        const selected = [];
+        for (const [axis, requested] of selectionEntries(desired)) {
+            const active = activeConfigurationValue(before, axis);
+            if (active !== undefined && configurationValueMatches(active, requested)) {
+                selected.push({ axis, requested, selected: active });
+                continue;
+            }
+            const selection = before.experience === "work"
+                ? await selectWorkAxis(env, axis, requested)
+                : await selectChatAxis(env, axis, requested, args.timeoutMs);
+            if (selection === undefined) {
+                return configurationFailure(page, before, desired, selected, `Configuration option "${requested}" for ${axis} was not found or was ambiguous on the ${before.experience} surface.`, "configuration_option_not_found", before.options[axis]?.map(option => option.label));
+            }
+            selected.push({ axis, requested, selected: selection });
+        }
+        const afterResult = await inspectConfiguration(env, {
+            ...(args.experience === undefined ? {} : { experience: args.experience }),
+            includeOptions: false,
+            ...(args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs })
+        });
+        if (!afterResult.ok || afterResult.data === undefined) {
+            return forwardFailure(afterResult);
+        }
+        const after = afterResult.data;
+        const verified = configurationMatchesSelection(after, desired);
+        const data = { requested: desired, selected, before, after, verified };
+        if (!verified && strict) {
+            return {
+                ok: false,
+                status: "blocked",
+                data,
+                warnings: [],
+                blocker: {
+                    kind: "selector_drift",
+                    code: "configuration_postcondition_unverified",
+                    fieldPath: "desired",
+                    message: `ChatGPT accepted configuration clicks, but the visible ${after.experience} controls do not verify every requested value.`,
+                    candidates: Object.entries(after.active).map(([axis, label]) => ({ label: `${axis}: ${label}` })),
+                    resumable: true
+                },
+                context: await contextFromPage(page, {
+                    experience: after.experience,
+                    selectorProfile: after.selectorProfile
+                })
+            };
+        }
+        const warnings = verified
+            ? []
+            : ["Configuration clicks completed, but strict verification was disabled and the visible postcondition remains unverified."];
+        return resultOk(data, await contextFromPage(page, {
+            experience: after.experience,
+            selectorProfile: after.selectorProfile
+        }), warnings);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+export function configurationInspectionFromSurface(experience, detectedProfile, evidence, panel, menuItems) {
+    const active = {};
+    const options = {};
+    const availableAxes = [];
+    let selectorProfile = detectedProfile;
+    if (experience === "work") {
+        for (const row of panel.axisRows) {
+            if (!availableAxes.includes(row.axis))
+                availableAxes.push(row.axis);
+            if (row.value !== undefined && row.value.length > 0)
+                active[row.axis] = row.value;
+        }
+        selectorProfile = panel.advancedVisible ? "work_advanced_v1" : "work_basic_v1";
+    }
+    else if (experience === "chat") {
+        const simplified = chatMenuLooksSimplified(menuItems);
+        selectorProfile = simplified ? "chat_simplified_v1" : detectedProfile;
+        const axis = simplified ? "intelligence" : "effort";
+        if (menuItems.length > 0 || panel.openerLabel !== undefined) {
+            availableAxes.push(axis);
+        }
+        if (panel.openerLabel !== undefined) {
+            active[axis] = panel.openerLabel;
+        }
+        const chatOptions = menuItems
+            .filter(item => !isConfigurationAxisRow(item.label))
+            .map(menuItemToOption);
+        if (chatOptions.length > 0) {
+            options[axis] = chatOptions;
+        }
+        const modelRows = menuItems.filter(item => /^gpt[\s-]/i.test(item.label) || item.hasPopup === true);
+        if (modelRows.length > 0) {
+            availableAxes.push("modelVersion");
+            options.modelVersion = modelRows.map(menuItemToOption);
+        }
+    }
+    return {
+        experience,
+        selectorProfile,
+        availableAxes,
+        active,
+        options,
+        verified: experience !== "unknown" && (availableAxes.length > 0 || Object.keys(active).length > 0),
+        evidence
+    };
+}
+async function inspectWorkAxisOptions(env, axis) {
+    const page = env.page;
+    const options = (await openWorkAxisOptions(env, axis))
+        .map(menuItemToOption);
+    await closeConfigurationSubmenu(page);
+    return dedupeOptions(options);
+}
+async function selectWorkAxis(env, axis, requested) {
+    const page = env.page;
+    if (!WORK_AXES.includes(axis)) {
+        return undefined;
+    }
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const candidates = await openWorkAxisOptions(env, axis);
+        const match = findConfigurationOption(candidates, requested);
+        if (match !== undefined && await clickVisibleMenuItem(page, match)) {
+            await page.waitForTimeout?.(150);
+            return match.label;
+        }
+        if (attempt === 0) {
+            // The submenu can disappear between enumeration and the visible click
+            // when ChatGPT's pointer-grace timer fires. Reopen once and click from a
+            // fresh DOM instance instead of treating that transient race as drift.
+            await closeConfigurationMenus(page);
+            await page.waitForTimeout?.(200);
+        }
+    }
+    return undefined;
+}
+async function openWorkAxisOptions(env, axis, allowRootRetry = true) {
+    const page = env.page;
+    if (!await ensureWorkAdvancedPanel(page))
+        return [];
+    const row = await findWorkAxisRow(page, axis);
+    if (row === undefined)
+        return [];
+    const visibleOptions = async () => filterWorkAxisOptions(await enumerateVisibleMenuItems(page), axis);
+    const alreadyOpen = await visibleOptions();
+    if (alreadyOpen.length > 0)
+        return alreadyOpen;
+    const point = await locatorCenter(row);
+    if (point !== undefined && await movePointerWithCdp(env, point)) {
+        await page.waitForTimeout?.(180);
+        const hoveredOptions = await visibleOptions();
+        if (hoveredOptions.length > 0)
+            return hoveredOptions;
+        // Radix may apply the previous submenu's pointer-grace close after the new
+        // axis briefly opens. Once that timer has elapsed, a tiny in-row nudge
+        // creates a fresh hover transition without ever leaving the root menu.
+        await movePointerWithCdp(env, { x: point.x - 2, y: point.y });
+        await movePointerWithCdp(env, point);
+        await page.waitForTimeout?.(180);
+        const retriedOptions = await visibleOptions();
+        if (retriedOptions.length > 0)
+            return retriedOptions;
+    }
+    if (point !== undefined && page.mouse?.move !== undefined) {
+        try {
+            await page.mouse.move(point.x, point.y);
+        }
+        catch {
+            // Fall through to the Computer Use and click fallbacks.
+        }
+        await page.waitForTimeout?.(180);
+        const mouseOptions = await visibleOptions();
+        if (mouseOptions.length > 0)
+            return mouseOptions;
+    }
+    if (point !== undefined && typeof page.cua?.move === "function") {
+        try {
+            await page.cua.move(point);
+        }
+        catch {
+            // Fall through to the click fallback.
+        }
+        await page.waitForTimeout?.(180);
+        const movedOptions = await visibleOptions();
+        if (movedOptions.length > 0)
+            return movedOptions;
+    }
+    if (row.click !== undefined) {
+        await row.click().catch(() => undefined);
+        await page.waitForTimeout?.(180);
+    }
+    const clickedOptions = await visibleOptions();
+    if (clickedOptions.length > 0 || !allowRootRetry)
+        return clickedOptions;
+    // A submenu pointer-grace dismissal can also close the root menu. Reopen the
+    // complete Advanced panel once and resolve a fresh row locator; stale row
+    // handles and same-coordinate pointer moves cannot recover a detached menu.
+    await closeConfigurationMenus(page);
+    await page.waitForTimeout?.(200);
+    return openWorkAxisOptions(env, axis, false);
+}
+async function locatorCenter(locator) {
+    if (locator.evaluate === undefined)
+        return undefined;
+    return locator.evaluate(element => {
+        const rect = element.getBoundingClientRect();
+        return {
+            x: Math.round(rect.left + rect.width / 2),
+            y: Math.round(rect.top + rect.height / 2)
+        };
+    }).catch(() => undefined);
+}
+async function movePointerWithCdp(env, point) {
+    const page = env.page;
+    const tabId = page === undefined ? undefined : tabIdFromPage(page);
+    if (tabId === undefined || env.browser?.tabs?.get === undefined)
+        return false;
+    try {
+        const tab = await env.browser.tabs.get(tabId);
+        const capability = await tab.capabilities?.get?.("cdp");
+        if (capability?.send === undefined)
+            return false;
+        // Move directly between axis rows. Moving outside the Radix root menu first
+        // schedules its dismissal; the submenu can briefly appear and then vanish
+        // before the bounded option inspection runs.
+        await capability.send("Input.dispatchMouseEvent", {
+            type: "mouseMoved",
+            x: Math.round(point.x),
+            y: Math.round(point.y),
+            button: "none",
+            buttons: 0,
+            pointerType: "mouse"
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function filterWorkAxisOptions(items, axis) {
+    return items.filter(item => {
+        if (isConfigurationAxisRow(item.label))
+            return false;
+        // Keep every choice axis-specific. This excludes parent actions such as
+        // "Reset to default" and prevents a still-open model submenu from being
+        // mistaken for effort or speed choices if Escape is unavailable.
+        return workAxisOptionLabelMatches(axis, item.label);
+    });
+}
+function workAxisOptionLabelMatches(axis, label) {
+    if (axis === "model") {
+        return /\b(?:gpt[\s-]?\d|sol|luna|terra)\b/i.test(label);
+    }
+    const candidates = axis === "effort"
+        ? [
+            ...localeLabels.configurationOptions.light,
+            ...localeLabels.configurationOptions.medium,
+            ...localeLabels.configurationOptions.high,
+            ...localeLabels.configurationOptions.extraHigh,
+            ...localeLabels.configurationOptions.max,
+            ...localeLabels.configurationOptions.ultra,
+        ]
+        : axis === "speed"
+            ? [
+                ...localeLabels.configurationOptions.standard,
+                ...localeLabels.configurationOptions.fast,
+            ]
+            : [];
+    return candidates.some(candidate => visibleLabelMatches(label, candidate));
+}
+async function selectChatAxis(env, axis, requested, timeoutMs) {
+    const legacyArgs = axis === "modelVersion"
+        ? { modelVersion: requested }
+        : axis === "intelligence"
+            ? { intelligence: requested }
+            : axis === "effort"
+                ? { effort: requested }
+                : axis === "model"
+                    ? { model: requested }
+                    : undefined;
+    if (legacyArgs === undefined) {
+        return undefined;
+    }
+    const result = await setMode(env, {
+        ...legacyArgs,
+        ...(timeoutMs === undefined ? {} : { timeoutMs })
+    });
+    return result.ok ? result.data?.selected.at(-1) : undefined;
+}
+async function openConfigurationRoot(page, experience) {
+    const existing = await readConfigurationPanel(page);
+    if (existing.axisRows.length > 0) {
+        return true;
+    }
+    const existingItems = await enumerateVisibleMenuItems(page).catch(() => []);
+    if (configurationMenuLooksRecognized(existingItems, experience, existing.openerLabel)) {
+        return true;
+    }
+    if (existing.openerLabel !== undefined
+        && await clickIfUnique(page.getByRole?.("button", { name: existing.openerLabel, exact: true }))) {
+        return true;
+    }
+    if (typeof page.evaluate === "function") {
+        const clicked = await page.evaluate((surface) => {
+            const normalize = (value) => value.replace(/\s+/g, " ").trim();
+            const visible = (element) => {
+                const html = element;
+                const rect = html.getBoundingClientRect?.();
+                if (rect !== undefined && (rect.width <= 0 || rect.height <= 0))
+                    return false;
+                let current = element;
+                while (current !== null) {
+                    if (current.hasAttribute?.("inert") || current.getAttribute?.("aria-hidden") === "true") {
+                        return false;
+                    }
+                    const style = typeof window !== "undefined"
+                        ? window.getComputedStyle?.(current)
+                        : undefined;
+                    if (style?.display === "none" || style?.visibility === "hidden" || style?.opacity === "0") {
+                        return false;
+                    }
+                    current = current.parentElement ?? null;
+                }
+                return true;
+            };
+            const composerRoots = Array.from(document.querySelectorAll("main form, main [data-testid*='composer' i], main [class*='composer' i]"));
+            const main = document.querySelector("main");
+            const roots = Array.from(new Set([
+                ...composerRoots,
+                ...(main === null ? [] : [main])
+            ]));
+            const controls = Array.from(new Set(roots.flatMap(root => Array.from(root.querySelectorAll("button, [role='button']")))))
+                .filter(visible);
+            const matches = controls.filter(control => {
+                const html = control;
+                const label = normalize(control.getAttribute("aria-label") ?? html.innerText ?? control.textContent ?? "");
+                const testId = control.getAttribute("data-testid") ?? "";
+                if (/send|voice|microphone|attach|upload|add files|plus/i.test(`${label} ${testId}`))
+                    return false;
+                if (/model-switcher|model-selector|mode-selector/i.test(testId))
+                    return true;
+                return surface === "work"
+                    ? /\b(?:gpt|sol|luna|terra|light|medium|high|max|ultra|standard|fast)\b/i.test(label)
+                    : /\b(?:instant|medium|high|extra high|pro|thinking|extended|gpt)\b/i.test(label);
+            });
+            if (matches.length !== 1)
+                return false;
+            matches[0].click();
+            return true;
+        }, experience).catch(() => false);
+        if (clicked)
+            return true;
+    }
+    const labels = experience === "work"
+        ? [
+            ...localeLabels.configurationOptions.light,
+            ...localeLabels.configurationOptions.medium,
+            ...localeLabels.configurationOptions.high,
+            ...localeLabels.configurationOptions.standard,
+        ]
+        : [
+            ...localeLabels.configurationOptions.instant,
+            ...localeLabels.configurationOptions.medium,
+            ...localeLabels.configurationOptions.high,
+            ...localeLabels.configurationOptions.extraHigh,
+            ...localeLabels.configurationOptions.pro,
+            ...localeLabels.modeOptions.thinking,
+        ];
+    for (const label of labels) {
+        if (await clickIfUnique(page.getByRole?.("button", { name: label, exact: true }))) {
+            return true;
+        }
+    }
+    return false;
+}
+function configurationMenuLooksRecognized(items, experience, openerLabel) {
+    if (items.some(item => /(?:model|mode|effort|speed)-(?:switcher|selector)|model-switcher/i.test(item.testId ?? ""))) {
+        return true;
+    }
+    if (experience === "work" && items.some(item => localeLabels.configurationAxes.advanced.some(label => visibleLabelMatches(item.label, label)))) {
+        return true;
+    }
+    if (openerLabel === undefined || items.length === 0) {
+        return false;
+    }
+    const semanticLabels = experience === "work"
+        ? [
+            ...localeLabels.configurationOptions.light,
+            ...localeLabels.configurationOptions.medium,
+            ...localeLabels.configurationOptions.high,
+            ...localeLabels.configurationOptions.max,
+            ...localeLabels.configurationOptions.ultra,
+            ...localeLabels.configurationOptions.standard,
+            ...localeLabels.configurationOptions.fast,
+        ]
+        : [
+            ...localeLabels.configurationOptions.instant,
+            ...localeLabels.configurationOptions.medium,
+            ...localeLabels.configurationOptions.high,
+            ...localeLabels.configurationOptions.extraHigh,
+            ...localeLabels.configurationOptions.pro,
+            ...localeLabels.modeOptions.thinking,
+            ...localeLabels.modeOptions.extended,
+        ];
+    const matched = new Set(items
+        .filter(item => semanticLabels.some(label => visibleLabelMatches(item.label, label)))
+        .map(item => normalizeConfigurationId(item.label)));
+    return matched.size >= 2;
+}
+async function ensureWorkAdvancedPanel(page) {
+    const panel = await readConfigurationPanel(page);
+    if (panel.axisRows.length > 0)
+        return true;
+    if (!await openConfigurationRoot(page, "work"))
+        return false;
+    const reopenedPanel = await readConfigurationPanel(page);
+    if (reopenedPanel.axisRows.length > 0)
+        return true;
+    const items = await enumerateVisibleMenuItems(page);
+    const advanced = items.filter(item => localeLabels.configurationAxes.advanced.some(label => visibleLabelMatches(item.label, label)));
+    if (advanced.length !== 1 || !await clickVisibleMenuItem(page, advanced[0])) {
+        return false;
+    }
+    await page.waitForTimeout?.(200);
+    return (await readConfigurationPanel(page)).axisRows.length > 0;
+}
+async function readConfigurationPanel(page) {
+    if (typeof page.evaluate !== "function") {
+        return { axisRows: [], advancedVisible: false };
+    }
+    return page.evaluate((axisLabels) => {
+        const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const normalizedAxes = Object.fromEntries(Object.entries(axisLabels).map(([axis, labels]) => [
+            axis,
+            labels.map(label => normalize(label).toLocaleLowerCase())
+        ]));
+        const visible = (element) => {
+            const html = element;
+            const rect = html.getBoundingClientRect?.();
+            if (rect !== undefined && (rect.width <= 0 || rect.height <= 0))
+                return false;
+            let current = element;
+            while (current !== null) {
+                if (current.hasAttribute?.("inert") || current.getAttribute?.("aria-hidden") === "true") {
+                    return false;
+                }
+                const style = typeof window !== "undefined"
+                    ? window.getComputedStyle?.(current)
+                    : undefined;
+                if (style?.display === "none" || style?.visibility === "hidden" || style?.opacity === "0") {
+                    return false;
+                }
+                current = current.parentElement ?? null;
+            }
+            return true;
+        };
+        const overlays = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper], [data-radix-menu-content]")).filter(visible);
+        const roots = overlays.length > 0 ? overlays : Array.from(document.querySelectorAll("main")).filter(visible);
+        const rows = roots.flatMap(root => Array.from(root.querySelectorAll("button, [role='button'], [role='menuitem'], [role='menuitemradio'], [role='option']"))).filter(visible);
+        const axisRows = [];
+        for (const row of rows) {
+            const html = row;
+            const label = normalize(row.getAttribute("aria-label") ?? html.innerText ?? row.textContent ?? "");
+            const normalized = label.toLocaleLowerCase();
+            for (const axis of ["model", "intelligence", "effort", "speed"]) {
+                const candidates = normalizedAxes[axis] ?? [];
+                const prefix = candidates.find(candidate => normalized === candidate || normalized.startsWith(`${candidate} `));
+                if (prefix === undefined)
+                    continue;
+                const value = normalize(label.slice(prefix.length));
+                const item = { axis, label };
+                if (value.length > 0)
+                    item.value = value;
+                axisRows.push(item);
+                break;
+            }
+        }
+        const composerRoots = Array.from(document.querySelectorAll("main form, main [data-testid*='composer' i], main [class*='composer' i]"));
+        const main = document.querySelector("main");
+        const openerRoots = Array.from(new Set([
+            ...composerRoots,
+            ...(main === null ? [] : [main])
+        ]));
+        const openerCandidates = Array.from(new Set(openerRoots.flatMap(root => Array.from(root.querySelectorAll("button, [role='button']")))))
+            .filter(visible)
+            .map(control => {
+            const html = control;
+            return {
+                label: normalize(control.getAttribute("aria-label") ?? html.innerText ?? control.textContent ?? ""),
+                testId: control.getAttribute("data-testid") ?? ""
+            };
+        })
+            .filter(item => !/send|voice|microphone|attach|upload|add files|plus/i.test(`${item.label} ${item.testId}`))
+            .filter(item => /model-switcher|model-selector|mode-selector/i.test(item.testId)
+            || /\b(?:gpt|sol|luna|terra|instant|medium|high|extra high|pro|thinking|extended|light|standard|fast)\b/i.test(item.label));
+        const result = {
+            axisRows,
+            advancedVisible: axisRows.length > 0
+        };
+        if (openerCandidates.length === 1 && openerCandidates[0]?.label.length) {
+            result.openerLabel = openerCandidates[0].label;
+        }
+        return result;
+    }, localeLabels.configurationAxes).catch(() => ({ axisRows: [], advancedVisible: false }));
+}
+async function findWorkAxisRow(page, axis) {
+    const labels = axis === "modelVersion" ? [] : localeLabels.configurationAxes[axis] ?? [];
+    for (const label of labels) {
+        const pattern = new RegExp(`^${escapeRegExp(label)}(?:\\s|$)`, "i");
+        for (const role of ["button", "menuitem"]) {
+            const locator = page.getByRole?.(role, { name: pattern });
+            if (locator?.count !== undefined && await locator.count().catch(() => 0) === 1) {
+                return locator;
+            }
+        }
+    }
+    return undefined;
+}
+async function clickVisibleMenuItem(page, item) {
+    if (item.testId !== undefined && await clickIfUnique(page.locator?.(`[data-testid="${escapeAttributeValue(item.testId)}"]`))) {
+        return true;
+    }
+    for (const role of ["menuitemradio", "menuitem", "option"]) {
+        if (await clickIfUnique(page.getByRole?.(role, { name: item.label, exact: true }))) {
+            return true;
+        }
+    }
+    return clickIfUnique(page.getByText?.(item.label, { exact: true }));
+}
+function findConfigurationOption(items, requested) {
+    const normalizedRequested = normalizeConfigurationId(requested);
+    const exact = items.filter(item => normalizeConfigurationId(item.label) === normalizedRequested);
+    if (exact.length === 1)
+        return exact[0];
+    const semanticLabels = configurationSemanticLabels(requested);
+    for (const wanted of semanticLabels) {
+        const matches = items.filter(item => normalizeForLabelMatch(item.label) === normalizeForLabelMatch(wanted)
+            || visibleLabelMatches(item.label, wanted));
+        if (matches.length === 1)
+            return matches[0];
+    }
+    return undefined;
+}
+function configurationSemanticLabels(requested) {
+    const normalized = normalizeConfigurationId(requested);
+    for (const labels of Object.values(localeLabels.configurationOptions)) {
+        if (labels.some(label => normalizeConfigurationId(label) === normalized)) {
+            return labels;
+        }
+    }
+    for (const labels of Object.values(localeLabels.modeOptions)) {
+        if (labels.some(label => normalizeConfigurationId(label) === normalized)) {
+            return labels;
+        }
+    }
+    return [requested];
+}
+export function configurationMatchesSelection(inspection, desired) {
+    return selectionEntries(desired).every(([axis, requested]) => {
+        const active = activeConfigurationValue(inspection, axis);
+        return active !== undefined && configurationValueMatches(active, requested);
+    });
+}
+function activeConfigurationValue(inspection, axis) {
+    const direct = inspection.active[axis];
+    if (direct !== undefined || inspection.experience !== "chat") {
+        return direct;
+    }
+    if (axis === "model" || axis === "intelligence") {
+        return inspection.active.intelligence ?? inspection.active.effort;
+    }
+    if (axis === "effort") {
+        return inspection.active.effort ?? inspection.active.intelligence;
+    }
+    return undefined;
+}
+function configurationValueMatches(actual, requested) {
+    const normalizedActual = normalizeConfigurationId(actual);
+    const normalizedRequested = normalizeConfigurationId(requested);
+    if (normalizedActual === normalizedRequested)
+        return true;
+    return configurationSemanticLabels(requested)
+        .some(label => normalizeConfigurationId(label) === normalizedActual);
+}
+function selectionEntries(selection) {
+    const entries = [];
+    for (const axis of CONFIGURATION_AXIS_ORDER) {
+        const value = selection[axis];
+        if (typeof value === "string" && value.trim().length > 0) {
+            entries.push([axis, value.trim()]);
+        }
+    }
+    return entries;
+}
+function normalizeDesiredSelection(selection) {
+    const normalized = {};
+    for (const axis of ["model", "intelligence", "effort", "speed"]) {
+        const value = selection[axis]?.trim();
+        if (value !== undefined && value.length > 0)
+            normalized[axis] = value;
+    }
+    const modelVersion = (selection.modelVersion ?? selection.version)?.trim();
+    if (modelVersion !== undefined && modelVersion.length > 0) {
+        normalized.modelVersion = modelVersion;
+    }
+    return normalized;
+}
+function menuItemToOption(item) {
+    const option = {
+        id: normalizeConfigurationId(item.label),
+        label: item.label,
+        selected: item.checked === true
+    };
+    if (item.hasPopup !== undefined)
+        option.hasSubmenu = item.hasPopup;
+    return option;
+}
+function dedupeOptions(options) {
+    const seen = new Set();
+    return options.filter(option => {
+        const key = `${option.id}\u0000${option.label}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function chatMenuLooksSimplified(items) {
+    const normalized = items.map(item => normalizeConfigurationId(item.label));
+    const simplified = ["instant", "medium", "high", "extra high", "pro"];
+    return simplified.filter(label => normalized.includes(label)).length >= 3;
+}
+function isConfigurationAxisRow(label) {
+    const normalized = normalizeForLabelMatch(label);
+    return Object.values(localeLabels.configurationAxes)
+        .flat()
+        .some(axis => {
+        const prefix = normalizeForLabelMatch(axis);
+        return normalized === prefix || normalized.startsWith(`${prefix} `);
+    });
+}
+function normalizeConfigurationId(value) {
+    return normalizeForLabelMatch(value)
+        .replace(/^gpt[\s-]*/i, "gpt ")
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+async function closeConfigurationMenus(page) {
+    if (!await pressConfigurationEscape(page))
+        return;
+    await page.waitForTimeout?.(50);
+    await pressConfigurationEscape(page);
+}
+async function closeConfigurationSubmenu(page) {
+    if (!await pressConfigurationEscape(page))
+        return;
+    // Radix retains a short pointer-grace timer after a submenu closes. If the
+    // next axis is hovered too quickly, that stale timer can dismiss the newly
+    // opened submenu. Let the prior close settle before moving to another row.
+    await page.waitForTimeout?.(200);
+}
+async function pressConfigurationEscape(page) {
+    if (page.keyboard?.press !== undefined) {
+        await page.keyboard.press("Escape");
+        return true;
+    }
+    if (page.cua?.keypress !== undefined) {
+        try {
+            await page.cua.keypress({ keys: ["ESC"] });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+async function clickIfUnique(locator) {
+    if (locator?.count === undefined || locator.click === undefined)
+        return false;
+    const count = await locator.count().catch(() => 0);
+    if (count === 1) {
+        await locator.click();
+        return true;
+    }
+    if (count <= 1 || locator.nth === undefined)
+        return false;
+    const visible = [];
+    for (let index = 0; index < count; index += 1) {
+        const candidate = locator.nth(index);
+        if (candidate.isVisible !== undefined && await candidate.isVisible().catch(() => false)) {
+            visible.push(candidate);
+        }
+    }
+    if (visible.length !== 1 || visible[0]?.click === undefined)
+        return false;
+    await visible[0].click();
+    return true;
+}
+async function configurationFailure(page, before, desired, selected, message, code, candidates = []) {
+    const data = {
+        requested: desired,
+        selected,
+        before,
+        after: before,
+        verified: false
+    };
+    return {
+        ok: false,
+        status: "unsupported",
+        data,
+        warnings: [],
+        blocker: {
+            kind: "selector_drift",
+            code,
+            fieldPath: "desired",
+            message,
+            candidates: candidates.map(label => ({ label })),
+            resumable: true
+        },
+        context: await contextFromPage(page, {
+            experience: before.experience,
+            selectorProfile: before.selectorProfile
+        })
+    };
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeAttributeValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function forwardFailure(result) {
+    const forwarded = {
+        ok: false,
+        status: result.status,
+        warnings: result.warnings,
+        context: result.context
+    };
+    if (result.output_text !== undefined)
+        forwarded.output_text = result.output_text;
+    if (result.reportPath !== undefined)
+        forwarded.reportPath = result.reportPath;
+    if (result.error !== undefined)
+        forwarded.error = result.error;
+    if (result.blocker !== undefined)
+        forwarded.blocker = result.blocker;
+    if (result.steps !== undefined)
+        forwarded.steps = result.steps;
+    return forwarded;
+}