autokap 1.0.2 → 1.0.3

package/dist/session-profile.js

@@ -1,1471 +0,0 @@
-const EMAIL_RE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i;
-const LOGIN_URL_RE = /\/(login|signin|sign-in|auth|session|connexion|connect(?:ion)?)\b/i;
-const LOGIN_BUTTON_RE = /\b(sign[\s-]?in|log[\s-]?in|continue with email|connexion|se connecter|login)\b/i;
-const LOGOUT_BUTTON_RE = /\b(sign[\s-]?out|log[\s-]?out|logout|d[eé]connexion|se d[eé]connecter)\b/i;
-const ACCOUNT_MENU_RE = /\b(account|profile|profil|compte|workspace|organization|organisation|team|billing|settings)\b/i;
-const PERSON_NAME_RE = /^[A-ZÀ-Ý][A-Za-zÀ-ÿ'’-]{1,20}(?:\s+[A-ZÀ-Ý][A-Za-zÀ-ÿ'’-]{1,20}){1,2}$/;
-const CORPORATE_SUFFIX_RE = /\b(inc|llc|ltd|corp|gmbh|sas|sarl|company|studio|agency)\b/i;
-const LANG_CONTROL_RE = /\b(lang|locale|language|idioma|sprache|langue|lingua)\b/i;
-const THEME_CONTROL_RE = /\b(theme|appearance|mode|dark|light|clair|sombre|oscuro|claro)\b/i;
-const LANGUAGE_ALIASES = {
-    ar: ['ar', 'arabic', 'arab', 'العربية'],
-    cs: ['cs', 'czech', 'cesky', 'čeština'],
-    da: ['da', 'danish', 'dansk'],
-    de: ['de', 'german', 'deutsch'],
-    en: ['en', 'english'],
-    es: ['es', 'spanish', 'espanol', 'español'],
-    fi: ['fi', 'finnish', 'suomi'],
-    fr: ['fr', 'french', 'francais', 'français'],
-    hu: ['hu', 'hungarian', 'magyar'],
-    it: ['it', 'italian', 'italiano'],
-    ja: ['ja', 'japanese', 'japonais', '日本語'],
-    ko: ['ko', 'korean', '한국어'],
-    nl: ['nl', 'dutch', 'nederlands'],
-    no: ['no', 'nb', 'norwegian', 'norsk'],
-    pl: ['pl', 'polish', 'polski'],
-    pt: ['pt', 'portuguese', 'portugues', 'português'],
-    ru: ['ru', 'russian', 'русский'],
-    sv: ['sv', 'swedish', 'svenska'],
-    tr: ['tr', 'turkish', 'turkce', 'türkçe'],
-    zh: ['zh', 'chinese', '中文'],
-};
-function makeDiagnostic(outcome, confidence, reasons) {
-    return {
-        outcome,
-        confidence,
-        reasons: reasons.filter((reason) => !!reason),
-    };
-}
-function confidenceFromScore(score, options) {
-    if (options.highSignal || score >= options.highAt)
-        return 'high';
-    if (score >= options.mediumAt)
-        return 'medium';
-    return 'low';
-}
-const FIXED_UI_LANGUAGE_PATTERNS = {
-    en: [
-        /\b(settings|dashboard|search|save|cancel|continue|projects?|captures?|gallery|account|profile|billing|language|theme|edit|new)\b/i,
-        /\b(sign in|sign out|screenshots?|templates?|navigation|overview)\b/i,
-    ],
-    fr: [
-        /\b(param[eè]tres|tableau de bord|rechercher|enregistrer|annuler|continuer|projets?|captures?|galerie|compte|profil|facturation|langue|th[eè]me|modifier|nouveau)\b/i,
-        /\b(se connecter|d[eé]connexion|captures d[' ]ecran|mod[eè]les|navigation|aper[uç]u)\b/i,
-    ],
-    de: [
-        /\b(einstellungen|dashboard|suche|speichern|abbrechen|weiter|projekte?|galerie|konto|profil|abrechnung|sprache|thema|bearbeiten|neu)\b/i,
-        /\b(anmelden|abmelden|vorlage|navigation|ubersicht)\b/i,
-    ],
-    es: [
-        /\b(configuraci[oó]n|panel|buscar|guardar|cancelar|continuar|proyectos?|capturas?|galer[ií]a|cuenta|perfil|facturaci[oó]n|idioma|tema|editar|nuevo)\b/i,
-        /\b(iniciar sesi[oó]n|cerrar sesi[oó]n|plantillas|navegaci[oó]n|resumen)\b/i,
-    ],
-    it: [
-        /\b(impostazioni|dashboard|cerca|salva|annulla|continua|progetti?|schermate|galleria|account|profilo|fatturazione|lingua|tema|modifica|nuovo)\b/i,
-        /\b(accedi|disconnetti|modelli|navigazione|panoramica)\b/i,
-    ],
-    pt: [
-        /\b(configura[cç][aã]o|painel|pesquisar|salvar|cancelar|continuar|projetos?|capturas?|galeria|conta|perfil|cobran[cç]a|idioma|tema|editar|novo)\b/i,
-        /\b(entrar|sair|modelos|navega[cç][aã]o|vis[aã]o geral)\b/i,
-    ],
-};
-function normalizeLangCode(value) {
-    if (!value)
-        return null;
-    return value.trim().toLowerCase().replace('_', '-').split('-')[0] || null;
-}
-function normalizeSearchText(value) {
-    return (value ?? '')
-        .normalize('NFD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase();
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function truncate(value, max = 180) {
-    return value.length > max ? `${value.slice(0, max - 1)}...` : value;
-}
-function looksLikeAccountText(value) {
-    const normalized = (value ?? '').replace(/\s+/g, ' ').trim();
-    if (!normalized)
-        return false;
-    if (LOGIN_BUTTON_RE.test(normalized) || LOGOUT_BUTTON_RE.test(normalized))
-        return false;
-    if (EMAIL_RE.test(normalized))
-        return true;
-    return PERSON_NAME_RE.test(normalized) && !CORPORATE_SUFFIX_RE.test(normalized);
-}
-function extractAccountLabel(signals) {
-    const hintedAccount = signals.authHints?.accountLikeText.find((value) => looksLikeAccountText(value));
-    if (hintedAccount)
-        return hintedAccount;
-    const sources = [
-        signals.visibleText,
-        signals.title,
-        ...signals.navLabels,
-        ...signals.breadcrumbLabels,
-    ];
-    for (const source of sources) {
-        const match = source.match(EMAIL_RE);
-        if (match)
-            return match[0];
-    }
-    const nameCandidate = sources.find((source) => looksLikeAccountText(source));
-    if (nameCandidate)
-        return nameCandidate.replace(/\s+/g, ' ').trim();
-    return null;
-}
-function textContainsLanguageAlias(value, lang) {
-    const haystack = normalizeSearchText(value);
-    if (!haystack)
-        return false;
-    const aliases = LANGUAGE_ALIASES[lang] ?? [lang];
-    return aliases.some((alias) => {
-        const normalizedAlias = normalizeSearchText(alias);
-        if (!normalizedAlias)
-            return false;
-        if (/^[a-z]{2,3}$/.test(normalizedAlias)) {
-            return new RegExp(`(^|[^a-z])${escapeRegExp(normalizedAlias)}([^a-z]|$)`, 'i').test(haystack);
-        }
-        return haystack.includes(normalizedAlias);
-    });
-}
-function textContainsThemeAlias(value, theme) {
-    const haystack = normalizeSearchText(value);
-    if (!haystack)
-        return false;
-    const aliases = theme === 'dark'
-        ? ['dark', 'sombre', 'oscuro', 'dunkel']
-        : ['light', 'clair', 'claro', 'hell'];
-    return aliases.some((alias) => haystack.includes(alias));
-}
-function parseMaybeUrl(rawUrl) {
-    if (!rawUrl)
-        return null;
-    try {
-        return new URL(rawUrl);
-    }
-    catch {
-        return null;
-    }
-}
-function urlSuggestsLanguage(rawUrl, lang) {
-    const url = parseMaybeUrl(rawUrl);
-    if (!url)
-        return false;
-    if (normalizeLangCode(url.hostname.split('.')[0]) === lang) {
-        return true;
-    }
-    for (const segment of url.pathname.split('/')) {
-        if (normalizeLangCode(segment) === lang || textContainsLanguageAlias(segment, lang)) {
-            return true;
-        }
-    }
-    for (const key of ['lang', 'hl', 'locale']) {
-        const value = url.searchParams.get(key);
-        if (normalizeLangCode(value) === lang || textContainsLanguageAlias(value, lang)) {
-            return true;
-        }
-    }
-    return false;
-}
-function parseHreflangCode(entry) {
-    const separatorIndex = entry.indexOf(':');
-    if (separatorIndex > 0) {
-        return normalizeLangCode(entry.slice(0, separatorIndex));
-    }
-    return normalizeLangCode(entry);
-}
-function normalizePathSegments(pathname) {
-    return pathname
-        .split('/')
-        .map((segment) => segment.trim().toLowerCase())
-        .filter(Boolean);
-}
-function stripLeadingLocaleSegment(segments) {
-    if (segments.length === 0)
-        return segments;
-    return normalizeLangCode(segments[0]) ? segments.slice(1) : segments;
-}
-function pathStartsWithSegments(current, expected) {
-    if (expected.length === 0)
-        return true;
-    if (current.length < expected.length)
-        return false;
-    return expected.every((segment, index) => current[index] === segment);
-}
-function pathsRoughlyMatch(currentPathname, expectedPathname) {
-    const currentSegments = normalizePathSegments(currentPathname);
-    const expectedSegments = normalizePathSegments(expectedPathname);
-    if (pathStartsWithSegments(currentSegments, expectedSegments)) {
-        return true;
-    }
-    return pathStartsWithSegments(stripLeadingLocaleSegment(currentSegments), stripLeadingLocaleSegment(expectedSegments));
-}
-function extractLangCandidates(signals, currentUrl) {
-    const candidates = new Set();
-    const push = (value) => {
-        const normalized = normalizeLangCode(value);
-        if (normalized)
-            candidates.add(normalized);
-    };
-    push(signals.htmlLang);
-    signals.hreflangs.forEach((entry) => push(parseHreflangCode(entry) ?? entry));
-    signals.localeHints.forEach((hint) => {
-        const normalizedHint = normalizeLangCode(hint);
-        if (normalizedHint) {
-            candidates.add(normalizedHint);
-            return;
-        }
-        const lowerHint = hint.toLowerCase();
-        for (const [code, aliases] of Object.entries(LANGUAGE_ALIASES)) {
-            if (aliases.some((alias) => lowerHint.includes(alias))) {
-                candidates.add(code);
-                break;
-            }
-        }
-    });
-    try {
-        const url = new URL(currentUrl);
-        push(url.hostname.split('.')[0]);
-        for (const segment of url.pathname.split('/')) {
-            push(segment);
-        }
-    }
-    catch {
-        // Ignore invalid URLs.
-    }
-    return Array.from(candidates);
-}
-function collectFixedChromeText(signals) {
-    const localeControlText = signals.variantControls
-        .filter((control) => control.kind === 'locale')
-        .flatMap((control) => [
-        control.label,
-        control.value ?? '',
-        ...(control.options ?? [])
-            .filter((option) => option.selected)
-            .flatMap((option) => [option.label, option.value ?? '']),
-    ]);
-    return [
-        ...signals.navLabels,
-        ...signals.breadcrumbLabels,
-        ...signals.headings,
-        ...localeControlText,
-    ]
-        .filter(Boolean)
-        .join(' ');
-}
-function scoreFixedChromeText(signals, lang) {
-    const patterns = FIXED_UI_LANGUAGE_PATTERNS[lang];
-    if (!patterns || patterns.length === 0) {
-        return { lang, score: 0, reasons: [] };
-    }
-    const text = collectFixedChromeText(signals);
-    if (!text.trim()) {
-        return { lang, score: 0, reasons: [] };
-    }
-    const hits = patterns.filter((pattern) => pattern.test(text)).length;
-    if (hits === 0) {
-        return { lang, score: 0, reasons: [] };
-    }
-    const normalizedScore = Math.min(1, hits / patterns.length);
-    return {
-        lang,
-        score: normalizedScore * 3.6,
-        reasons: [`fixed_ui_text=${lang}(${normalizedScore.toFixed(2)})`],
-    };
-}
-function scoreLocaleControls(signals, lang) {
-    const localeControls = signals.variantControls.filter((control) => control.kind === 'locale');
-    if (localeControls.length === 0) {
-        return { lang, score: 0, reasons: [] };
-    }
-    let score = 0;
-    const reasons = [];
-    for (const control of localeControls) {
-        const selectedTexts = [
-            control.value ?? '',
-            ...(control.options ?? [])
-                .filter((option) => option.selected)
-                .flatMap((option) => [option.label, option.value ?? '']),
-        ].filter(Boolean);
-        if (selectedTexts.some((value) => textContainsLanguageAlias(value, lang))) {
-            score = Math.max(score, 2.0);
-            reasons.splice(0, reasons.length, `locale_control_active=${lang}`);
-            continue;
-        }
-        if (textContainsLanguageAlias(control.label, lang)) {
-            score = Math.max(score, 1.0);
-            if (reasons.length === 0) {
-                reasons.push(`locale_control_label=${lang}`);
-            }
-        }
-    }
-    return { lang, score, reasons };
-}
-function scoreLanguageCandidate(params) {
-    const { lang, currentUrl, signals } = params;
-    let score = 0;
-    const reasons = [];
-    if (normalizeLangCode(signals.htmlLang) === lang) {
-        score += 2.8;
-        reasons.push(`html_lang=${signals.htmlLang}`);
-    }
-    if (urlSuggestsLanguage(currentUrl, lang)) {
-        score += 2.4;
-        reasons.push(`url=${lang}`);
-    }
-    else if (urlSuggestsLanguage(signals.canonicalUrl, lang)) {
-        score += 1.2;
-        reasons.push(`canonical_url=${lang}`);
-    }
-    if (signals.hreflangs.some((entry) => parseHreflangCode(entry) === lang)) {
-        score += 1.6;
-        reasons.push(`hreflang=${lang}`);
-    }
-    if (signals.localeHints.some((hint) => normalizeLangCode(hint) === lang || textContainsLanguageAlias(hint, lang))) {
-        score += 1.3;
-        reasons.push(`locale_hint=${lang}`);
-    }
-    const localeControlScore = scoreLocaleControls(signals, lang);
-    score += localeControlScore.score;
-    reasons.push(...localeControlScore.reasons);
-    const textScore = scoreFixedChromeText(signals, lang);
-    score += textScore.score;
-    reasons.push(...textScore.reasons);
-    return { lang, score, reasons };
-}
-export function evaluateRequestedLanguageState(params) {
-    const requested = normalizeLangCode(params.requestedLang);
-    const candidateLangs = new Set();
-    if (requested) {
-        candidateLangs.add(requested);
-    }
-    for (const lang of Object.keys(FIXED_UI_LANGUAGE_PATTERNS)) {
-        candidateLangs.add(lang);
-    }
-    for (const lang of extractLangCandidates(params.signals, params.currentUrl)) {
-        candidateLangs.add(lang);
-    }
-    for (const lang of Object.keys(LANGUAGE_ALIASES)) {
-        if (params.signals.localeHints.some((hint) => textContainsLanguageAlias(hint, lang) || normalizeLangCode(hint) === lang)) {
-            candidateLangs.add(lang);
-        }
-    }
-    const ranked = Array.from(candidateLangs)
-        .map((lang) => scoreLanguageCandidate({
-        lang,
-        currentUrl: params.currentUrl,
-        signals: params.signals,
-    }))
-        .sort((left, right) => right.score - left.score);
-    const best = ranked[0] ?? null;
-    const runnerUp = ranked[1] ?? null;
-    const bestScore = best?.score ?? 0;
-    const runnerUpScore = runnerUp?.score ?? 0;
-    const gap = bestScore - runnerUpScore;
-    const bestReasons = best?.reasons ?? [];
-    const explicitLocaleControl = bestReasons.some((reason) => reason.startsWith('locale_control_active='));
-    const fixedChromeEvidence = bestReasons.some((reason) => reason.startsWith('fixed_ui_text='));
-    const routeLanguageEvidence = bestReasons.some((reason) => reason.startsWith('url=')
-        || reason.startsWith('canonical_url=')
-        || reason.startsWith('hreflang='));
-    const strongSurfaceEvidence = explicitLocaleControl
-        || fixedChromeEvidence
-        || routeLanguageEvidence;
-    const confident = bestScore >= 3.0
-        && gap >= 0.85
-        && (strongSurfaceEvidence || bestScore >= 5.6);
-    const detected = confident ? best?.lang ?? null : null;
-    const requestedScore = requested
-        ? ranked.find((entry) => entry.lang === requested)?.score ?? 0
-        : 0;
-    const reasons = [
-        requested ? `requested=${requested}(${requestedScore.toFixed(2)})` : null,
-        best ? `best=${best.lang}(${best.score.toFixed(2)})` : null,
-        runnerUp && runnerUp.score > 0 ? `runner_up=${runnerUp.lang}(${runnerUp.score.toFixed(2)})` : null,
-        ...(best?.reasons ?? []).slice(0, 4),
-        !confident && bestScore > 0 ? `state=ambiguous(gap=${gap.toFixed(2)})` : null,
-        bestScore === 0 ? 'state=ambiguous(no_language_signal)' : null,
-    ].filter((reason) => !!reason);
-    const confidence = detected
-        ? confidenceFromScore(bestScore, {
-            mediumAt: 3.2,
-            highAt: 5.6,
-            highSignal: explicitLocaleControl || (fixedChromeEvidence && gap >= 1.2),
-        })
-        : confidenceFromScore(bestScore, { mediumAt: 3.0, highAt: 5.2 });
-    if (!requested) {
-        return {
-            requested: null,
-            detected,
-            active: detected !== null,
-            ambiguous: detected === null,
-            confidence,
-            reasons,
-        };
-    }
-    if (detected === requested) {
-        return {
-            requested,
-            detected,
-            active: true,
-            ambiguous: false,
-            confidence,
-            reasons,
-        };
-    }
-    return {
-        requested,
-        detected,
-        active: false,
-        ambiguous: detected === null || confidence !== 'high',
-        confidence,
-        reasons,
-    };
-}
-function detectThemeFromControls(signals) {
-    for (const control of signals.variantControls) {
-        if (control.kind !== 'theme')
-            continue;
-        const selectedValues = [
-            control.value ?? '',
-            ...(control.options ?? [])
-                .filter((option) => option.selected)
-                .flatMap((option) => [option.label, option.value ?? '']),
-        ].filter(Boolean);
-        if (selectedValues.some((value) => textContainsThemeAlias(value, 'dark'))) {
-            return { theme: 'dark', confidence: 'high', reasons: ['theme_control_active=dark'] };
-        }
-        if (selectedValues.some((value) => textContainsThemeAlias(value, 'light'))) {
-            return { theme: 'light', confidence: 'high', reasons: ['theme_control_active=light'] };
-        }
-    }
-    return { theme: null, confidence: 'low', reasons: [] };
-}
-function detectThemeFromStorage(signals) {
-    for (const hint of signals.storageHints) {
-        if (hint.kind !== 'theme')
-            continue;
-        if (textContainsThemeAlias(hint.valueSample, 'dark')) {
-            return { theme: 'dark', confidence: 'high', reasons: [`theme_storage=${hint.key}:dark`] };
-        }
-        if (textContainsThemeAlias(hint.valueSample, 'light')) {
-            return { theme: 'light', confidence: 'high', reasons: [`theme_storage=${hint.key}:light`] };
-        }
-    }
-    return { theme: null, confidence: 'low', reasons: [] };
-}
-function detectThemeFromRoot(signals) {
-    const rootHints = (signals.themeRootHints ?? []).join(' ');
-    const hasDark = textContainsThemeAlias(rootHints, 'dark');
-    const hasLight = textContainsThemeAlias(rootHints, 'light');
-    if (hasDark === hasLight) {
-        return { theme: null, confidence: 'low', reasons: [] };
-    }
-    return {
-        theme: hasDark ? 'dark' : 'light',
-        confidence: 'medium',
-        reasons: [`theme_root_hint=${hasDark ? 'dark' : 'light'}`],
-    };
-}
-function detectThemeFromChrome(signals) {
-    const chromeSamples = signals.chromeThemeSamples ?? [];
-    const brightChrome = chromeSamples.filter((sample) => sample.luminance !== null && sample.luminance >= 0.58);
-    const darkChrome = chromeSamples.filter((sample) => sample.luminance !== null && sample.luminance <= 0.28);
-    if (brightChrome.length > 0 && darkChrome.length === 0) {
-        return {
-            theme: 'light',
-            confidence: brightChrome.length >= 2 ? 'high' : 'medium',
-            reasons: [`chrome_theme=light(${brightChrome.length})`],
-        };
-    }
-    if (darkChrome.length > 0 && brightChrome.length === 0) {
-        return {
-            theme: 'dark',
-            confidence: darkChrome.length >= 2 ? 'high' : 'medium',
-            reasons: [`chrome_theme=dark(${darkChrome.length})`],
-        };
-    }
-    return { theme: null, confidence: 'low', reasons: [] };
-}
-export function evaluateRequestedThemeState(params) {
-    const requested = params.requestedTheme ?? null;
-    const controlTheme = detectThemeFromControls(params.signals);
-    const storageTheme = detectThemeFromStorage(params.signals);
-    const rootTheme = detectThemeFromRoot(params.signals);
-    const chromeTheme = detectThemeFromChrome(params.signals);
-    const hasThemeControls = params.signals.variantControls.some((control) => control.kind === 'theme');
-    const hasThemeStorage = params.signals.storageHints.some((hint) => hint.kind === 'theme');
-    const hasThemeMechanism = hasThemeControls || hasThemeStorage;
-    const themeSources = [controlTheme, storageTheme, rootTheme, chromeTheme].filter((entry) => entry.theme !== null);
-    const darkVotes = themeSources.filter((entry) => entry.theme === 'dark').length;
-    const lightVotes = themeSources.filter((entry) => entry.theme === 'light').length;
-    let detected = null;
-    let confidence = 'low';
-    const reasons = [
-        requested ? `requested=${requested}` : null,
-        ...controlTheme.reasons,
-        ...storageTheme.reasons,
-        ...rootTheme.reasons,
-        ...chromeTheme.reasons,
-    ].filter((reason) => !!reason);
-    if (controlTheme.theme) {
-        detected = controlTheme.theme;
-        confidence = controlTheme.confidence;
-    }
-    else if (storageTheme.theme) {
-        detected = storageTheme.theme;
-        confidence = storageTheme.confidence;
-    }
-    else if (rootTheme.theme && chromeTheme.theme && rootTheme.theme !== chromeTheme.theme) {
-        return {
-            requested,
-            detected: null,
-            active: false,
-            ambiguous: true,
-            confidence: 'medium',
-            reasons: [
-                ...reasons,
-                'state=ambiguous(root_chrome_conflict)',
-            ],
-        };
-    }
-    else if (rootTheme.theme) {
-        detected = rootTheme.theme;
-        confidence = chromeTheme.theme === rootTheme.theme ? 'high' : rootTheme.confidence;
-    }
-    else if (chromeTheme.theme) {
-        detected = chromeTheme.theme;
-        confidence = chromeTheme.confidence;
-    }
-    else if (!hasThemeMechanism && params.signals.detectedTheme) {
-        detected = params.signals.detectedTheme;
-        confidence = 'medium';
-        reasons.push(`detected_theme=${params.signals.detectedTheme}`);
-    }
-    if (!requested) {
-        return {
-            requested: null,
-            detected: detected ?? params.signals.preferredColorScheme,
-            active: true,
-            ambiguous: detected === null,
-            confidence,
-            reasons: reasons.length > 0 ? reasons : [`preferred_color_scheme=${params.signals.preferredColorScheme}`],
-        };
-    }
-    if (!detected) {
-        return {
-            requested,
-            detected: null,
-            active: false,
-            ambiguous: true,
-            confidence: hasThemeMechanism ? 'medium' : 'low',
-            reasons: [
-                ...reasons,
-                `preferred_color_scheme=${params.signals.preferredColorScheme}`,
-                hasThemeControls ? 'theme_controls_detected' : null,
-                hasThemeStorage ? 'theme_storage_detected' : null,
-                'state=ambiguous(unresolved_theme_mechanism)',
-            ].filter((reason) => !!reason),
-        };
-    }
-    if (detected === requested) {
-        return {
-            requested,
-            detected,
-            active: true,
-            ambiguous: false,
-            confidence,
-            reasons,
-        };
-    }
-    const conflictingLowConfidence = confidence !== 'high'
-        || (darkVotes > 0 && lightVotes > 0);
-    return {
-        requested,
-        detected,
-        active: false,
-        ambiguous: conflictingLowConfidence,
-        confidence,
-        reasons: conflictingLowConfidence
-            ? [...reasons, 'state=ambiguous(theme_signal_conflict)']
-            : reasons,
-    };
-}
-function validateRequestedUrl(startUrl, currentUrl) {
-    if (!startUrl)
-        return true;
-    try {
-        const expected = new URL(startUrl);
-        const current = new URL(currentUrl);
-        if (expected.origin !== current.origin)
-            return false;
-        if (expected.pathname === '/' || expected.pathname === '')
-            return true;
-        return pathsRoughlyMatch(current.pathname, expected.pathname);
-    }
-    catch {
-        return currentUrl.startsWith(startUrl);
-    }
-}
-function evaluateAuthState(signals, currentUrl, profile) {
-    const authHints = signals.authHints ?? {
-        hasPasswordField: false,
-        hasEmailField: false,
-        hasAuthForm: false,
-        loginButtons: [],
-        logoutButtons: [],
-        accountMenuLabels: [],
-        accountLikeText: [],
-    };
-    const accountLabel = extractAccountLabel(signals) ?? profile?.accountLabel ?? null;
-    const loginLikeUrl = LOGIN_URL_RE.test(currentUrl);
-    const positiveReasons = [];
-    const negativeReasons = [];
-    const weakNegativeReasons = [];
-    if (authHints.logoutButtons.length > 0) {
-        positiveReasons.push(`logout_button=${truncate(authHints.logoutButtons[0], 60)}`);
-    }
-    if (accountLabel) {
-        positiveReasons.push(`account_label=${truncate(accountLabel, 60)}`);
-    }
-    if (authHints.accountMenuLabels.some((value) => ACCOUNT_MENU_RE.test(value))) {
-        positiveReasons.push(`account_menu=${truncate(authHints.accountMenuLabels[0], 60)}`);
-    }
-    if (!accountLabel && authHints.accountLikeText.length > 0) {
-        positiveReasons.push(`account_like=${truncate(authHints.accountLikeText[0], 60)}`);
-    }
-    if (profile?.authState === 'authenticated' && !loginLikeUrl) {
-        positiveReasons.push('profile=authenticated');
-    }
-    if (loginLikeUrl) {
-        negativeReasons.push(`login_url=${currentUrl}`);
-    }
-    if (authHints.hasPasswordField) {
-        negativeReasons.push('password_field_visible');
-    }
-    if (authHints.hasAuthForm) {
-        negativeReasons.push('auth_form_visible');
-    }
-    const dominantLoginCta = authHints.loginButtons.length > 0
-        && positiveReasons.length === 0
-        && (loginLikeUrl
-            || authHints.hasPasswordField
-            || authHints.hasAuthForm
-            || authHints.hasEmailField
-            || (signals.navLabels.length <= 2 && signals.breadcrumbLabels.length === 0));
-    if (dominantLoginCta) {
-        negativeReasons.push(`login_cta=${truncate(authHints.loginButtons[0], 60)}`);
-    }
-    else {
-        if (authHints.hasEmailField) {
-            weakNegativeReasons.push('email_field_visible');
-        }
-        if (authHints.loginButtons.length > 0) {
-            weakNegativeReasons.push(`login_button=${truncate(authHints.loginButtons[0], 60)}`);
-        }
-    }
-    if (negativeReasons.length > 0 && positiveReasons.length > 0) {
-        return {
-            authState: 'unknown',
-            diagnostic: makeDiagnostic('ambiguous', 'high', [
-                ...positiveReasons,
-                ...negativeReasons,
-                'state=ambiguous(auth_signal_conflict)',
-            ]),
-        };
-    }
-    if (negativeReasons.length > 0) {
-        return {
-            authState: 'login_required',
-            diagnostic: makeDiagnostic('mismatch', 'high', negativeReasons),
-        };
-    }
-    if (positiveReasons.length > 0 && weakNegativeReasons.length > 0) {
-        return {
-            authState: 'unknown',
-            diagnostic: makeDiagnostic('ambiguous', 'medium', [
-                ...positiveReasons,
-                ...weakNegativeReasons,
-                'state=ambiguous(mixed_auth_hints)',
-            ]),
-        };
-    }
-    if (positiveReasons.length > 0) {
-        return {
-            authState: 'authenticated',
-            diagnostic: makeDiagnostic('match', positiveReasons.some((reason) => reason.startsWith('logout_button=') || reason.startsWith('account_label='))
-                ? 'high'
-                : 'medium', positiveReasons),
-        };
-    }
-    if (weakNegativeReasons.length > 0) {
-        return {
-            authState: 'unknown',
-            diagnostic: makeDiagnostic('ambiguous', 'medium', [
-                ...weakNegativeReasons,
-                'state=ambiguous(weak_login_hints)',
-            ]),
-        };
-    }
-    return {
-        authState: 'unknown',
-        diagnostic: makeDiagnostic('ambiguous', 'low', ['auth=unknown']),
-    };
-}
-function buildSessionSummary(params) {
-    const parts = [
-        `auth=${params.authState}`,
-        params.detectedLang ? `lang=${params.detectedLang}` : null,
-        params.detectedTheme ? `theme=${params.detectedTheme}` : null,
-        params.accountLabel ? `account=${params.accountLabel}` : null,
-        `url=${params.currentUrl}`,
-        `state=${params.validationStatus}`,
-    ].filter(Boolean);
-    return truncate(parts.join('; '), 220);
-}
-export function buildAgentRunHints(entries) {
-    const severityByType = {
-        give_up: 'high',
-        verification_failure: 'high',
-        max_iterations: 'medium',
-        stuck_loop: 'medium',
-        storage_upload_failure: 'low',
-    };
-    const deduped = new Map();
-    for (const entry of entries) {
-        const correction = entry.user_response ? ` Fix: ${entry.user_response}` : '';
-        const message = truncate(`${entry.message}${correction}`, 240);
-        const key = `${entry.error_type}:${message.toLowerCase()}`;
-        if (deduped.has(key))
-            continue;
-        deduped.set(key, {
-            key: entry.error_type,
-            message,
-            severity: severityByType[entry.error_type] ?? 'medium',
-            source: 'agent_error',
-        });
-    }
-    return Array.from(deduped.values())
-        .sort((a, b) => {
-        const weight = (severity) => severity === 'high' ? 3 : severity === 'medium' ? 2 : 1;
-        return weight(b.severity) - weight(a.severity);
-    })
-        .slice(0, 6);
-}
-export function validateSessionProfile(params) {
-    const requestedLang = normalizeLangCode(params.requestedLang);
-    const langState = evaluateRequestedLanguageState({
-        currentUrl: params.currentUrl,
-        requestedLang: requestedLang ?? undefined,
-        signals: params.signals,
-    });
-    const themeState = evaluateRequestedThemeState({
-        requestedTheme: params.requestedTheme,
-        signals: params.signals,
-    });
-    const langCandidates = extractLangCandidates(params.signals, params.currentUrl);
-    const detectedLang = langState.detected ?? langCandidates[0] ?? null;
-    const detectedTheme = themeState.detected ?? params.profile?.detectedTheme ?? null;
-    const accountLabel = extractAccountLabel(params.signals) ?? params.profile?.accountLabel ?? null;
-    const authStateEvaluation = evaluateAuthState(params.signals, params.currentUrl, params.profile);
-    const authState = authStateEvaluation.authState;
-    const authDiagnostic = authStateEvaluation.diagnostic;
-    const authMatches = authDiagnostic.outcome !== 'mismatch';
-    let langMatches = null;
-    if (requestedLang) {
-        if (langState.active)
-            langMatches = true;
-        else if (langState.ambiguous)
-            langMatches = null;
-        else
-            langMatches = false;
-    }
-    const langDiagnostic = !requestedLang
-        ? makeDiagnostic('match', 'low', ['lang=not_requested'])
-        : langMatches === true
-            ? makeDiagnostic('match', langState.confidence, langState.reasons)
-            : langMatches === false
-                ? makeDiagnostic('mismatch', langState.confidence, langState.reasons)
-                : makeDiagnostic('ambiguous', langState.confidence, langState.reasons);
-    let themeMatches = null;
-    if (params.requestedTheme) {
-        if (themeState.active)
-            themeMatches = true;
-        else if (themeState.ambiguous)
-            themeMatches = null;
-        else
-            themeMatches = false;
-    }
-    const themeDiagnostic = !params.requestedTheme
-        ? makeDiagnostic('match', 'low', ['theme=not_requested'])
-        : themeMatches === true
-            ? makeDiagnostic('match', themeState.confidence, themeState.reasons)
-            : themeMatches === false
-                ? makeDiagnostic('mismatch', themeState.confidence, themeState.reasons)
-                : makeDiagnostic('ambiguous', themeState.confidence, themeState.reasons);
-    const urlMatches = validateRequestedUrl(params.startUrl, params.currentUrl);
-    const urlDiagnostic = !params.startUrl
-        ? makeDiagnostic('match', 'low', ['url=not_requested'])
-        : urlMatches
-            ? makeDiagnostic('match', 'high', [`url_matches=${params.startUrl}`])
-            : makeDiagnostic('mismatch', 'high', [`url_mismatch=${params.startUrl}`]);
-    const issues = [];
-    if (authDiagnostic.outcome === 'mismatch')
-        issues.push('auth');
-    if (langDiagnostic.outcome === 'mismatch')
-        issues.push('lang');
-    if (themeDiagnostic.outcome === 'mismatch')
-        issues.push('theme');
-    if (urlDiagnostic.outcome === 'mismatch')
-        issues.push('url');
-    let validationStatus = 'valid';
-    if (issues.length > 0) {
-        validationStatus = 'invalid';
-    }
-    else if (authDiagnostic.outcome === 'ambiguous'
-        || langDiagnostic.outcome === 'ambiguous'
-        || themeDiagnostic.outcome === 'ambiguous'
-        || urlDiagnostic.outcome === 'ambiguous') {
-        validationStatus = 'unknown';
-    }
-    return {
-        validationStatus,
-        authState,
-        authMatches,
-        langMatches,
-        themeMatches,
-        urlMatches,
-        authDiagnostic,
-        langDiagnostic,
-        themeDiagnostic,
-        urlDiagnostic,
-        detectedLang,
-        detectedTheme,
-        accountLabel,
-        issues,
-        summary: buildSessionSummary({
-            currentUrl: params.currentUrl,
-            authState,
-            detectedLang,
-            detectedTheme,
-            accountLabel,
-            validationStatus,
-        }),
-    };
-}
-export async function collectValidatedSessionProfile(browser, params) {
-    const currentUrl = browser.currentPage.url();
-    const includeStorageSnapshots = params.includeStorageSnapshots !== false;
-    const [signals, storageState, sessionStorage] = await Promise.all([
-        browser.capturePageSignals(),
-        includeStorageSnapshots
-            ? browser.exportStorageState().catch(() => undefined)
-            : Promise.resolve(params.existingProfile?.storageState),
-        includeStorageSnapshots
-            ? browser.exportSessionStorage().catch(() => undefined)
-            : Promise.resolve(params.existingProfile?.sessionStorage),
-    ]);
-    const validation = validateSessionProfile({
-        currentUrl,
-        startUrl: params.startUrl,
-        requestedLang: params.requestedLang,
-        requestedTheme: params.requestedTheme,
-        signals,
-        profile: params.existingProfile,
-    });
-    return {
-        profile: {
-            storageState,
-            sessionStorage,
-            authState: validation.authState,
-            accountLabel: validation.accountLabel,
-            detectedLang: validation.detectedLang,
-            detectedTheme: validation.detectedTheme,
-            validatedStartUrl: params.startUrl ?? params.existingProfile?.validatedStartUrl ?? currentUrl,
-            lastKnownUrl: currentUrl,
-            summary: validation.summary,
-            validationStatus: validation.validationStatus,
-            lastUsedAt: new Date().toISOString(),
-            profileVersion: params.existingProfile?.profileVersion ?? 1,
-        },
-        validation,
-    };
-}
-function uniqueSelectors(values) {
-    if (!values)
-        return [];
-    return Array.from(new Set(values.filter((value) => value && !value.startsWith('[index:'))));
-}
-function buildRequestedLanguageValues(requestedLang, sample) {
-    const normalized = normalizeLangCode(requestedLang);
-    if (!normalized)
-        return [];
-    const values = new Set([normalized]);
-    const raw = requestedLang.trim();
-    if (raw) {
-        values.add(raw);
-        values.add(raw.toLowerCase());
-        values.add(raw.toUpperCase());
-        values.add(raw.replace('-', '_'));
-        values.add(raw.toLowerCase().replace('-', '_'));
-    }
-    const sampleText = sample ?? '';
-    if (/^[A-Z]{2}$/.test(sampleText.trim())) {
-        values.add(normalized.toUpperCase());
-    }
-    return Array.from(values).filter(Boolean);
-}
-function buildRequestedThemeValues(requestedTheme, sample) {
-    const normalizedSample = (sample ?? '').trim().toLowerCase();
-    const values = new Set([requestedTheme]);
-    if (normalizedSample === '1' || normalizedSample === '0') {
-        values.add(requestedTheme === 'dark' ? '1' : '0');
-    }
-    if (normalizedSample === 'true' || normalizedSample === 'false') {
-        values.add(requestedTheme === 'dark' ? 'true' : 'false');
-    }
-    if (normalizedSample === 'enabled' || normalizedSample === 'disabled') {
-        values.add(requestedTheme === 'dark' ? 'enabled' : 'disabled');
-    }
-    if (normalizedSample === 'on' || normalizedSample === 'off') {
-        values.add(requestedTheme === 'dark' ? 'on' : 'off');
-    }
-    return Array.from(values);
-}
-function buildStorageReplacementCandidates(hint, params) {
-    if (hint.kind === 'locale' && params.requestedLang) {
-        return buildRequestedLanguageValues(params.requestedLang, hint.valueSample);
-    }
-    if (hint.kind === 'theme' && params.requestedTheme) {
-        return buildRequestedThemeValues(params.requestedTheme, hint.valueSample);
-    }
-    return [];
-}
-async function writeStorageHintCandidate(browser, hint, candidateValue) {
-    return browser.currentPage.evaluate(({ storageName, key, candidate, kind }) => {
-        const storage = storageName === 'localStorage' ? window.localStorage : window.sessionStorage;
-        const current = storage.getItem(key);
-        if (current == null)
-            return false;
-        if (current === candidate)
-            return true;
-        // Strict key matching for storage mutation to avoid rewriting unrelated keys.
-        // Keys must be an exact known term OR contain it as an isolated segment
-        // (e.g. "settings.lang" matches, "appLanguageVersion" does NOT).
-        const LOCALE_KEY_WHITELIST = ['lang', 'locale', 'language', 'i18n', 'intl', 'i18n-locale', 'next-i18next', 'NEXT_LOCALE', 'nuxt-i18n-locale'];
-        const THEME_KEY_WHITELIST = ['theme', 'color-scheme', 'colorScheme', 'dark-mode', 'darkMode', 'appearance'];
-        const whitelist = kind === 'locale' ? LOCALE_KEY_WHITELIST : THEME_KEY_WHITELIST;
-        const isAllowedKey = (k) => {
-            const lower = k.toLowerCase();
-            return whitelist.some(w => {
-                const wl = w.toLowerCase();
-                if (lower === wl)
-                    return true;
-                // Match as isolated segment: preceded/followed by non-alphanumeric
-                const re = new RegExp(`(?:^|[^a-zA-Z0-9])${wl.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}(?:$|[^a-zA-Z0-9])`, 'i');
-                return re.test(lower);
-            });
-        };
-        // Validate the current value looks like a lang code (2-5 chars) or theme value
-        // before rewriting, to avoid corrupting unrelated data.
-        const looksLikeTargetValue = (v) => {
-            if (kind === 'locale') {
-                return /^[a-z]{2,3}(-[a-zA-Z]{2,4})?$/.test(v.trim());
-            }
-            return /^(light|dark|auto|system|dim|high-contrast)$/i.test(v.trim());
-        };
-        const rewrite = (input, parentKeyAllowed = false) => {
-            if (typeof input === 'string') {
-                if (!looksLikeTargetValue(input))
-                    return { changed: false, value: input };
-                return { changed: input !== candidate, value: candidate };
-            }
-            if (Array.isArray(input)) {
-                // Only rewrite array elements when the parent key is an allowed locale/theme key.
-                // This prevents corrupting arrays of short strings (e.g. abbreviations, country codes)
-                // that happen to match locale patterns but are not linguistic in nature.
-                if (!parentKeyAllowed)
-                    return { changed: false, value: input };
-                let changed = false;
-                const next = input.map((entry) => {
-                    const rewritten = rewrite(entry, true);
-                    changed = changed || rewritten.changed;
-                    return rewritten.value;
-                });
-                return { changed, value: next };
-            }
-            if (input && typeof input === 'object') {
-                let changed = false;
-                const next = {};
-                for (const [entryKey, entryValue] of Object.entries(input)) {
-                    const keyAllowed = isAllowedKey(entryKey);
-                    if (keyAllowed && typeof entryValue === 'string' && looksLikeTargetValue(entryValue)) {
-                        if (entryValue !== candidate)
-                            changed = true;
-                        next[entryKey] = candidate;
-                        continue;
-                    }
-                    const rewritten = rewrite(entryValue, keyAllowed);
-                    changed = changed || rewritten.changed;
-                    next[entryKey] = rewritten.value;
-                }
-                return { changed, value: next };
-            }
-            return { changed: false, value: input };
-        };
-        let nextValue = candidate;
-        try {
-            const parsed = JSON.parse(current);
-            const rewritten = rewrite(parsed);
-            if (rewritten.changed) {
-                nextValue = JSON.stringify(rewritten.value);
-            }
-        }
-        catch {
-            nextValue = candidate;
-        }
-        storage.setItem(key, nextValue);
-        return true;
-    }, {
-        storageName: hint.storage,
-        key: hint.key,
-        candidate: candidateValue,
-        kind: hint.kind,
-    });
-}
-async function probeSelector(browser, selector) {
-    try {
-        return await browser.currentPage.locator(selector).first().evaluate((node) => ({
-            tag: node.tagName.toLowerCase(),
-            role: node.getAttribute('role') || '',
-            href: node instanceof HTMLAnchorElement ? node.href : node.getAttribute('href'),
-            label: (node.getAttribute('aria-label')
-                || node.getAttribute('title')
-                || node.innerText
-                || node.textContent
-                || '').replace(/\s+/g, ' ').trim().slice(0, 120),
-            inputType: node instanceof HTMLInputElement ? node.type : node.getAttribute('type'),
-        }));
-    }
-    catch {
-        return null;
-    }
-}
-function languageTerms(requestedLang) {
-    const normalized = normalizeLangCode(requestedLang);
-    if (!normalized)
-        return [];
-    return LANGUAGE_ALIASES[normalized] ?? [normalized];
-}
-function controlMatchesVariant(control, kind, target) {
-    if (control.kind !== kind)
-        return false;
-    const targetLower = target.toLowerCase();
-    const options = control.options
-        ?.map((option) => `${option.label || ''} ${option.value || ''}`.toLowerCase())
-        .join(' ')
-        ?? '';
-    const haystack = `${control.label} ${control.value || ''} ${control.href || ''} ${options}`.toLowerCase();
-    if (kind === 'locale') {
-        return languageTerms(target).some((term) => haystack.includes(term));
-    }
-    return haystack.includes(targetLower);
-}
-async function applyVariantSelector(browser, selector, params) {
-    const probe = await probeSelector(browser, selector);
-    if (!probe)
-        return false;
-    if (probe.tag === 'select') {
-        const optionLabel = params.kind === 'locale'
-            ? languageTerms(params.target)[0] ?? params.target
-            : params.target;
-        await browser.selectOption({
-            selector,
-            optionLabel,
-        });
-        return true;
-    }
-    if (probe.href && controlMatchesVariant({
-        kind: params.kind,
-        mechanism: 'link',
-        selector,
-        label: probe.label,
-        value: null,
-        href: probe.href,
-        tag: probe.tag,
-        role: probe.role,
-    }, params.kind, params.target)) {
-        await browser.navigateTo(probe.href);
-        return true;
-    }
-    if (params.kind === 'theme' && (probe.role === 'switch' || probe.inputType === 'checkbox')) {
-        await browser.clickBySelector(selector);
-        return true;
-    }
-    if (LANG_CONTROL_RE.test(`${probe.label} ${selector}`) || THEME_CONTROL_RE.test(`${probe.label} ${selector}`)) {
-        await browser.safeExpand({ selector });
-        return true;
-    }
-    await browser.clickBySelector(selector);
-    return true;
-}
-async function revalidate(browser, params) {
-    const signals = await browser.capturePageSignals();
-    return validateSessionProfile({
-        currentUrl: browser.currentPage.url(),
-        startUrl: params.startUrl,
-        requestedLang: params.requestedLang,
-        requestedTheme: params.requestedTheme,
-        signals,
-        profile: params.profile,
-    });
-}
-async function trySelectorSet(browser, selectors, action, params) {
-    let validation = await revalidate(browser, params.validationParams);
-    const updates = [];
-    for (const selector of selectors) {
-        try {
-            await action(selector);
-            await browser.wait(350);
-            validation = await revalidate(browser, params.validationParams);
-            updates.push({
-                stepSignature: params.signature,
-                selector,
-                source: 'deterministic',
-                success: validation.validationStatus !== 'invalid',
-            });
-            if (validation.validationStatus === 'valid') {
-                return { success: true, validation, updates };
-            }
-        }
-        catch {
-            updates.push({
-                stepSignature: params.signature,
-                selector,
-                source: 'deterministic',
-                success: false,
-            });
-        }
-    }
-    return { success: false, validation, updates };
-}
-function needsHardLangRepair(validation) {
-    return validation.langDiagnostic.outcome === 'mismatch';
-}
-function needsHardThemeRepair(validation) {
-    return validation.themeDiagnostic.outcome === 'mismatch';
-}
-export async function performDeterministicSessionRepair(browser, params) {
-    let validation = await revalidate(browser, params);
-    const updates = [];
-    if (validation.validationStatus === 'valid') {
-        return { repaired: false, validation, pathUsed: null, updates };
-    }
-    const remember = (next) => {
-        updates.push(...next.filter((update) => !!update.selector));
-    };
-    const refreshSignals = async (fallback) => browser.capturePageSignals().catch(() => fallback);
-    if (!validation.authMatches && params.credentials?.email && params.credentials?.password) {
-        const emailSelectors = uniqueSelectors(params.selectorMemory?.['login:email_field']);
-        const passwordSelectors = uniqueSelectors(params.selectorMemory?.['login:password_field']);
-        const submitSelectors = uniqueSelectors(params.selectorMemory?.['login:submit']);
-        if (params.credentials.loginUrl && !/\/(login|signin|sign-in|auth)\b/i.test(browser.currentPage.url())) {
-            await browser.navigateTo(params.credentials.loginUrl).catch(() => undefined);
-            await browser.wait(300);
-        }
-        for (const selector of emailSelectors.slice(0, 2)) {
-            try {
-                await browser.typeText(params.credentials.email, { selector, clearFirst: true });
-                remember([{ stepSignature: 'login:email_field', selector, source: 'deterministic', success: true }]);
-                break;
-            }
-            catch {
-                remember([{ stepSignature: 'login:email_field', selector, source: 'deterministic', success: false }]);
-            }
-        }
-        for (const selector of passwordSelectors.slice(0, 2)) {
-            try {
-                await browser.typeText(params.credentials.password, { selector, clearFirst: true });
-                remember([{ stepSignature: 'login:password_field', selector, source: 'deterministic', success: true }]);
-                break;
-            }
-            catch {
-                remember([{ stepSignature: 'login:password_field', selector, source: 'deterministic', success: false }]);
-            }
-        }
-        const submitAttempt = await trySelectorSet(browser, submitSelectors.slice(0, 2), async (selector) => {
-            await browser.clickBySelector(selector);
-        }, {
-            signature: 'login:submit',
-            validationParams: params,
-        });
-        remember(submitAttempt.updates);
-        validation = submitAttempt.validation;
-        if (validation.validationStatus === 'valid') {
-            return { repaired: true, validation, pathUsed: 'login_memory', updates };
-        }
-    }
-    let signals = await browser.capturePageSignals().catch(() => null);
-    if (params.requestedLang && needsHardLangRepair(validation)) {
-        const requestedLang = normalizeLangCode(params.requestedLang) ?? params.requestedLang;
-        const langOptionSelectors = uniqueSelectors(params.selectorMemory?.[`lang:option:${requestedLang}`]);
-        const langSwitchers = uniqueSelectors(params.selectorMemory?.['lang:switcher']);
-        const langMemoryAttempt = await trySelectorSet(browser, [...langOptionSelectors.slice(0, 3), ...langSwitchers.slice(0, 2)], async (selector) => {
-            await applyVariantSelector(browser, selector, {
-                kind: 'locale',
-                target: params.requestedLang,
-            });
-        }, {
-            signature: langOptionSelectors.length > 0 ? `lang:option:${requestedLang}` : 'lang:switcher',
-            validationParams: params,
-        });
-        remember(langMemoryAttempt.updates);
-        validation = langMemoryAttempt.validation;
-        if (langMemoryAttempt.updates.length > 0) {
-            signals = await refreshSignals(signals);
-        }
-        if (validation.validationStatus === 'valid') {
-            return { repaired: true, validation, pathUsed: 'lang_memory', updates };
-        }
-        if (signals) {
-            const control = signals.variantControls.find((entry) => controlMatchesVariant(entry, 'locale', params.requestedLang));
-            if (control) {
-                try {
-                    await applyVariantSelector(browser, control.selector, {
-                        kind: 'locale',
-                        target: params.requestedLang,
-                    });
-                    await browser.wait(350);
-                    validation = await revalidate(browser, params);
-                    signals = await refreshSignals(signals);
-                    remember([{
-                            stepSignature: `lang:option:${requestedLang}`,
-                            selector: control.selector,
-                            source: 'deterministic',
-                            success: validation.validationStatus !== 'invalid',
-                        }]);
-                    if (validation.validationStatus === 'valid') {
-                        return { repaired: true, validation, pathUsed: 'lang_control', updates };
-                    }
-                }
-                catch {
-                    remember([{
-                            stepSignature: `lang:option:${requestedLang}`,
-                            selector: control.selector,
-                            source: 'deterministic',
-                            success: false,
-                        }]);
-                }
-            }
-        }
-    }
-    // Recapture signals before theme repair — lang repair may have changed the DOM structure,
-    // opened/closed menus, or navigated to different settings. Theme variant controls detected
-    // before lang repair may no longer be accurate.
-    if (params.requestedTheme && needsHardThemeRepair(validation)) {
-        signals = await refreshSignals(signals);
-        const themeOptionSelectors = uniqueSelectors(params.selectorMemory?.[`theme:option:${params.requestedTheme}`]);
-        const themeToggles = uniqueSelectors(params.selectorMemory?.['theme:toggle']);
-        const themeAttempt = await trySelectorSet(browser, [...themeOptionSelectors.slice(0, 3), ...themeToggles.slice(0, 2)], async (selector) => {
-            await applyVariantSelector(browser, selector, {
-                kind: 'theme',
-                target: params.requestedTheme,
-            });
-        }, {
-            signature: themeOptionSelectors.length > 0 ? `theme:option:${params.requestedTheme}` : 'theme:toggle',
-            validationParams: params,
-        });
-        remember(themeAttempt.updates);
-        validation = themeAttempt.validation;
-        if (themeAttempt.updates.length > 0) {
-            signals = await refreshSignals(signals);
-        }
-        if (validation.validationStatus === 'valid') {
-            return { repaired: true, validation, pathUsed: 'theme_memory', updates };
-        }
-        if (signals) {
-            const control = signals.variantControls.find((entry) => controlMatchesVariant(entry, 'theme', params.requestedTheme));
-            if (control) {
-                try {
-                    await applyVariantSelector(browser, control.selector, {
-                        kind: 'theme',
-                        target: params.requestedTheme,
-                    });
-                    await browser.wait(350);
-                    validation = await revalidate(browser, params);
-                    signals = await refreshSignals(signals);
-                    remember([{
-                            stepSignature: `theme:option:${params.requestedTheme}`,
-                            selector: control.selector,
-                            source: 'deterministic',
-                            success: validation.validationStatus !== 'invalid',
-                        }]);
-                    if (validation.validationStatus === 'valid') {
-                        return { repaired: true, validation, pathUsed: 'theme_control', updates };
-                    }
-                }
-                catch {
-                    remember([{
-                            stepSignature: `theme:option:${params.requestedTheme}`,
-                            selector: control.selector,
-                            source: 'deterministic',
-                            success: false,
-                        }]);
-                }
-            }
-        }
-    }
-    if (signals
-        && ((params.requestedLang && validation.langMatches !== true)
-            || (params.requestedTheme && validation.themeMatches !== true))) {
-        const storageHints = signals.storageHints
-            .filter((hint) => (hint.kind === 'locale' && params.requestedLang && needsHardLangRepair(validation))
-            || (hint.kind === 'theme' && params.requestedTheme && needsHardThemeRepair(validation)))
-            .slice(0, 6);
-        for (const hint of storageHints) {
-            const candidates = buildStorageReplacementCandidates(hint, params).slice(0, 4);
-            for (const candidate of candidates) {
-                try {
-                    const written = await writeStorageHintCandidate(browser, hint, candidate);
-                    if (!written)
-                        continue;
-                    await browser.currentPage.reload({ waitUntil: 'domcontentloaded', timeout: 15000 }).catch(async () => {
-                        await browser.navigateTo(browser.currentPage.url());
-                    });
-                    await browser.wait(350);
-                    validation = await revalidate(browser, params);
-                    signals = await refreshSignals(signals);
-                    if (validation.validationStatus === 'valid') {
-                        return {
-                            repaired: true,
-                            validation,
-                            pathUsed: hint.kind === 'locale' ? 'lang_storage' : 'theme_storage',
-                            updates,
-                        };
-                    }
-                }
-                catch {
-                    // Try the next candidate/value.
-                }
-            }
-        }
-    }
-    const expandableSelectors = [
-        ...uniqueSelectors(params.selectorMemory?.['menu:primary']).slice(0, 2),
-        ...uniqueSelectors(params.selectorMemory?.['account:menu']).slice(0, 2),
-    ];
-    if (expandableSelectors.length > 0 && (needsHardLangRepair(validation) || needsHardThemeRepair(validation))) {
-        const menuAttempt = await trySelectorSet(browser, expandableSelectors, async (selector) => {
-            await browser.safeExpand({ selector });
-        }, {
-            signature: 'menu:primary',
-            validationParams: params,
-        });
-        remember(menuAttempt.updates);
-        validation = menuAttempt.validation;
-        if (menuAttempt.updates.length > 0) {
-            signals = await refreshSignals(signals);
-        }
-        if (validation.validationStatus === 'valid') {
-            return { repaired: true, validation, pathUsed: 'menu_expand', updates };
-        }
-        const expandedSignals = await refreshSignals(signals);
-        if (expandedSignals) {
-            if (params.requestedLang && needsHardLangRepair(validation)) {
-                const control = expandedSignals.variantControls.find((entry) => controlMatchesVariant(entry, 'locale', params.requestedLang));
-                if (control) {
-                    try {
-                        await applyVariantSelector(browser, control.selector, {
-                            kind: 'locale',
-                            target: params.requestedLang,
-                        });
-                        await browser.wait(350);
-                        validation = await revalidate(browser, params);
-                        signals = await refreshSignals(expandedSignals);
-                        remember([{
-                                stepSignature: `lang:option:${normalizeLangCode(params.requestedLang) ?? params.requestedLang}`,
-                                selector: control.selector,
-                                source: 'deterministic',
-                                success: validation.validationStatus !== 'invalid',
-                            }]);
-                        if (validation.validationStatus === 'valid') {
-                            return { repaired: true, validation, pathUsed: 'menu_expand_lang_control', updates };
-                        }
-                    }
-                    catch {
-                        remember([{
-                                stepSignature: `lang:option:${normalizeLangCode(params.requestedLang) ?? params.requestedLang}`,
-                                selector: control.selector,
-                                source: 'deterministic',
-                                success: false,
-                            }]);
-                    }
-                }
-            }
-            if (params.requestedTheme && needsHardThemeRepair(validation)) {
-                const control = expandedSignals.variantControls.find((entry) => controlMatchesVariant(entry, 'theme', params.requestedTheme));
-                if (control) {
-                    try {
-                        await applyVariantSelector(browser, control.selector, {
-                            kind: 'theme',
-                            target: params.requestedTheme,
-                        });
-                        await browser.wait(350);
-                        validation = await revalidate(browser, params);
-                        signals = await refreshSignals(expandedSignals);
-                        remember([{
-                                stepSignature: `theme:option:${params.requestedTheme}`,
-                                selector: control.selector,
-                                source: 'deterministic',
-                                success: validation.validationStatus !== 'invalid',
-                            }]);
-                        if (validation.validationStatus === 'valid') {
-                            return { repaired: true, validation, pathUsed: 'menu_expand_theme_control', updates };
-                        }
-                    }
-                    catch {
-                        remember([{
-                                stepSignature: `theme:option:${params.requestedTheme}`,
-                                selector: control.selector,
-                                source: 'deterministic',
-                                success: false,
-                            }]);
-                    }
-                }
-            }
-        }
-    }
-    return { repaired: false, validation, pathUsed: null, updates };
-}
-export function buildProfileSelectorUpdates(signals, params) {
-    const updates = [];
-    const requestedLang = normalizeLangCode(params.requestedLang);
-    for (const control of signals.variantControls) {
-        if (control.kind === 'locale') {
-            updates.push({
-                stepSignature: requestedLang && controlMatchesVariant(control, 'locale', requestedLang)
-                    ? `lang:option:${requestedLang}`
-                    : 'lang:switcher',
-                selector: control.selector,
-                source: 'deterministic',
-                success: true,
-            });
-        }
-        else if (control.kind === 'theme') {
-            updates.push({
-                stepSignature: params.requestedTheme && controlMatchesVariant(control, 'theme', params.requestedTheme)
-                    ? `theme:option:${params.requestedTheme}`
-                    : 'theme:toggle',
-                selector: control.selector,
-                source: 'deterministic',
-                success: true,
-            });
-        }
-    }
-    return updates;
-}
-//# sourceMappingURL=session-profile.js.map