autokap 1.0.2 → 1.0.3

package/dist/video-agent.js

@@ -1,4783 +0,0 @@
-import OpenAI from 'openai';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { Browser } from './browser.js';
-import { analyzeReplayCandidate, executeAction, resolveReplayActionArgs, runAgent } from './agent.js';
-import { observePlanningContext, planFromScript } from './video-planner.js';
-import { videoVerificationTools } from './video-tools.js';
-import { buildCursorOverlayScript, buildVideoPromptContentParts, buildVideoVerificationSystemPrompt, buildVideoStepVerificationUserMessage, buildStepFixerSystemPrompt, buildStepFixerUserMessage, } from './video-prompts.js';
-import { buildVideoObservationSnapshot, captureVideoObservationSummary } from './video-observation.js';
-import { buildStepUsageFromSnapshot, extractLlmUsageSnapshot, normalizeLlmUsageSnapshot, } from './llm-usage.js';
-import { detectVariantStateDeterministic, evaluateRequestedThemeState, scoreLocaleSignals, } from './video-variant-state.js';
-import { animatedClick, animatedHover, humanType, moveMouse } from './mouse-animation.js';
-import { dismissOverlaysWithLogging } from './overlay-utils.js';
-import { logger } from './logger.js';
-import { evaluateActionSecurity, evaluateResolvedActionSecurity } from './security.js';
-import { createAbortError, getAbortMessage, isAbortError, throwIfAborted } from './abort.js';
-const VIDEO_AGENT_CACHE_LAYOUT_V2 = process.env.VIDEO_AGENT_CACHE_LAYOUT_V2 === '1';
-function createClient(apiKey) {
-    return new OpenAI({
-        baseURL: 'https://openrouter.ai/api/v1',
-        apiKey,
-        defaultHeaders: {
-            'HTTP-Referer': 'https://github.com/screenshot-agent',
-            'X-Title': 'Screenshot Agent',
-        },
-    });
-}
-// ── Helpers ──────────────────────────────────────────────────────────
-function log(msg, level = 'info', cb) {
-    const entry = { level, message: msg, timestamp: Date.now() };
-    if (level === 'error')
-        logger.error(msg);
-    else if (level === 'success')
-        logger.success(msg);
-    else if (level === 'ai')
-        logger.ai(msg);
-    else
-        logger.info(msg);
-    cb?.(entry);
-}
-function attachAbortToBrowser(signal, browser) {
-    if (!signal) {
-        return () => { };
-    }
-    const onAbort = () => {
-        void browser.close().catch(() => {
-            // Browser may already be closed.
-        });
-    };
-    if (signal.aborted) {
-        onAbort();
-        return () => { };
-    }
-    signal.addEventListener('abort', onAbort, { once: true });
-    return () => {
-        signal.removeEventListener('abort', onAbort);
-    };
-}
-function createDryRunSubphaseSignal(params) {
-    if (!params.parentSignal && params.timeoutMs === null) {
-        return { signal: undefined, cleanup: () => { } };
-    }
-    const controller = new AbortController();
-    let timeout = null;
-    const abort = (reason) => {
-        if (controller.signal.aborted)
-            return;
-        if (reason instanceof Error) {
-            controller.abort(reason);
-            return;
-        }
-        if (typeof reason === 'string' && reason.trim().length > 0) {
-            controller.abort(createAbortError(reason));
-            return;
-        }
-        controller.abort(createAbortError('Video dry-run cancelled.'));
-    };
-    const onParentAbort = () => {
-        abort(params.parentSignal?.reason ?? getAbortMessage(params.parentSignal, 'Video dry-run cancelled.'));
-    };
-    if (params.parentSignal) {
-        if (params.parentSignal.aborted) {
-            onParentAbort();
-        }
-        else {
-            params.parentSignal.addEventListener('abort', onParentAbort, { once: true });
-        }
-    }
-    if (params.timeoutMs !== null) {
-        timeout = setTimeout(() => {
-            abort(createAbortError(`Dry-run step ${params.stepIndex + 1} ${params.subphase} timed out after ${params.timeoutMs}ms.`));
-        }, params.timeoutMs);
-    }
-    return {
-        signal: controller.signal,
-        cleanup: () => {
-            if (timeout)
-                clearTimeout(timeout);
-            if (params.parentSignal) {
-                params.parentSignal.removeEventListener('abort', onParentAbort);
-            }
-        },
-    };
-}
-function getAbortAwareErrorMessage(signal, error, fallback) {
-    if (signal?.aborted) {
-        return getAbortMessage(signal, fallback);
-    }
-    if (error instanceof Error && error.message) {
-        return error.message;
-    }
-    return fallback;
-}
-function getRemainingPhaseBudgetMs(config) {
-    if (!config.internalPhaseStartedAt || !config.internalPhaseTimeoutMs) {
-        return null;
-    }
-    return Math.max(0, config.internalPhaseTimeoutMs - (Date.now() - config.internalPhaseStartedAt));
-}
-function summarizeVideoTarget(target) {
-    if (!target)
-        return '';
-    const parts = [
-        target.label ? `label=${target.label}` : '',
-        target.href ? `href=${target.href}` : '',
-        target.role ? `role=${target.role}` : '',
-        target.tag ? `tag=${target.tag}` : '',
-        target.selector ? `selector=${target.selector}` : '',
-        typeof target.index === 'number' ? `index=${target.index}` : '',
-    ].filter(Boolean);
-    return parts.join(', ');
-}
-function summarizeStepTarget(step) {
-    return summarizeVideoTarget(step.target)
-        || step.selector
-        || (step.coordinates ? `coords=${step.coordinates.x},${step.coordinates.y}` : '')
-        || step.description;
-}
-async function runDryRunSubphase(params) {
-    const remaining = getRemainingPhaseBudgetMs(params.config);
-    const minBudgetMs = Math.max(1200, params.minBudgetMs ?? 1500);
-    log(`[Dry-run] stepStart step=${params.stepIndex + 1} subphase=${params.subphase} remainingBudgetMs=${remaining ?? 'unbounded'}`, 'info', params.callbacks.onLog);
-    if (remaining !== null && remaining < minBudgetMs) {
-        throw new Error(`Dry-run budget exhausted before step ${params.stepIndex + 1} ${params.subphase} (remaining ${remaining}ms).`);
-    }
-    const localTimeout = remaining === null
-        ? null
-        : Math.max(800, Math.min(remaining - 250, params.subphase === 'repair_lane'
-            ? 40_000
-            : params.subphase === 'prepared_variant'
-                ? 60_000
-                : params.subphase === 'verification_llm' || params.subphase === 'llm_fixer'
-                    ? 30_000
-                    : 20_000));
-    const fallbackMessage = localTimeout === null
-        ? `Dry-run step ${params.stepIndex + 1} ${params.subphase} cancelled.`
-        : `Dry-run step ${params.stepIndex + 1} ${params.subphase} timed out after ${localTimeout}ms.`;
-    const { signal, cleanup } = createDryRunSubphaseSignal({
-        parentSignal: params.config.abortSignal,
-        timeoutMs: localTimeout,
-        stepIndex: params.stepIndex,
-        subphase: params.subphase,
-    });
-    try {
-        const result = await params.run(localTimeout, signal);
-        log(`[Dry-run] ${params.subphase}End step=${params.stepIndex + 1} remainingBudgetMs=${getRemainingPhaseBudgetMs(params.config) ?? 'unbounded'}`, 'info', params.callbacks.onLog);
-        return result;
-    }
-    catch (error) {
-        const message = getAbortAwareErrorMessage(signal, error, fallbackMessage);
-        log(`[Dry-run] ${params.subphase}Failed step=${params.stepIndex + 1} error=${message}`, 'error', params.callbacks.onLog);
-        throw signal?.aborted && !params.config.abortSignal?.aborted
-            ? createAbortError(message)
-            : error;
-    }
-    finally {
-        cleanup();
-    }
-}
-function buildVideoStepTargetFromAction(action, coherenceKey) {
-    const selector = typeof action.params.selector === 'string' ? action.params.selector : undefined;
-    const coordinates = typeof action.params.x === 'number' && typeof action.params.y === 'number'
-        ? { x: action.params.x, y: action.params.y }
-        : typeof action.params.elementCx === 'number' && typeof action.params.elementCy === 'number'
-            ? { x: action.params.elementCx, y: action.params.elementCy }
-            : undefined;
-    const target = {
-        selector,
-        href: typeof action.params.href === 'string' ? action.params.href : undefined,
-        label: typeof action.params.elementLabel === 'string' ? action.params.elementLabel : undefined,
-        tag: typeof action.params.elementTag === 'string' ? action.params.elementTag : undefined,
-        role: typeof action.params.elementRole === 'string' ? action.params.elementRole : undefined,
-        coordinates,
-        index: typeof action.params.index === 'number' ? action.params.index : undefined,
-        coherenceKey,
-    };
-    return target.selector || target.href || target.label || target.coordinates || typeof target.index === 'number'
-        ? target
-        : undefined;
-}
-function mapExecutedActionsToVideoSteps(params) {
-    const actionable = params.actions.filter((action) => (action.success !== false
-        && ['navigate_to', 'dismiss_overlays', 'click', 'type_text', 'select_option', 'scroll', 'press_key', 'wait', 'hover', 'safe_expand'].includes(action.action)));
-    return actionable.map((action, index) => {
-        const id = index === 0 ? params.originalStep.id : `${params.originalStep.id}-repair-${index + 1}`;
-        const target = buildVideoStepTargetFromAction(action, params.coherenceKey);
-        const baseStep = {
-            ...params.originalStep,
-            id,
-            description: typeof action.params.elementLabel === 'string'
-                ? `${action.action} ${action.params.elementLabel}`.trim()
-                : params.originalStep.description,
-            target,
-            selector: target?.selector ?? (typeof action.params.selector === 'string' ? action.params.selector : undefined),
-            coordinates: target?.coordinates,
-        };
-        switch (action.action) {
-            case 'navigate_to':
-                return { ...baseStep, type: 'navigate', url: String(action.params.url ?? params.originalStep.url ?? '') };
-            case 'dismiss_overlays':
-                return { ...baseStep, type: 'dismiss_overlays' };
-            case 'type_text':
-                return { ...baseStep, type: 'type', text: String(action.params.text ?? params.originalStep.text ?? '') };
-            case 'select_option':
-                return {
-                    ...baseStep,
-                    type: 'select_option',
-                    optionLabel: typeof action.params.optionLabel === 'string' ? action.params.optionLabel : params.originalStep.optionLabel,
-                    optionValue: typeof action.params.optionValue === 'string' ? action.params.optionValue : params.originalStep.optionValue,
-                    optionIndex: typeof action.params.optionIndex === 'number' ? action.params.optionIndex : params.originalStep.optionIndex,
-                };
-            case 'scroll':
-                return {
-                    ...baseStep,
-                    type: 'scroll',
-                    direction: action.params.direction ?? params.originalStep.direction ?? 'down',
-                    amount: typeof action.params.amount === 'number' ? action.params.amount : params.originalStep.amount ?? 400,
-                };
-            case 'press_key':
-                return { ...baseStep, type: 'key', key: String(action.params.key ?? params.originalStep.key ?? 'Enter') };
-            case 'hover':
-            case 'safe_expand':
-                return { ...baseStep, type: 'hover' };
-            case 'wait':
-                return { ...baseStep, type: 'wait', waitMs: Number(action.params.ms ?? params.originalStep.waitMs ?? 500) };
-            case 'click':
-            default:
-                return { ...baseStep, type: 'click' };
-        }
-    });
-}
-function buildScreenshotRepairLanePrompt(params) {
-    const details = [
-        `Overall clip goal: ${params.script}`,
-        `Current blocked step: ${params.step.description}`,
-        params.nextStep ? `Stop as soon as the UI needed for the next step is visible: ${params.nextStep.description}` : 'Stop as soon as this step has clearly succeeded.',
-        params.lang ? `Requested UI language: ${params.lang}` : '',
-        params.theme ? `Requested UI theme: ${params.theme}` : '',
-        params.step.expectedPageAfter ? `Expected destination contract: ${JSON.stringify(params.step.expectedPageAfter)}` : '',
-        summarizeStepTarget(params.step) ? `Current step target hints: ${summarizeStepTarget(params.step)}` : '',
-    ].filter(Boolean).join('\n');
-    return `${details}
-
-Use the existing browser state on the current page. Perform ONLY the minimal actions needed to make this step succeed.
-- Re-read the live page and use visible interactive elements or search_text instead of guessing stale selectors.
-- If a menu, dialog, or popover must be opened for the step to succeed, open it and stop immediately once that resulting UI is visible.
-- Do NOT perform later clip actions.
-- Do NOT navigate away unless the current step explicitly requires it.
-- Call ready_to_capture immediately when the exact post-step UI state is visible.`;
-}
-function buildPreparedVariantRepairPrompt(params) {
-    const details = [
-        'Variant preflight only.',
-        `Overall clip goal: ${params.script}`,
-        `Current page URL: ${params.currentUrl}`,
-        params.preparedStartUrl ? `Required final page URL family: ${params.preparedStartUrl}` : '',
-        params.lang ? `Requested fixed UI language: ${params.lang}` : '',
-        params.theme ? `Requested fixed UI theme: ${params.theme}` : '',
-        params.observedSummary ? `Observed variant mismatch: ${params.observedSummary}` : '',
-        params.langInstructions
-            ? `Follow these language-switch instructions exactly:\n${params.langInstructions}`
-            : params.lang
-                ? `Use the in-app language selector and confirm the fixed app chrome is in "${params.lang}".`
-                : '',
-        params.themeInstructions
-            ? `Follow these theme-switch instructions exactly:\n${params.themeInstructions}`
-            : params.theme
-                ? `If the fixed UI theme is not "${params.theme}", use the in-app theme selector, appearance menu, or persisted preference to switch it.`
-                : '',
-    ].filter(Boolean).join('\n\n');
-    return `${details}
-
-Use the existing authenticated browser state. The correct project/page is already open, but the fixed UI variant is not reliably restored in this fresh browser.
-- Keep the SAME project/entity/page open while restoring the requested language/theme.
-- Dismiss cookie/analytics banners or overlays first if they block the UI.
-- Prefer visible locale/theme controls, user menus, or settings/sidebar entries. If a combined variant chip or label like "fr light" is visible, use that control directly.
-- Do NOT start by searching for tiny raw tokens like "fr", "en", "light", or "dark" unless a settings page, language picker, or variant menu is already open.
-- Use visible controls, menus, settings, or search_text to find the language/theme switch. Do not guess stale selectors.
-- If the app briefly detours through settings or another route to switch language/theme, return to the same project/page before finishing.
-- Ignore user-generated content that may remain in another language, including project names, preset names, assistant text, and imported data labels.
-- Do NOT perform the recorded clip interaction itself (for example do not click "New", do not open "New preset", do not select "Hero").
-- Call ready_to_capture only when the current page is back on the correct project/entity and the visible app chrome matches the requested language/theme.
-- If you cannot restore the requested language/theme on this page, call give_up.`;
-}
-async function replayPreparedActions(browser, config, callbacks) {
-    if (!config.preparedReplayActions || config.preparedReplayActions.length === 0) {
-        return;
-    }
-    const replayAnalysis = analyzeReplayCandidate(config.preparedReplayActions, {
-        currentUrl: browser.currentPage.url(),
-        targetUrl: config.preparedStartUrl ?? config.url,
-        currentViewport: browser.currentPage.viewportSize(),
-        isAuthenticated: !!config.credentials,
-        currentDialogCount: null,
-        pageIdentity: config.preparedObservationSnapshot?.pageIdentity ?? null,
-    });
-    if (replayAnalysis.skipReason) {
-        log(`[Dry-run] replayPreparedState skipped: ${replayAnalysis.skipReason}`, 'info', callbacks.onLog);
-        return;
-    }
-    log(`[Dry-run] replayPreparedState replaying ${replayAnalysis.replayableActions.length} action(s)`, 'info', callbacks.onLog);
-    for (const action of replayAnalysis.replayableActions) {
-        throwIfAborted(config.abortSignal, 'Video dry-run cancelled.');
-        const interactiveElements = ['click', 'type_text', 'select_option', 'scroll', 'hover', 'safe_expand'].includes(action.action)
-            ? await browser.getInteractiveElements({ timeoutMs: 3000 }).catch(() => [])
-            : [];
-        const resolved = resolveReplayActionArgs(action, interactiveElements);
-        if (!resolved.args) {
-            log(`[Dry-run] replayPreparedState unresolved action "${action.action}": ${resolved.reason}`, 'info', callbacks.onLog);
-            continue;
-        }
-        const result = await executeAction(browser, action.action, resolved.args);
-        if (!result.success) {
-            log(`[Dry-run] replayPreparedState action "${action.action}" failed: ${result.error}`, 'info', callbacks.onLog);
-            break;
-        }
-    }
-}
-async function runScreenshotRepairLane(params) {
-    const prompt = buildScreenshotRepairLanePrompt({
-        script: params.config.script,
-        step: params.originalStep,
-        nextStep: params.nextStep,
-        lang: params.config.lang,
-        theme: params.config.theme,
-    });
-    const result = await runAgent(params.browser, {
-        url: params.browser.currentPage.url(),
-        prompt,
-        dark: params.config.theme === 'dark',
-        langs: params.config.lang ? [params.config.lang] : ['en'],
-        outputDir: '',
-        headed: false,
-        viewport: params.config.viewport,
-        maxIterations: Math.min(params.config.maxStepRetries ?? 12, 12),
-        model: params.config.model,
-        credentials: params.config.credentials,
-        currentLang: params.config.lang,
-        currentTheme: params.config.theme,
-        selectorMemory: params.config.selectorMemory,
-        abortSignal: params.abortSignal ?? params.config.abortSignal,
-    }, params.config.apiKey);
-    if (!result.success) {
-        return null;
-    }
-    const steps = mapExecutedActionsToVideoSteps({
-        actions: result.actions,
-        originalStep: params.originalStep,
-        coherenceKey: params.config.preparedCoherenceKey,
-    });
-    if (steps.length === 0) {
-        return null;
-    }
-    return {
-        steps,
-        actions: result.actions,
-        resolvedTargetSummary: summarizeStepTarget(steps[0] ?? params.originalStep),
-    };
-}
-async function runPreparedVariantRepairLane(params) {
-    const prompt = buildPreparedVariantRepairPrompt({
-        script: params.config.script,
-        currentUrl: params.browser.currentPage.url(),
-        preparedStartUrl: params.config.preparedStartUrl,
-        lang: params.config.lang,
-        theme: params.config.theme,
-        langInstructions: params.config.langInstructions,
-        themeInstructions: params.config.themeInstructions,
-        observedSummary: params.observedSummary,
-    });
-    const buildAgentConfig = (model) => ({
-        url: params.browser.currentPage.url(),
-        prompt,
-        dark: params.config.theme === 'dark',
-        langs: params.config.lang ? [params.config.lang] : ['en'],
-        outputDir: '',
-        headed: false,
-        viewport: params.config.viewport,
-        maxIterations: Math.min(params.config.maxStepRetries ?? 12, 12),
-        model,
-        credentials: params.config.credentials,
-        langInstructions: params.config.langInstructions,
-        themeInstructions: params.config.themeInstructions,
-        currentLang: params.config.lang,
-        currentTheme: params.config.theme,
-        selectorMemory: params.config.selectorMemory,
-        abortSignal: params.abortSignal ?? params.config.abortSignal,
-        runMode: 'language_preflight',
-        currentObjective: 'repair',
-    });
-    const result = await runAgent(params.browser, buildAgentConfig(params.config.model), params.config.apiKey);
-    // If primary model failed to complete the repair (no actions, or ran but didn't succeed)
-    // and a fallback is configured, retry with the fallback model.
-    if (!result.success && params.config.fallbackModel && params.config.fallbackModel !== params.config.model) {
-        logger.info(`[repair-lane] Primary model failed (${result.actions.length} actions, success=${result.success}), retrying with fallback model: ${params.config.fallbackModel}`);
-        return runAgent(params.browser, buildAgentConfig(params.config.fallbackModel), params.config.apiKey);
-    }
-    return result;
-}
-async function prepareVideoSessionStorage(browser, sessionStorage) {
-    if (!sessionStorage || Object.keys(sessionStorage).length === 0)
-        return;
-    await browser.prepareSessionStorage(sessionStorage, { replace: true });
-}
-async function captureVideoStepCheckpoint(page) {
-    const scroll = await page.evaluate(() => ({
-        x: Math.round(window.scrollX),
-        y: Math.round(window.scrollY),
-    })).catch(() => ({ x: 0, y: 0 }));
-    return {
-        url: page.url(),
-        scrollX: scroll.x,
-        scrollY: scroll.y,
-    };
-}
-export async function restoreVideoStepCheckpoint(browser, checkpoint) {
-    let page = browser.currentPage;
-    const currentUrl = page.url();
-    if (currentUrl !== checkpoint.url) {
-        await browser.navigateTo(checkpoint.url);
-        page = browser.currentPage;
-        await page.waitForLoadState('networkidle', { timeout: 4000 }).catch(() => { });
-    }
-    await page.evaluate(({ x, y }) => window.scrollTo({ left: x, top: y, behavior: 'instant' }), { x: checkpoint.scrollX, y: checkpoint.scrollY }).catch(() => { });
-    await page.waitForTimeout(250);
-}
-export function isRectMeaningfullyVisibleInViewport(params) {
-    const { rect, viewportWidth, viewportHeight, topInset = 0, bottomInset = 0 } = params;
-    const topSafeY = topInset + 16;
-    const bottomSafeY = viewportHeight - bottomInset - 16;
-    if (rect.width <= 0 ||
-        rect.height <= 0 ||
-        rect.bottom <= topSafeY ||
-        rect.right <= 0 ||
-        rect.top >= bottomSafeY ||
-        rect.left >= viewportWidth) {
-        return false;
-    }
-    const visibleHeight = Math.min(rect.bottom, bottomSafeY) - Math.max(rect.top, topSafeY);
-    const minVisibleHeight = Math.min(Math.max(28, rect.height * 0.45), Math.max(28, rect.height - 4));
-    return visibleHeight >= minVisibleHeight;
-}
-async function isLocatorMeaningfullyInViewport(locator) {
-    try {
-        return await locator.evaluate((node) => {
-            if (!(node instanceof HTMLElement))
-                return false;
-            const detectOcclusionInsets = () => {
-                let top = 0;
-                let bottom = 0;
-                const viewportHeight = window.innerHeight;
-                const viewportWidth = window.innerWidth;
-                const viewportCenterX = viewportWidth / 2;
-                for (const candidate of Array.from(document.body?.querySelectorAll('*') ?? [])) {
-                    if (!(candidate instanceof HTMLElement))
-                        continue;
-                    const style = window.getComputedStyle(candidate);
-                    if (style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity || '1') === 0) {
-                        continue;
-                    }
-                    if (style.position !== 'fixed' && style.position !== 'sticky')
-                        continue;
-                    if (candidate.getAttribute('aria-hidden') === 'true')
-                        continue;
-                    const rect = candidate.getBoundingClientRect();
-                    if (rect.width <= 0 || rect.height <= 0)
-                        continue;
-                    if (rect.width < viewportWidth * 0.35)
-                        continue;
-                    if (rect.left > viewportCenterX || rect.right < viewportCenterX)
-                        continue;
-                    if (rect.height > viewportHeight * 0.35)
-                        continue;
-                    if (rect.top <= 24 && rect.bottom > 0) {
-                        top = Math.max(top, rect.bottom);
-                    }
-                    if (rect.bottom >= viewportHeight - 24 && rect.top < viewportHeight) {
-                        bottom = Math.max(bottom, viewportHeight - rect.top);
-                    }
-                }
-                return { top, bottom };
-            };
-            const rect = node.getBoundingClientRect();
-            const { top, bottom } = detectOcclusionInsets();
-            const topSafeY = top + 16;
-            const bottomSafeY = window.innerHeight - bottom - 16;
-            if (rect.width <= 0 ||
-                rect.height <= 0 ||
-                rect.bottom <= topSafeY ||
-                rect.right <= 0 ||
-                rect.top >= bottomSafeY ||
-                rect.left >= window.innerWidth) {
-                return false;
-            }
-            const visibleHeight = Math.min(rect.bottom, bottomSafeY) - Math.max(rect.top, topSafeY);
-            const minVisibleHeight = Math.min(Math.max(28, rect.height * 0.45), Math.max(28, rect.height - 4));
-            return visibleHeight >= minVisibleHeight;
-        });
-    }
-    catch {
-        return false;
-    }
-}
-function isFeatureEnabled(name, defaultEnabled = true) {
-    const raw = process.env[name];
-    if (raw == null)
-        return defaultEnabled;
-    const normalized = raw.trim().toLowerCase();
-    return normalized !== '0' && normalized !== 'false' && normalized !== 'off' && normalized !== 'no';
-}
-function splitSelectorCandidates(selector) {
-    if (!selector)
-        return [];
-    return selector
-        .split(',')
-        .map((item) => item.trim())
-        .filter(Boolean);
-}
-function containsInternalAutomationSelector(selector) {
-    return !!selector && /\[data-ak-[^\]]+\]|data-ak-interactive-index/i.test(selector);
-}
-function dedupeSelectors(selectors) {
-    const seen = new Set();
-    const result = [];
-    for (const selector of selectors) {
-        if (containsInternalAutomationSelector(selector))
-            continue;
-        if (seen.has(selector))
-            continue;
-        seen.add(selector);
-        result.push(selector);
-    }
-    return result;
-}
-function pickModeTimeout(mode, recordingMs, dryRunMs) {
-    return mode === 'recording' ? recordingMs : dryRunMs;
-}
-function shouldUseDeterministicRecovery(step) {
-    return step.type === 'click'
-        || step.type === 'type'
-        || step.type === 'select_option'
-        || step.type === 'hover'
-        || step.type === 'assert_element';
-}
-function buildStepSignature(step) {
-    const normalizedDescription = step.description.toLowerCase().replace(/\\s+/g, ' ').trim().slice(0, 120);
-    if (step.type === 'navigate')
-        return `navigate|${step.url ?? ''}|${normalizedDescription}`;
-    if (step.type === 'assert_url')
-        return `assert_url|${step.urlPattern ?? ''}|${normalizedDescription}`;
-    if (step.type === 'assert_text')
-        return `assert_text|${step.text ?? ''}|${normalizedDescription}`;
-    if (step.type === 'assert_page')
-        return `assert_page|${JSON.stringify(step.pageExpectation ?? {})}|${normalizedDescription}`;
-    if (step.type === 'select_option')
-        return `select_option|${step.selector ?? ''}|${step.optionLabel ?? step.optionValue ?? step.optionIndex ?? ''}|${normalizedDescription}`;
-    return `${step.type}|${step.selector ?? ''}|${normalizedDescription}`;
-}
-function applyStepSelector(step, selector) {
-    if (!selector)
-        return step;
-    return { ...step, selector };
-}
-function normalizeUrlForComparison(rawUrl) {
-    return rawUrl.trim().replace(/\/+$/, '').toLowerCase();
-}
-function normalizeOutputScale(value) {
-    if (!Number.isFinite(value))
-        return 2;
-    return Math.max(0.5, Math.min(4, Number(value)));
-}
-function normalizeLangTag(value) {
-    if (!value)
-        return null;
-    return value.trim().toLowerCase().replace('_', '-').split('-')[0] || null;
-}
-function normalizeComparableUrl(rawUrl) {
-    return rawUrl.trim().replace(/\/+$/, '').toLowerCase();
-}
-function parseUrlMaybe(rawUrl, base) {
-    try {
-        return new URL(rawUrl, base);
-    }
-    catch {
-        return null;
-    }
-}
-function normalizePathSegments(pathname) {
-    return pathname
-        .split('/')
-        .map((segment) => decodeURIComponent(segment).trim().toLowerCase())
-        .filter(Boolean);
-}
-function stripLocalePrefix(segments) {
-    if (segments.length === 0)
-        return segments;
-    return /^[a-z]{2}(?:-[a-z]{2})?$/i.test(segments[0]) ? segments.slice(1) : segments;
-}
-function routeSegmentMatches(expected, actual) {
-    if (expected === actual)
-        return true;
-    if (actual.startsWith(`${expected}-`) || expected.startsWith(`${actual}-`))
-        return true;
-    return false;
-}
-function pathFamilyMatches(actualPath, expectedPath) {
-    const actualSegments = stripLocalePrefix(normalizePathSegments(actualPath));
-    const expectedSegments = stripLocalePrefix(normalizePathSegments(expectedPath));
-    if (expectedSegments.length === 0)
-        return actualSegments.length === 0;
-    for (let start = 0; start <= actualSegments.length - expectedSegments.length; start += 1) {
-        const matches = expectedSegments.every((segment, index) => routeSegmentMatches(segment, actualSegments[start + index] ?? ''));
-        if (matches)
-            return true;
-    }
-    return false;
-}
-function urlPatternMatches(actualUrl, expected, mode = 'contains') {
-    if (mode === 'equals') {
-        return normalizeComparableUrl(actualUrl) === normalizeComparableUrl(expected);
-    }
-    if (mode === 'regex') {
-        try {
-            return new RegExp(expected).test(actualUrl);
-        }
-        catch {
-            return false;
-        }
-    }
-    if (actualUrl.includes(expected)) {
-        return true;
-    }
-    const actualParsed = parseUrlMaybe(actualUrl);
-    const expectedParsed = parseUrlMaybe(expected, actualUrl);
-    if (!actualParsed || !expectedParsed)
-        return false;
-    const actualHost = actualParsed.hostname.replace(/^www\./, '');
-    const expectedHost = expectedParsed.hostname.replace(/^www\./, '');
-    if (expectedParsed.hostname && actualHost !== expectedHost) {
-        return false;
-    }
-    return pathFamilyMatches(actualParsed.pathname, expectedParsed.pathname);
-}
-function parseHreflangEntry(entry) {
-    const separatorIndex = entry.indexOf(':');
-    if (separatorIndex <= 0)
-        return null;
-    const code = entry.slice(0, separatorIndex).trim();
-    const href = entry.slice(separatorIndex + 1).trim();
-    if (!code || !href)
-        return null;
-    return { code, href };
-}
-function addLocaleActivationCandidate(candidates, url, source, score) {
-    if (!url)
-        return;
-    const parsed = parseUrlMaybe(url);
-    if (!parsed || !/^https?:$/i.test(parsed.protocol))
-        return;
-    const normalized = normalizeComparableUrl(parsed.toString());
-    const existing = candidates.get(normalized);
-    if (!existing || existing.score < score) {
-        candidates.set(normalized, { url: parsed.toString(), source, score });
-    }
-}
-function buildLocalePrefixedUrl(rawUrl, requestedLang) {
-    const parsed = parseUrlMaybe(rawUrl);
-    if (!parsed)
-        return null;
-    const pathname = parsed.pathname || '/';
-    const trailingSlash = pathname.endsWith('/') || pathname === '/';
-    const nextSegments = [requestedLang, ...stripLocalePrefix(normalizePathSegments(pathname))];
-    parsed.pathname = `/${nextSegments.join('/')}${trailingSlash ? '/' : ''}`.replace(/\/{2,}/g, '/');
-    return parsed.toString();
-}
-function buildLocaleQueryUrls(rawUrl, requestedLang) {
-    const parsed = parseUrlMaybe(rawUrl);
-    if (!parsed)
-        return [];
-    const candidates = [];
-    for (const key of ['lang', 'hl', 'locale']) {
-        if (!parsed.searchParams.has(key))
-            continue;
-        const next = new URL(parsed.toString());
-        next.searchParams.set(key, requestedLang);
-        candidates.push(next.toString());
-    }
-    return candidates;
-}
-function collectLocaleActivationCandidates(signals, requestedLang, seedUrls = []) {
-    const lang = normalizeLangTag(requestedLang);
-    const requestedExact = requestedLang?.trim().toLowerCase() ?? null;
-    if (!lang)
-        return [];
-    const candidates = new Map();
-    for (const entry of signals.hreflangs) {
-        const parsedEntry = parseHreflangEntry(entry);
-        if (!parsedEntry)
-            continue;
-        const normalizedCode = normalizeLangTag(parsedEntry.code);
-        if (normalizedCode !== lang)
-            continue;
-        const rawCode = parsedEntry.code.trim().toLowerCase();
-        const score = rawCode === requestedExact ? 120 : rawCode === lang ? 116 : 112;
-        addLocaleActivationCandidate(candidates, parsedEntry.href, `hreflang ${parsedEntry.code}`, score);
-    }
-    for (const rawUrl of [signals.url, signals.canonicalUrl, ...seedUrls]) {
-        if (!rawUrl)
-            continue;
-        addLocaleActivationCandidate(candidates, buildLocalePrefixedUrl(rawUrl, lang), `locale path from ${rawUrl}`, normalizeComparableUrl(rawUrl) === normalizeComparableUrl(signals.url) ? 82 : 76);
-        for (const queryUrl of buildLocaleQueryUrls(rawUrl, lang)) {
-            addLocaleActivationCandidate(candidates, queryUrl, `locale query from ${rawUrl}`, 62);
-        }
-    }
-    return [...candidates.values()].sort((a, b) => b.score - a.score);
-}
-function normalizeVariantToken(value) {
-    return (value ?? '')
-        .normalize('NFD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .replace(/\s+/g, ' ')
-        .trim()
-        .toLowerCase();
-}
-const LANGUAGE_LABEL_ALIASES = {
-    fr: ['fr', 'fr-fr', 'fr_fr', 'france', 'french', 'francais', 'français'],
-    en: ['en', 'en-us', 'en_gb', 'english', 'anglais'],
-    de: ['de', 'de-de', 'de_de', 'german', 'deutsch'],
-    es: ['es', 'es-es', 'es_es', 'spanish', 'espanol', 'español'],
-    it: ['it', 'it-it', 'it_it', 'italian', 'italiano'],
-    pt: ['pt', 'pt-pt', 'pt-br', 'pt_pt', 'pt_br', 'portuguese', 'portugues', 'português'],
-    nl: ['nl', 'nl-nl', 'dutch', 'nederlands'],
-};
-const THEME_LABEL_ALIASES = {
-    light: ['light', 'clair', 'claro', 'hell', 'day'],
-    dark: ['dark', 'sombre', 'oscuro', 'dunkel', 'night'],
-};
-function buildRequestedLanguageTokens(requestedLang) {
-    const lang = normalizeLangTag(requestedLang);
-    if (!lang)
-        return [];
-    const tokens = new Set(LANGUAGE_LABEL_ALIASES[lang] ?? [lang]);
-    tokens.add(lang);
-    if (requestedLang) {
-        tokens.add(normalizeVariantToken(requestedLang));
-        tokens.add(normalizeVariantToken(requestedLang.replace('-', '_')));
-        tokens.add(normalizeVariantToken(requestedLang.replace('_', '-')));
-    }
-    return [...tokens].filter(Boolean);
-}
-function buildRequestedThemeTokens(requestedTheme) {
-    if (!requestedTheme)
-        return [];
-    return [...new Set([requestedTheme, ...THEME_LABEL_ALIASES[requestedTheme]].map(normalizeVariantToken).filter(Boolean))];
-}
-function isLikelyAuthPreparationText(text) {
-    const normalized = normalizeVariantToken(text);
-    if (!normalized)
-        return false;
-    return /\b(sign in|signin|log in|login|authenticate|auth|connexion|connecter|se connecter|mot de passe|password|email)\b/i.test(normalized);
-}
-function urlLooksVariantRelated(rawUrl, requestedLang, requestedTheme) {
-    const parsed = parseUrlMaybe(rawUrl, 'https://example.com');
-    if (!parsed)
-        return false;
-    const localeTokens = buildRequestedLanguageTokens(requestedLang);
-    const themeTokens = buildRequestedThemeTokens(requestedTheme);
-    const urlBits = [
-        parsed.pathname,
-        parsed.search,
-        ...normalizePathSegments(parsed.pathname),
-        ...Array.from(parsed.searchParams.entries()).flatMap(([key, value]) => [key, value]),
-    ]
-        .map((value) => normalizeVariantToken(value))
-        .filter(Boolean);
-    return urlBits.some((bit) => localeTokens.some((token) => bit.includes(token))
-        || themeTokens.some((token) => bit.includes(token))
-        || /\b(lang|locale|language|theme|appearance|mode|color scheme|couleur|langue)\b/.test(bit));
-}
-function stepLooksVariantRelevant(step, requestedLang, requestedTheme) {
-    const localeTokens = buildRequestedLanguageTokens(requestedLang);
-    const themeTokens = buildRequestedThemeTokens(requestedTheme);
-    const genericVariantTokens = [
-        'lang',
-        'language',
-        'locale',
-        'theme',
-        'appearance',
-        'mode',
-        'color scheme',
-        'langue',
-        'theme',
-        'thème',
-        'apparence',
-        'clair',
-        'sombre',
-    ].map(normalizeVariantToken);
-    const textFields = [
-        step.description,
-        step.selector,
-        step.url,
-        step.urlPattern,
-        step.text,
-        step.optionLabel,
-        step.optionValue,
-        step.pageExpectation?.locale,
-        step.pageExpectation?.theme,
-        step.expectedPageAfter?.locale,
-        step.expectedPageAfter?.theme,
-        ...(step.pageExpectation?.urlPatterns ?? []),
-        ...(step.pageExpectation?.textPatterns ?? []),
-        ...(step.pageExpectation?.titlePatterns ?? []),
-        ...(step.expectedPageAfter?.urlPatterns ?? []),
-        ...(step.expectedPageAfter?.textPatterns ?? []),
-        ...(step.expectedPageAfter?.titlePatterns ?? []),
-    ]
-        .filter((value) => typeof value === 'string' && value.trim().length > 0)
-        .map(normalizeVariantToken);
-    const tokenMatch = textFields.some((value) => localeTokens.some((token) => value.includes(token))
-        || themeTokens.some((token) => value.includes(token))
-        || genericVariantTokens.some((token) => token && value.includes(token)));
-    if (tokenMatch)
-        return true;
-    if (step.url && urlLooksVariantRelated(step.url, requestedLang, requestedTheme))
-        return true;
-    if (step.urlPattern && urlLooksVariantRelated(step.urlPattern, requestedLang, requestedTheme))
-        return true;
-    if (textFields.some(isLikelyAuthPreparationText))
-        return true;
-    if (step.pageExpectation?.locale || step.pageExpectation?.theme || step.expectedPageAfter?.locale || step.expectedPageAfter?.theme) {
-        return true;
-    }
-    return false;
-}
-export function sanitizeVariantPrefixSteps(steps, requestedLang, requestedTheme) {
-    return steps.filter((step) => {
-        if (step.type === 'dismiss_overlays' || step.type === 'wait')
-            return true;
-        return stepLooksVariantRelevant(step, requestedLang, requestedTheme);
-    });
-}
-function scoreTokenMatch(text, tokens) {
-    const normalized = normalizeVariantToken(text);
-    if (!normalized || tokens.length === 0)
-        return 0;
-    let score = 0;
-    for (const token of tokens) {
-        if (!token)
-            continue;
-        if (normalized === token)
-            score += 28;
-        else if (normalized.includes(token))
-            score += 18;
-        else if (token.length > 2 && normalized.split(/[^a-z0-9]+/).includes(token))
-            score += 14;
-    }
-    return score;
-}
-function scoreLocaleControl(control, requestedLang) {
-    if (control.kind !== 'locale' || !requestedLang)
-        return 0;
-    const tokens = buildRequestedLanguageTokens(requestedLang);
-    let score = 0;
-    score += scoreTokenMatch(control.label, tokens);
-    score += scoreTokenMatch(control.value ?? '', tokens);
-    score += scoreTokenMatch(control.href ?? '', tokens);
-    if (control.mechanism === 'select')
-        score += 10;
-    if (control.options?.length) {
-        const optionScores = control.options.map((option) => Math.max(scoreTokenMatch(option.label, tokens), scoreTokenMatch(option.value ?? '', tokens)));
-        score += Math.max(0, ...optionScores);
-    }
-    return score;
-}
-function scoreThemeControl(control, requestedTheme) {
-    if (control.kind !== 'theme' || !requestedTheme)
-        return 0;
-    const tokens = buildRequestedThemeTokens(requestedTheme);
-    let score = 0;
-    score += scoreTokenMatch(control.label, tokens);
-    score += scoreTokenMatch(control.value ?? '', tokens);
-    score += scoreTokenMatch(control.href ?? '', tokens);
-    if (control.mechanism === 'toggle')
-        score += 8;
-    if (control.options?.length) {
-        const optionScores = control.options.map((option) => Math.max(scoreTokenMatch(option.label, tokens), scoreTokenMatch(option.value ?? '', tokens)));
-        score += Math.max(0, ...optionScores);
-    }
-    return score;
-}
-function buildRequestedLanguageValues(requestedLang, sample) {
-    const lang = normalizeLangTag(requestedLang);
-    if (!lang)
-        return [];
-    const values = new Set([lang]);
-    if (requestedLang) {
-        const normalized = requestedLang.replace('_', '-');
-        values.add(normalized);
-        values.add(normalized.toLowerCase());
-        values.add(normalized.toUpperCase());
-        values.add(normalized.replace('-', '_'));
-        values.add(normalized.toLowerCase().replace('-', '_'));
-    }
-    const sampleText = sample ?? '';
-    if (/^[A-Z]{2}$/.test(sampleText.trim())) {
-        values.add(lang.toUpperCase());
-    }
-    return [...values].filter(Boolean);
-}
-function buildStorageReplacementCandidates(hint, requestedLang, requestedTheme) {
-    if (hint.kind === 'locale') {
-        return buildRequestedLanguageValues(requestedLang, hint.valueSample);
-    }
-    if (hint.kind === 'theme' && requestedTheme) {
-        return [requestedTheme];
-    }
-    return [];
-}
-async function settleAfterVariantMutation(browser) {
-    const page = browser.currentPage;
-    await page.waitForLoadState('domcontentloaded', { timeout: 3000 }).catch(() => { });
-    await page.waitForLoadState('networkidle', { timeout: 3000 }).catch(() => { });
-    await page.waitForTimeout(350);
-}
-async function tryActivateVariantControl(browser, control, requestedLang, requestedTheme, callbacks) {
-    const page = browser.currentPage;
-    const locator = page.locator(control.selector).first();
-    await locator.waitFor({ state: 'visible', timeout: 3000 });
-    if (control.mechanism === 'select' && control.options?.length) {
-        const scoreOption = (option) => control.kind === 'locale'
-            ? Math.max(scoreTokenMatch(option.label, buildRequestedLanguageTokens(requestedLang)), scoreTokenMatch(option.value ?? '', buildRequestedLanguageTokens(requestedLang)))
-            : Math.max(scoreTokenMatch(option.label, buildRequestedThemeTokens(requestedTheme)), scoreTokenMatch(option.value ?? '', buildRequestedThemeTokens(requestedTheme)));
-        const ranked = control.options
-            .map((option, index) => ({ option, index, score: scoreOption(option) }))
-            .sort((a, b) => b.score - a.score);
-        const best = ranked[0];
-        if (!best || best.score <= 0) {
-            return false;
-        }
-        if (best.option.value) {
-            await locator.selectOption({ value: best.option.value }, { timeout: 4000 });
-        }
-        else {
-            await locator.selectOption({ label: best.option.label }, { timeout: 4000 });
-        }
-        await settleAfterVariantMutation(browser);
-        return true;
-    }
-    try {
-        await locator.click({ timeout: 4000 });
-    }
-    catch (err) {
-        if (control.href && control.mechanism === 'link') {
-            log(`Variant control click failed for ${control.label}; falling back to href navigation ${control.href}.`, 'info', callbacks.onLog);
-            await browser.navigateTo(control.href);
-            return true;
-        }
-        throw err;
-    }
-    await settleAfterVariantMutation(browser);
-    return true;
-}
-async function attemptVariantControlsActivation(browser, requestedLang, requestedTheme, signals, callbacks, depth = 0) {
-    let detected = await detectVariantStateDeterministic(browser, requestedLang, requestedTheme);
-    if ((requestedLang ? detected.lang.active : true) && (requestedTheme ? detected.theme.active : true)) {
-        return { detected };
-    }
-    const rankedControls = signals.variantControls
-        .map((control) => ({
-        control,
-        score: Math.max(!detected.lang.active ? scoreLocaleControl(control, requestedLang) : 0, !detected.theme.active ? scoreThemeControl(control, requestedTheme) : 0),
-    }))
-        .filter((entry) => entry.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, 6);
-    for (const entry of rankedControls) {
-        try {
-            log(`Variant preflight trying ${entry.control.kind} control ${entry.control.selector} (${entry.control.label}).`, 'info', callbacks.onLog);
-            const activated = await tryActivateVariantControl(browser, entry.control, requestedLang, requestedTheme, callbacks);
-            if (!activated)
-                continue;
-            await dismissOverlaysWithLogging(browser, {
-                context: `variant control activation (${entry.control.selector})`,
-                onLog: callbacks.onLog,
-            });
-            detected = await detectVariantStateDeterministic(browser, requestedLang, requestedTheme);
-            if ((requestedLang ? detected.lang.active : true) && (requestedTheme ? detected.theme.active : true)) {
-                log(`Variant preflight activated state via ${entry.control.kind} control ${entry.control.selector}.`, 'success', callbacks.onLog);
-                return { detected, controlUsed: entry.control };
-            }
-            if (depth === 0 && entry.control.mechanism !== 'select') {
-                const nestedSignals = detected.pageSignals;
-                const nestedAttempt = await attemptVariantControlsActivation(browser, requestedLang, requestedTheme, nestedSignals, callbacks, depth + 1);
-                if ((requestedLang ? nestedAttempt.detected.lang.active : true) && (requestedTheme ? nestedAttempt.detected.theme.active : true)) {
-                    return nestedAttempt;
-                }
-                detected = nestedAttempt.detected;
-            }
-        }
-        catch (err) {
-            log(`Variant preflight control activation failed for ${entry.control.selector}: ${err.message}`, 'info', callbacks.onLog);
-        }
-    }
-    return { detected };
-}
-async function writeVariantStorageCandidate(browser, hint, candidateValue) {
-    const page = browser.currentPage;
-    return page.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;
-        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 = (entryKey) => {
-            const lower = entryKey.toLowerCase();
-            return whitelist.some((allowed) => {
-                const normalizedAllowed = allowed.toLowerCase();
-                if (lower === normalizedAllowed)
-                    return true;
-                const re = new RegExp(`(?:^|[^a-zA-Z0-9])${normalizedAllowed.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}(?:$|[^a-zA-Z0-9])`, 'i');
-                return re.test(lower);
-            });
-        };
-        const looksLikeTargetValue = (value) => {
-            if (kind === 'locale') {
-                return /^[a-z]{2,3}(?:[-_][a-zA-Z]{2,4})?$/.test(value.trim());
-            }
-            return /^(light|dark|auto|system|dim|high-contrast|1|0|true|false|enabled|disabled|on|off)$/i.test(value.trim());
-        };
-        const rewrite = (input) => {
-            if (typeof input === 'string') {
-                if (!looksLikeTargetValue(input))
-                    return { changed: false, value: input };
-                return { changed: input !== candidate, value: candidate };
-            }
-            if (Array.isArray(input)) {
-                let changed = false;
-                const next = input.map((entry) => {
-                    const rewritten = rewrite(entry);
-                    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)) {
-                    if (isAllowedKey(entryKey) && typeof entryValue === 'string' && looksLikeTargetValue(entryValue)) {
-                        if (entryValue !== candidate)
-                            changed = true;
-                        next[entryKey] = candidate;
-                        continue;
-                    }
-                    const rewritten = rewrite(entryValue);
-                    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 attemptVariantStorageActivation(browser, requestedLang, requestedTheme, signals, callbacks) {
-    let detected = await detectVariantStateDeterministic(browser, requestedLang, requestedTheme);
-    if ((requestedLang ? detected.lang.active : true) && (requestedTheme ? detected.theme.active : true)) {
-        return { detected };
-    }
-    const rankedHints = signals.storageHints
-        .map((hint) => {
-        const score = hint.kind === 'locale' && !detected.lang.active
-            ? 20 + scoreTokenMatch(`${hint.key} ${hint.valueSample}`, buildRequestedLanguageTokens(requestedLang))
-            : hint.kind === 'theme' && !detected.theme.active
-                ? 20 + scoreTokenMatch(`${hint.key} ${hint.valueSample}`, buildRequestedThemeTokens(requestedTheme))
-                : 0;
-        return { hint, score };
-    })
-        .filter((entry) => entry.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, 6);
-    for (const entry of rankedHints) {
-        const candidates = buildStorageReplacementCandidates(entry.hint, requestedLang, requestedTheme);
-        for (const candidate of candidates) {
-            try {
-                log(`Variant preflight trying ${entry.hint.kind} storage ${entry.hint.storage}.${entry.hint.key}=${candidate}.`, 'info', callbacks.onLog);
-                const written = await writeVariantStorageCandidate(browser, entry.hint, candidate);
-                if (!written)
-                    continue;
-                await browser.currentPage.reload({ waitUntil: 'domcontentloaded', timeout: 15000 }).catch(async () => {
-                    await browser.navigateTo(browser.currentPage.url());
-                });
-                await settleAfterVariantMutation(browser);
-                await dismissOverlaysWithLogging(browser, {
-                    context: `variant storage activation (${entry.hint.storage}.${entry.hint.key})`,
-                    onLog: callbacks.onLog,
-                });
-                detected = await detectVariantStateDeterministic(browser, requestedLang, requestedTheme);
-                if ((requestedLang ? detected.lang.active : true) && (requestedTheme ? detected.theme.active : true)) {
-                    log(`Variant preflight activated state via ${entry.hint.storage}.${entry.hint.key}.`, 'success', callbacks.onLog);
-                    return { detected, storageUsed: entry.hint };
-                }
-            }
-            catch (err) {
-                log(`Variant preflight storage activation failed for ${entry.hint.storage}.${entry.hint.key}: ${err.message}`, 'info', callbacks.onLog);
-            }
-        }
-    }
-    return { detected };
-}
-function isConcreteVariantActivationStep(step) {
-    return step.type === 'navigate'
-        || step.type === 'click'
-        || step.type === 'select_option'
-        || step.type === 'type'
-        || step.type === 'key'
-        || step.type === 'drag';
-}
-async function evaluatePageExpectation(page, signals, expectation) {
-    const reasons = [];
-    let matchedWeight = 0;
-    let totalWeight = 0;
-    const evaluatePatterns = (actualValues, expectedValues, weight, matcher = (actual, expected) => actual.toLowerCase().includes(expected.toLowerCase()), label = 'signal') => {
-        if (!expectedValues || expectedValues.length === 0)
-            return;
-        totalWeight += weight;
-        const expectedHit = expectedValues.some((expected) => actualValues.some((actual) => matcher(actual, expected)));
-        if (expectedHit) {
-            matchedWeight += weight;
-            reasons.push(`${label} matched`);
-        }
-        else {
-            reasons.push(`${label} missing`);
-        }
-    };
-    evaluatePatterns([signals.url], expectation.urlPatterns, 0.35, (actual, expected) => urlPatternMatches(actual, expected), 'url');
-    evaluatePatterns([signals.title], expectation.titlePatterns, 0.15, undefined, 'title');
-    if (expectation.textPatterns && expectation.textPatterns.length > 0) {
-        totalWeight += 0.2;
-        let textHit = expectation.textPatterns.some((expected) => [signals.visibleText, ...signals.headings].some((actual) => actual.toLowerCase().includes(expected.toLowerCase())));
-        if (!textHit) {
-            for (const expected of expectation.textPatterns) {
-                try {
-                    const domState = await queryNamedTargetDomState(page, expected, false, 'dry_run');
-                    if (domState.found && domState.visible) {
-                        textHit = true;
-                        reasons.push('text matched via visible DOM');
-                        break;
-                    }
-                }
-                catch {
-                    // Fall through to body-text fallback.
-                }
-            }
-        }
-        if (!textHit) {
-            try {
-                const bodyText = await page.evaluate(() => document.body?.innerText ?? '');
-                textHit = expectation.textPatterns.some((expected) => matchStringWithMode(bodyText, expected, 'contains'));
-                if (textHit) {
-                    reasons.push('text matched via body text');
-                }
-            }
-            catch {
-                // Ignore and keep mismatch below.
-            }
-        }
-        if (textHit) {
-            matchedWeight += 0.2;
-            if (!reasons.some((reason) => reason.startsWith('text matched'))) {
-                reasons.push('text matched');
-            }
-        }
-        else {
-            reasons.push('text missing');
-        }
-    }
-    evaluatePatterns(signals.navLabels, expectation.navPatterns, 0.08, undefined, 'nav');
-    evaluatePatterns(signals.breadcrumbLabels, expectation.breadcrumbPatterns, 0.07, undefined, 'breadcrumb');
-    if (expectation.locale) {
-        totalWeight += 0.1;
-        const locale = scoreLocaleSignals(signals, expectation.locale);
-        if (locale.score >= 0.6) {
-            matchedWeight += 0.1;
-            reasons.push(`locale ok (${locale.reasons.join(', ') || expectation.locale})`);
-        }
-        else {
-            reasons.push(`locale weak (${locale.reasons.join(', ') || expectation.locale})`);
-        }
-    }
-    if (expectation.theme) {
-        totalWeight += 0.05;
-        const themeState = evaluateRequestedThemeState(signals, expectation.theme);
-        if (themeState.active) {
-            matchedWeight += 0.05;
-            reasons.push(`theme ok (${themeState.reason})`);
-        }
-        else {
-            reasons.push(`theme expected ${expectation.theme}, got ${themeState.detected ?? 'unknown'} (${themeState.reason})`);
-        }
-    }
-    if (expectation.selectors && expectation.selectors.length > 0) {
-        totalWeight += 0.15;
-        let selectorHit = false;
-        for (const selector of expectation.selectors) {
-            try {
-                if (await page.locator(selector).first().isVisible({ timeout: 800 })) {
-                    selectorHit = true;
-                    break;
-                }
-            }
-            catch {
-                // Try next selector candidate.
-            }
-        }
-        if (selectorHit) {
-            matchedWeight += 0.15;
-            reasons.push('selector matched');
-        }
-        else {
-            reasons.push('selector missing');
-        }
-    }
-    const confidence = totalWeight > 0 ? matchedWeight / totalWeight : 0;
-    const threshold = expectation.minConfidence ?? 0.65;
-    return {
-        ok: confidence >= threshold,
-        confidence,
-        reasons,
-    };
-}
-// Tested only against step.description (planner-controlled text).
-const VIDEO_DANGEROUS_ACTION_RE = /\b(delete|remove|destroy|deactivate|disable|disconnect|unlink|revoke|archive|trash|wipe|terminate|logout|log out|sign out|buy|purchase|checkout|pay|order|book|subscribe|upgrade|upload|import|publish|post|share|invite|merge|commit|save|confirm|approve)\b/i;
-// Tested against content fields (selector, text, url, optionLabel) — only truly destructive words
-// to avoid false positives from product names like "good buy" or URLs containing "book".
-const VIDEO_DANGEROUS_CONTENT_RE = /\b(delete|remove|destroy|wipe|terminate|trash|deactivate|disable|disconnect|revoke|archive|logout|log out|sign out)\b/i;
-const VIDEO_DRAG_HINT_RE = /\b(slider|compare|comparison|before|after|timeline|scrubber|handle|split|reveal)\b/i;
-const MAX_VIDEO_TEXT_LENGTH = 256;
-function resolveCredentialTemplates(value, credentials) {
-    if (!value)
-        return value;
-    const replacements = {
-        loginUrl: credentials?.loginUrl,
-        email: credentials?.email,
-        password: credentials?.password,
-    };
-    return value.replace(/\{\{credential\.(loginUrl|email|password)\}\}/g, (match, key) => {
-        const replacement = replacements[key];
-        return typeof replacement === 'string' ? replacement : match;
-    });
-}
-function ensureNoCredentialTemplate(field, value) {
-    if (value && /\{\{credential\.(loginUrl|email|password)\}\}/.test(value)) {
-        throw new Error(`Missing credential value for ${field}`);
-    }
-}
-function resolveStepCredentials(step, credentials) {
-    const resolved = {
-        ...step,
-        url: resolveCredentialTemplates(step.url, credentials),
-        urlPattern: resolveCredentialTemplates(step.urlPattern, credentials),
-        text: resolveCredentialTemplates(step.text, credentials),
-    };
-    ensureNoCredentialTemplate('step.url', resolved.url);
-    ensureNoCredentialTemplate('step.urlPattern', resolved.urlPattern);
-    ensureNoCredentialTemplate('step.text', resolved.text);
-    return resolved;
-}
-function shouldCaptureVideoStepReaction(step) {
-    return step.type === 'navigate'
-        || step.type === 'click'
-        || step.type === 'select_option'
-        || step.type === 'scroll'
-        || step.type === 'hover'
-        || step.type === 'drag'
-        || step.type === 'key';
-}
-function shouldRequireVideoStepReaction(step) {
-    // scroll and drag are excluded: a scroll to an already-visible element or
-    // a drag on a static handle may produce no observable change — that's not an error.
-    return step.type === 'navigate'
-        || step.type === 'click'
-        || step.type === 'select_option';
-}
-function getVideoStepReactionOptions(step) {
-    switch (step.type) {
-        case 'navigate':
-            return { timeoutMs: 2000, settleMs: 300 };
-        case 'click':
-        case 'select_option':
-        case 'key':
-            return { timeoutMs: 1500, settleMs: 250 };
-        case 'scroll':
-        case 'drag':
-            return { timeoutMs: 1200, settleMs: 200 };
-        case 'hover':
-            return { timeoutMs: 800, settleMs: 200 };
-        default:
-            return { timeoutMs: 1200, settleMs: 200 };
-    }
-}
-export async function evaluateVideoStepSafety(step, config, page, currentUrl, interactiveElements) {
-    let activeStep;
-    try {
-        activeStep = specializeStepSelectorForIntent(resolveStepCredentials(step, config.credentials));
-    }
-    catch (err) {
-        return {
-            allowed: false,
-            reason: err.message,
-        };
-    }
-    const actionIntent = (activeStep.description ?? '').toLowerCase();
-    const contentIntent = [
-        activeStep.selector,
-        activeStep.toSelector,
-        activeStep.text,
-        activeStep.url,
-        activeStep.urlPattern,
-        activeStep.optionLabel,
-        activeStep.optionValue,
-    ]
-        .filter(Boolean)
-        .join(' ')
-        .toLowerCase();
-    const descriptionRiskApplies = !(activeStep.type === 'scroll'
-        || activeStep.type === 'highlight'
-        || activeStep.type === 'hover'
-        || activeStep.type === 'wait'
-        || activeStep.type === 'assert_url'
-        || activeStep.type === 'assert_text'
-        || activeStep.type === 'assert_element'
-        || activeStep.type === 'assert_page');
-    if (descriptionRiskApplies && VIDEO_DANGEROUS_ACTION_RE.test(actionIntent)) {
-        return {
-            allowed: false,
-            reason: `Blocked by video safety policy: step description appears mutating or high-risk (${activeStep.description}).`,
-        };
-    }
-    if (VIDEO_DANGEROUS_CONTENT_RE.test(contentIntent)) {
-        return {
-            allowed: false,
-            reason: `Blocked by video safety policy: step content appears destructive (${activeStep.description}).`,
-        };
-    }
-    const actionContext = {
-        rootUrl: config.url,
-        currentUrl,
-        credentials: config.credentials,
-        interactiveElements,
-        currentLang: config.lang,
-        currentTheme: config.theme,
-    };
-    if (activeStep.type === 'navigate') {
-        const decision = evaluateActionSecurity('navigate_to', { url: activeStep.url }, actionContext);
-        return decision.allowed
-            ? { allowed: true }
-            : { allowed: false, reason: decision.reason ?? 'Blocked by navigation policy.' };
-    }
-    if (activeStep.type === 'click' || activeStep.type === 'hover') {
-        const target = await inspectVideoTarget(page, activeStep.selector, activeStep.coordinates);
-        // If the target can't be resolved yet (e.g. inside a popover that hasn't rendered),
-        // allow the step — executePlanStep has retries and fallbacks to find it later.
-        // Only block if the target IS resolved and the security check flags it as dangerous.
-        if (!target)
-            return { allowed: true };
-        const decision = evaluateResolvedActionSecurity(activeStep.type === 'hover' ? 'hover' : 'click', {
-            selector: activeStep.selector,
-            x: activeStep.coordinates?.x,
-            y: activeStep.coordinates?.y,
-        }, actionContext, target);
-        return decision.allowed
-            ? { allowed: true }
-            : { allowed: false, reason: decision.reason ?? 'Blocked by video interaction policy.' };
-    }
-    if (activeStep.type === 'key') {
-        const decision = evaluateActionSecurity('press_key', { key: activeStep.key }, actionContext);
-        return decision.allowed
-            ? { allowed: true }
-            : { allowed: false, reason: decision.reason ?? `Blocked by video safety policy: keyboard key "${activeStep.key ?? ''}" is not allowed.` };
-    }
-    if (activeStep.type === 'type') {
-        const text = activeStep.text ?? '';
-        if (text.length > MAX_VIDEO_TEXT_LENGTH) {
-            return {
-                allowed: false,
-                reason: `Blocked by video safety policy: typed text exceeds ${MAX_VIDEO_TEXT_LENGTH} characters.`,
-            };
-        }
-        if (/[\r\n]/.test(text)) {
-            return {
-                allowed: false,
-                reason: 'Blocked by video safety policy: multi-line text entry is not allowed.',
-            };
-        }
-        const target = await inspectVideoTarget(page, activeStep.selector, activeStep.coordinates);
-        const decision = evaluateResolvedActionSecurity('type_text', {
-            selector: activeStep.selector,
-            x: activeStep.coordinates?.x,
-            y: activeStep.coordinates?.y,
-            text,
-        }, actionContext, target);
-        return decision.allowed
-            ? { allowed: true }
-            : { allowed: false, reason: decision.reason ?? 'Blocked by video typing policy.' };
-    }
-    if (activeStep.type === 'select_option') {
-        const target = await inspectVideoTarget(page, activeStep.selector, activeStep.coordinates);
-        const decision = evaluateResolvedActionSecurity('select_option', {
-            selector: activeStep.selector,
-            optionLabel: activeStep.optionLabel,
-            optionValue: activeStep.optionValue,
-            optionIndex: activeStep.optionIndex,
-        }, actionContext, target);
-        return decision.allowed
-            ? { allowed: true }
-            : { allowed: false, reason: decision.reason ?? 'Blocked by video select policy.' };
-    }
-    if (activeStep.type === 'drag') {
-        const dragIntent = [actionIntent, contentIntent].join(' ');
-        if (!VIDEO_DRAG_HINT_RE.test(dragIntent)) {
-            return {
-                allowed: false,
-                reason: 'Blocked by video safety policy: drag is reserved for visual sliders or comparison reveals.',
-            };
-        }
-        if ((!activeStep.selector && !activeStep.coordinates) || (!activeStep.toSelector && !activeStep.toCoordinates)) {
-            return {
-                allowed: false,
-                reason: 'Blocked by video safety policy: drag requires a valid start and end target.',
-            };
-        }
-    }
-    return { allowed: true };
-}
-function matchStringWithMode(actual, expected, mode = 'contains') {
-    const normalize = (value) => value
-        .normalize('NFKC')
-        .replace(/[\u200b-\u200d\ufeff]/g, '')
-        .replace(/[\u00a0\u202f]/g, ' ')
-        .replace(/[’‘]/g, "'")
-        .replace(/\s+/g, ' ')
-        .trim()
-        .toLowerCase();
-    if (mode === 'equals')
-        return normalize(actual) === normalize(expected);
-    if (mode === 'contains')
-        return normalize(actual).includes(normalize(expected));
-    try {
-        return new RegExp(expected).test(actual);
-    }
-    catch {
-        return false;
-    }
-}
-function extractDescriptionEntityPhrases(description) {
-    if (!description)
-        return [];
-    const matches = [
-        ...Array.from(description.matchAll(/\b(?:open|click|highlight|hover|verify|scroll(?:\s+\w+){0,2}\s+to|go to|reveal)\s+(?:the\s+)?([a-z0-9][a-z0-9+.\-/'’]*(?:\s+[a-z0-9][a-z0-9+.\-/'’]*){0,4})\s+(?:page|section|link|button|tab|card)\b/gi)).map((match) => match[1]?.trim() ?? ''),
-        ...Array.from(description.matchAll(/\b(?:ouvrir|cliquer(?:\s+sur)?|survoler|v[eé]rifier|faire\s+d[eé]filer(?:\s+jusqu['’](?:a|à)|\s+jusqu(?:e)?\s+(?:a|à))?|aller(?:\s+vers)?|r[eé]v[eé]ler)\s+(?:la\s+|le\s+|les\s+)?(?:section|page|onglet|carte|lien|bouton)\s+([a-z0-9][a-z0-9+.\-/'’]*(?:\s+[a-z0-9][a-z0-9+.\-/'’]*){0,5})\b/gi)).map((match) => match[1]?.trim() ?? ''),
-    ];
-    return dedupeSelectors(matches)
-        .filter((value) => value.length >= 3);
-}
-function extractQuotedPhrases(text) {
-    if (!text)
-        return [];
-    return Array.from(text.matchAll(/(?:^|[\s([{"“”«»,:;])(["'])([^"'“”«»]{3,}?)\1(?=$|[\s)\]}“”«».,!?;:])/g))
-        .map((match) => match[2]?.trim() ?? '')
-        .filter((value) => value.length >= 3);
-}
-export function extractNamedScrollTarget(description) {
-    if (!description)
-        return null;
-    const quoted = extractQuotedPhrases(description)[0];
-    if (quoted)
-        return quoted;
-    const patterns = [
-        /\b(?:scroll(?:\s+\w+){0,2}\s+to|go to)\s+(?:the\s+)?(?:section\s+)?([a-z0-9][a-z0-9\s+.\-/'’]{2,80}?)(?:\s+section)?(?:[.!?,:;]|$)/i,
-        /\b(?:faire\s+d[eé]filer|aller)\s+(?:jusqu['’](?:a|à)|jusqu(?:e)?\s+(?:a|à)|vers)\s+(?:la\s+|le\s+)?(?:section\s+)?([a-z0-9][a-z0-9\s+.\-/'’]{2,80})(?:[.!?,:;]|$)/i,
-        /\b(?:section|rubrique)\s+([a-z0-9][a-z0-9\s+.\-/'’]{2,80})(?:[.!?,:;]|$)/i,
-    ];
-    for (const pattern of patterns) {
-        const match = description.match(pattern);
-        const raw = match?.[1]?.trim();
-        if (!raw)
-            continue;
-        const cleaned = raw
-            .replace(/^(?:see|view|reach)\s+(?:the\s+)?/i, '')
-            .replace(/^(?:la|le|les|the)\s+/i, '')
-            .replace(/\s+(?:section|rubrique)$/i, '')
-            .trim();
-        if (cleaned.length >= 3)
-            return cleaned;
-    }
-    return null;
-}
-function resolveNamedScrollTarget(step) {
-    const direct = extractNamedScrollTarget(step.description);
-    if (direct)
-        return direct;
-    const intentFallback = extractDescriptionEntityPhrases(step.description)[0];
-    return intentFallback?.trim() || null;
-}
-async function queryNamedTargetDomState(page, target, scrollIntoView, mode) {
-    const trimmedTarget = target.trim();
-    if (!trimmedTarget)
-        return { found: false, visible: false };
-    return page.evaluate(({ namedTarget, smooth, shouldScroll }) => {
-        const normalize = (value) => value
-            .normalize('NFD')
-            .replace(/[\u0300-\u036f]/g, '')
-            .replace(/[\u00a0\u202f]/g, ' ')
-            .replace(/[’‘]/g, "'")
-            .replace(/\s+/g, ' ')
-            .trim()
-            .toLowerCase();
-        const needle = normalize(namedTarget);
-        if (!needle)
-            return { found: false, visible: false };
-        const needleTokens = needle.split(' ').filter((token) => token.length > 2);
-        const needlePhrases = needleTokens.length >= 2
-            ? Array.from({ length: needleTokens.length - 1 }, (_, index) => `${needleTokens[index]} ${needleTokens[index + 1]}`)
-            : [];
-        const viewportHeight = window.innerHeight;
-        const viewportWidth = window.innerWidth;
-        const viewportCenterX = viewportWidth / 2;
-        const detectOcclusionInsets = () => {
-            let top = 0;
-            let bottom = 0;
-            for (const node of Array.from(document.body?.querySelectorAll('*') ?? [])) {
-                if (!(node instanceof HTMLElement))
-                    continue;
-                const style = window.getComputedStyle(node);
-                if (style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity || '1') === 0) {
-                    continue;
-                }
-                if (style.position !== 'fixed' && style.position !== 'sticky')
-                    continue;
-                if (node.getAttribute('aria-hidden') === 'true')
-                    continue;
-                const rect = node.getBoundingClientRect();
-                if (rect.width <= 0 || rect.height <= 0)
-                    continue;
-                if (rect.width < viewportWidth * 0.35)
-                    continue;
-                if (rect.left > viewportCenterX || rect.right < viewportCenterX)
-                    continue;
-                if (rect.height > viewportHeight * 0.35)
-                    continue;
-                if (rect.top <= 24 && rect.bottom > 0) {
-                    top = Math.max(top, rect.bottom);
-                }
-                if (rect.bottom >= viewportHeight - 24 && rect.top < viewportHeight) {
-                    bottom = Math.max(bottom, viewportHeight - rect.top);
-                }
-            }
-            return { top, bottom };
-        };
-        const isRenderable = (element) => {
-            if (element.getAttribute('aria-hidden') === 'true')
-                return false;
-            const style = window.getComputedStyle(element);
-            if (style.display === 'none' ||
-                style.visibility === 'hidden' ||
-                style.contentVisibility === 'hidden' ||
-                parseFloat(style.opacity || '1') === 0) {
-                return false;
-            }
-            const rect = element.getBoundingClientRect();
-            return rect.width > 0 && rect.height > 0;
-        };
-        const root = document.querySelector('main') ?? document.body ?? document.documentElement;
-        const candidates = [];
-        const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
-        let current = walker.currentNode;
-        while (current) {
-            if (current instanceof HTMLElement &&
-                isRenderable(current) &&
-                current.tagName !== 'SCRIPT' &&
-                current.tagName !== 'STYLE' &&
-                current.tagName !== 'NOSCRIPT' &&
-                current.tagName !== 'TEMPLATE') {
-                candidates.push(current);
-            }
-            current = walker.nextNode();
-        }
-        const rootText = normalize((root.textContent ?? '').slice(0, 200000));
-        const rootContainsNeedle = rootText.includes(needle);
-        let bestMatch = null;
-        for (const candidate of candidates) {
-            const text = normalize(candidate.textContent ?? '');
-            if (!text)
-                continue;
-            const exactTextMatch = text.includes(needle);
-            const tokenHits = needleTokens.filter((token) => text.includes(token)).length;
-            const phraseHits = needlePhrases.filter((phrase) => text.includes(phrase)).length;
-            const partialMatchThreshold = Math.max(2, Math.ceil(needleTokens.length * 0.55));
-            if (!exactTextMatch && phraseHits === 0 && tokenHits < partialMatchThreshold)
-                continue;
-            const rect = candidate.getBoundingClientRect();
-            const isHeading = /^H[1-6]$/.test(candidate.tagName) || candidate.getAttribute('role') === 'heading';
-            const isSectionLike = /^(SECTION|ARTICLE|ASIDE)$/i.test(candidate.tagName)
-                || candidate.getAttribute('role') === 'region';
-            const sectionAncestor = candidate.closest('section,article,[role="region"]');
-            const tagName = candidate.tagName.toUpperCase();
-            const isGenericContainer = tagName === 'MAIN' || tagName === 'BODY' || tagName === 'HTML';
-            const isMassiveContainer = rect.height > viewportHeight * 1.6
-                || text.length > Math.max(needle.length * 24, 2400);
-            if (isGenericContainer)
-                continue;
-            if (isMassiveContainer && !isHeading && !isSectionLike)
-                continue;
-            const exactMatch = exactTextMatch && (text === needle || text.startsWith(`${needle} `));
-            const textLengthPenalty = Math.min(18, text.length / Math.max(needle.length, 1));
-            const proximityPenalty = Math.abs(rect.top) / 2000;
-            const score = (exactMatch ? 16 : 0) +
-                (exactTextMatch ? 10 : 0) +
-                (isHeading ? 10 : 0) +
-                (isSectionLike ? 6 : 0) +
-                (sectionAncestor ? 5 : 0) +
-                phraseHits * 4 +
-                tokenHits +
-                (isMassiveContainer ? 4 : 0) -
-                textLengthPenalty -
-                proximityPenalty;
-            if (!bestMatch || score > bestMatch.score) {
-                bestMatch = { element: candidate, score };
-            }
-        }
-        if (!bestMatch) {
-            return { found: rootContainsNeedle, visible: false };
-        }
-        const { top: topInset, bottom: bottomInset } = detectOcclusionInsets();
-        const topSafeY = topInset + 16;
-        const bottomSafeY = viewportHeight - bottomInset - 16;
-        const isInViewport = (rect) => {
-            if (rect.width <= 0 ||
-                rect.height <= 0 ||
-                rect.bottom <= topSafeY ||
-                rect.right <= 0 ||
-                rect.top >= bottomSafeY ||
-                rect.left >= window.innerWidth) {
-                return false;
-            }
-            const visibleHeight = Math.min(rect.bottom, bottomSafeY) - Math.max(rect.top, topSafeY);
-            const minVisibleHeight = Math.min(Math.max(28, rect.height * 0.45), Math.max(28, rect.height - 4));
-            return visibleHeight >= minVisibleHeight;
-        };
-        const anchor = bestMatch.element;
-        const beforeRect = anchor.getBoundingClientRect();
-        if (shouldScroll && !isInViewport(beforeRect)) {
-            const desiredTop = Math.max(0, topSafeY);
-            const targetTop = Math.max(0, Math.round(window.scrollY + beforeRect.top - desiredTop));
-            window.scrollTo({ top: targetTop, behavior: smooth ? 'smooth' : 'instant' });
-        }
-        const afterRect = anchor.getBoundingClientRect();
-        return { found: true, visible: isInViewport(afterRect) };
-    }, { namedTarget: trimmedTarget, smooth: mode === 'recording', shouldScroll: scrollIntoView });
-}
-async function scrollNamedTargetIntoViewFromDom(page, target, mode) {
-    const state = await queryNamedTargetDomState(page, target, true, mode);
-    return state.found;
-}
-/**
- * Extract target text hints from a step description.
- * E.g. "Click 'Nouveau preset'" → ["Nouveau preset"]
- * E.g. "Click top 'New' / 'Nouveau' button" → ["New", "Nouveau"]
- */
-function extractDescriptionTextHints(description) {
-    const matches = Array.from(description.matchAll(/[''""]([^''"]+)[''""]/g));
-    return matches.map(m => m[1]).filter(Boolean);
-}
-/**
- * Find an interactive element on the live page by matching its visible text
- * against the step description — same approach as the screenshot agent.
- *
- * Uses `browser.getInteractiveElements()` to see the real DOM (including
- * popovers, modals, dropdowns that appeared after previous interactions).
- */
-async function findElementByDescription(browser, description) {
-    if (!description)
-        return null;
-    const textHints = extractDescriptionTextHints(description);
-    if (textHints.length === 0)
-        return null;
-    const elements = await browser.getInteractiveElements();
-    const viewport = browser.currentPage.viewportSize();
-    // Score each visible element by text similarity to the description hints
-    let bestMatch = null;
-    for (const el of elements) {
-        if (!el.visible || !el.boundingBox)
-            continue;
-        const elText = (el.text || el.ariaLabel || '').toLowerCase().trim();
-        if (!elText)
-            continue;
-        let score = 0;
-        for (const hint of textHints) {
-            const hintLower = hint.toLowerCase();
-            if (elText === hintLower) {
-                score += 100; // Exact match
-            }
-            else if (elText.includes(hintLower)) {
-                score += 60; // Contains
-            }
-            else if (hintLower.includes(elText)) {
-                score += 40; // Hint contains element text
-            }
-        }
-        if (score === 0)
-            continue;
-        // Prefer visible, in-viewport elements
-        const bb = el.boundingBox;
-        const cx = bb.x + bb.width / 2;
-        const cy = bb.y + bb.height / 2;
-        if (viewport && (cx < 0 || cy < 0 || cx > viewport.width || cy > viewport.height)) {
-            score -= 20; // Off-screen penalty
-        }
-        if (!bestMatch || score > bestMatch.score) {
-            bestMatch = { x: cx, y: cy, score };
-        }
-    }
-    return bestMatch;
-}
-function extractSelectorHints(selector, description) {
-    const textHints = Array.from(selector.matchAll(/:has-text\((['"])(.*?)\1\)|text=(['"])(.*?)\3|\[aria-label\*?=(['"]?)([^'"\]]+)\5\]/gi))
-        .map((match) => match[2] || match[4] || match[6] || '')
-        .filter(Boolean);
-    const hrefHints = Array.from(selector.matchAll(/\[href\*?=(['"]?)([^'"\]]+)\1\]/gi))
-        .map((match) => match[2] || '')
-        .filter(Boolean);
-    if (description) {
-        const quoted = extractQuotedPhrases(description);
-        textHints.push(...quoted);
-        textHints.push(...extractDescriptionEntityPhrases(description));
-    }
-    return {
-        textHints: dedupeSelectors(textHints),
-        hrefHints: dedupeSelectors(hrefHints),
-    };
-}
-function escapeSelectorText(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"');
-}
-function sanitizeIntentPhrase(value) {
-    return value
-        .trim()
-        .replace(/^[^a-z0-9]+/i, '')
-        .replace(/^(?:see|view|reach)\s+(?:the\s+)?/i, '')
-        .replace(/\b(?:de|du|des|d|le|la|les|the|a|an|to|for|pour|vers|sur|au|aux)\s+/i, '')
-        .replace(/^(?:l|d)['’]/i, '')
-        .replace(/\b(?:page|section|link|button|tab|card|onglet|carte|lien|bouton|rubrique)\b$/i, '')
-        .trim();
-}
-function slugifyIntentValue(value) {
-    return normalizeVariantToken(value)
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-function extractSpecificRouteSlugs(step) {
-    const rawPatterns = [
-        step.url,
-        step.urlPattern,
-        ...(step.pageExpectation?.urlPatterns ?? []),
-        ...(step.expectedPageAfter?.urlPatterns ?? []),
-    ]
-        .filter((value) => !!value);
-    const slugs = [];
-    for (const raw of rawPatterns) {
-        const parsed = parseUrlMaybe(raw, 'https://example.com');
-        const pathname = parsed?.pathname ?? raw;
-        for (const segment of normalizePathSegments(pathname)) {
-            if (segment.length < 3)
-                continue;
-            if (/^[a-z]{2}$/i.test(segment))
-                continue;
-            if (segment === 'iphone' || segment === 'mac' || segment === 'ipad' || segment === 'watch')
-                continue;
-            if (segment.includes('-') || /\d/.test(segment)) {
-                slugs.push(segment);
-            }
-        }
-    }
-    return dedupeSelectors(slugs);
-}
-function isSpecificIntentPhrase(value) {
-    const normalized = normalizeVariantToken(sanitizeIntentPhrase(value));
-    if (!normalized)
-        return false;
-    const tokens = normalized.split(/\s+/).filter(Boolean);
-    const meaningfulTokens = tokens.filter((token) => !/^(?:de|du|des|d|le|la|les|the|a|an|to|for|pour|vers|sur|au|aux|l)$/.test(token));
-    if (meaningfulTokens.length === 0)
-        return false;
-    return /\d/.test(normalized) || normalized.includes('-') || tokens.length >= 2;
-}
-function collectStepIntentTargets(step) {
-    const selectorHints = step.selector ? extractSelectorHints(step.selector, step.description) : { textHints: [], hrefHints: [] };
-    const quoted = step.description
-        ? extractQuotedPhrases(step.description)
-        : [];
-    const expectationPhrases = [
-        ...(step.pageExpectation?.titlePatterns ?? []),
-        ...(step.pageExpectation?.textPatterns ?? []),
-        ...(step.expectedPageAfter?.titlePatterns ?? []),
-        ...(step.expectedPageAfter?.textPatterns ?? []),
-    ];
-    const descriptionEntities = extractDescriptionEntityPhrases(step.description);
-    const phrases = dedupeSelectors([
-        ...quoted,
-        ...descriptionEntities,
-        ...expectationPhrases,
-        ...selectorHints.textHints,
-    ].map(sanitizeIntentPhrase).filter(Boolean)).filter(isSpecificIntentPhrase);
-    const slugs = dedupeSelectors([
-        ...extractSpecificRouteSlugs(step),
-        ...selectorHints.hrefHints.map(slugifyIntentValue),
-        ...phrases.map(slugifyIntentValue),
-    ]).filter((slug) => slug.length >= 3 && (slug.includes('-') || /\d/.test(slug)));
-    return {
-        phrases,
-        slugs,
-        strict: phrases.length > 0 || slugs.length > 0,
-    };
-}
-function selectorPreservesStepIntent(selector, step) {
-    const targets = collectStepIntentTargets(step);
-    if (!targets.strict)
-        return true;
-    const normalizedSelector = normalizeVariantToken(selector);
-    return targets.phrases.some((phrase) => normalizedSelector.includes(normalizeVariantToken(phrase)))
-        || targets.slugs.some((slug) => normalizedSelector.includes(slug));
-}
-function buildIntentSelectorCandidates(step) {
-    const targets = collectStepIntentTargets(step);
-    const selectors = [];
-    if (step.type === 'scroll') {
-        const namedTarget = resolveNamedScrollTarget(step);
-        const phrases = namedTarget ? dedupeSelectors([namedTarget, ...targets.phrases]) : targets.phrases;
-        for (const phrase of phrases) {
-            const escaped = escapeSelectorText(phrase);
-            selectors.push(`section:has-text("${escaped}")`);
-            selectors.push(`main section:has-text("${escaped}")`);
-            selectors.push(`[role="region"]:has-text("${escaped}")`);
-            selectors.push(`h1:has-text("${escaped}")`);
-            selectors.push(`h2:has-text("${escaped}")`);
-            selectors.push(`h3:has-text("${escaped}")`);
-            selectors.push(`p:has-text("${escaped}")`);
-            selectors.push(`text="${escaped}"`);
-        }
-        for (const slug of targets.slugs) {
-            const escaped = escapeSelectorText(slug);
-            selectors.push(`section[id*="${escaped}"]`);
-            selectors.push(`[id*="${escaped}"]`);
-            selectors.push(`[data-testid*="${escaped}"]`);
-            selectors.push(`[href*="${escaped}"]`);
-        }
-        return dedupeSelectors(selectors);
-    }
-    for (const slug of targets.slugs) {
-        const escaped = escapeSelectorText(slug);
-        selectors.push(`a[href*="${escaped}"]`);
-        selectors.push(`[href*="${escaped}"]`);
-        selectors.push(`[data-testid*="${escaped}"]`);
-        selectors.push(`[aria-label*="${escaped}"]`);
-    }
-    for (const phrase of targets.phrases) {
-        const escaped = escapeSelectorText(phrase);
-        selectors.push(`a:has-text("${escaped}")`);
-        selectors.push(`button:has-text("${escaped}")`);
-        // Modern component libraries (cmdk, Radix, Headless UI, etc.) render interactive
-        // items as <div> elements with role attributes or data-cmdk-item. These are not
-        // matched by a: or button: selectors. Add role-based and generic text selectors.
-        selectors.push(`[role="menuitem"]:has-text("${escaped}")`);
-        selectors.push(`[role="option"]:has-text("${escaped}")`);
-        selectors.push(`[role="listitem"]:has-text("${escaped}")`);
-        selectors.push(`[data-cmdk-item]:has-text("${escaped}")`);
-        selectors.push(`[aria-label*="${escaped}"]`);
-        selectors.push(`[title*="${escaped}"]`);
-        // Generic text selector as last resort — Playwright's text= matches any element
-        selectors.push(`text="${escaped}"`);
-    }
-    return dedupeSelectors(selectors);
-}
-function specializeStepSelectorForIntent(step) {
-    if (step.type !== 'click'
-        && step.type !== 'hover'
-        && step.type !== 'highlight'
-        && step.type !== 'assert_element'
-        && step.type !== 'scroll') {
-        return step;
-    }
-    if (!step.selector) {
-        const intentSelectors = buildIntentSelectorCandidates(step);
-        if (intentSelectors.length === 0)
-            return step;
-        return { ...step, selector: intentSelectors.join(', ') };
-    }
-    const originalSelectors = splitSelectorCandidates(step.selector);
-    const intentSelectors = buildIntentSelectorCandidates(step);
-    if (intentSelectors.length === 0)
-        return step;
-    const filteredOriginalSelectors = originalSelectors.filter((selector) => selectorPreservesStepIntent(selector, step));
-    const combined = dedupeSelectors([...intentSelectors, ...filteredOriginalSelectors]);
-    if (combined.length === 0)
-        return step;
-    return { ...step, selector: combined.join(', ') };
-}
-async function getElementCenter(browser, selector, description, mode = 'dry_run') {
-    if (containsInternalAutomationSelector(selector))
-        return null;
-    const page = browser.currentPage;
-    const selectorCandidates = splitSelectorCandidates(selector);
-    const selectors = selectorCandidates.length > 0 ? selectorCandidates : [selector];
-    const { textHints, hrefHints } = extractSelectorHints(selector, description);
-    const viewport = page.viewportSize();
-    const candidateLimit = mode === 'recording' ? 4 : 8;
-    let bestCandidate = null;
-    for (const candidateSelector of selectors) {
-        let locator;
-        try {
-            locator = page.locator(candidateSelector);
-            // Use a short timeout for counting to avoid hanging on complex selectors
-            // that trigger Playwright's auto-waiting in some edge cases.
-            const countPromise = locator.count();
-            const rawCount = await Promise.race([
-                countPromise,
-                new Promise((resolve) => setTimeout(() => resolve(0), 3000)),
-            ]);
-            const count = Math.min(rawCount, candidateLimit);
-            for (let index = 0; index < count; index += 1) {
-                const candidate = locator.nth(index);
-                const meta = await candidate.evaluate((node) => {
-                    if (!(node instanceof HTMLElement))
-                        return null;
-                    const rect = node.getBoundingClientRect();
-                    const style = window.getComputedStyle(node);
-                    const visible = style.display !== 'none'
-                        && style.visibility !== 'hidden'
-                        && parseFloat(style.opacity || '1') > 0
-                        && rect.width > 1
-                        && rect.height > 1;
-                    const text = (node.innerText || node.textContent || node.getAttribute('aria-label') || '').replace(/\s+/g, ' ').trim();
-                    const href = node instanceof HTMLAnchorElement ? node.href : node.getAttribute('href');
-                    return {
-                        rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
-                        visible,
-                        text,
-                        href,
-                        inNav: !!node.closest('nav, header, [role="navigation"]'),
-                        tag: node.tagName.toLowerCase(),
-                    };
-                }).catch(() => null);
-                if (!meta || !meta.visible)
-                    continue;
-                const centerX = meta.rect.x + meta.rect.width / 2;
-                const centerY = meta.rect.y + meta.rect.height / 2;
-                let score = 0;
-                if (viewport) {
-                    const fullyVisible = meta.rect.x >= 0
-                        && meta.rect.y >= 0
-                        && meta.rect.x + meta.rect.width <= viewport.width
-                        && meta.rect.y + meta.rect.height <= viewport.height;
-                    score += fullyVisible ? 16 : 6;
-                }
-                if (meta.inNav)
-                    score += 8;
-                if (meta.tag === 'a')
-                    score += 4;
-                if (meta.rect.width > 600 || meta.rect.height > 180)
-                    score -= 4;
-                const candidateText = `${meta.text || ''}`.toLowerCase();
-                const candidateHref = `${meta.href || ''}`.toLowerCase();
-                for (const hint of textHints) {
-                    const normalizedHint = hint.toLowerCase();
-                    if (!normalizedHint)
-                        continue;
-                    if (candidateText === normalizedHint)
-                        score += 18;
-                    else if (candidateText.includes(normalizedHint))
-                        score += 12;
-                }
-                for (const hint of hrefHints) {
-                    const normalizedHint = hint.toLowerCase();
-                    if (!normalizedHint)
-                        continue;
-                    if (candidateHref.includes(normalizedHint))
-                        score += 14;
-                }
-                if (!bestCandidate || score > bestCandidate.score) {
-                    bestCandidate = { x: centerX, y: centerY, score };
-                }
-            }
-        }
-        catch {
-            // Try next selector candidate.
-        }
-    }
-    if (bestCandidate) {
-        return { x: bestCandidate.x, y: bestCandidate.y };
-    }
-    try {
-        const locator = page.locator(selector).first();
-        await locator.waitFor({ state: 'visible', timeout: pickModeTimeout(mode, 900, 3000) });
-        const box = await locator.boundingBox({ timeout: pickModeTimeout(mode, 700, 1500) });
-        if (!box)
-            return null;
-        return {
-            x: box.x + box.width / 2,
-            y: box.y + box.height / 2,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function inspectVideoTarget(page, selector, coordinates) {
-    const inspectElementHandle = async (element, selectorValue = '') => {
-        return element.evaluate((node, resolvedSelector) => {
-            if (!(node instanceof HTMLElement))
-                return null;
-            const rect = node.getBoundingClientRect();
-            const vw = window.innerWidth;
-            const vh = window.innerHeight;
-            const visibleWidth = Math.max(0, Math.min(rect.right, vw) - Math.max(rect.left, 0));
-            const visibleHeight = Math.max(0, Math.min(rect.bottom, vh) - Math.max(rect.top, 0));
-            const inViewport = visibleWidth > 0 && visibleHeight > 0;
-            const fullyVisible = rect.top >= 0 && rect.left >= 0 && rect.bottom <= vh && rect.right <= vw;
-            const getOwnText = (el) => {
-                let text = '';
-                for (const child of el.childNodes) {
-                    if (child.nodeType === Node.TEXT_NODE) {
-                        text += `${(child.textContent || '').trim()} `;
-                    }
-                }
-                return text.trim();
-            };
-            const text = (() => {
-                if (node.tagName === 'INPUT' || node.tagName === 'TEXTAREA') {
-                    const input = node;
-                    return (input.placeholder || input.value || '').slice(0, 80);
-                }
-                const shallow = getOwnText(node);
-                if (shallow)
-                    return shallow.slice(0, 80);
-                return ((node.textContent || '').trim() || node.getAttribute('title') || node.getAttribute('aria-label') || '').slice(0, 80);
-            })();
-            const role = node.getAttribute('role')
-                || (node.tagName === 'A' ? 'link' : '')
-                || (node.tagName === 'BUTTON' ? 'button' : '')
-                || (node.tagName === 'INPUT' ? `input[${node.type}]` : '')
-                || node.tagName.toLowerCase();
-            const inputType = (node.tagName === 'INPUT' || node.tagName === 'SELECT' || node.tagName === 'TEXTAREA')
-                ? node.type || node.tagName.toLowerCase()
-                : null;
-            return {
-                index: -1,
-                tag: node.tagName.toLowerCase(),
-                role,
-                text,
-                ariaLabel: node.getAttribute('aria-label'),
-                ariaControls: node.getAttribute('aria-controls'),
-                ariaExpanded: node.getAttribute('aria-expanded'),
-                ariaHasPopup: node.getAttribute('aria-haspopup'),
-                href: node.tagName === 'A' ? node.href : null,
-                inputType,
-                boundingBox: {
-                    x: Math.round(rect.x),
-                    y: Math.round(rect.y),
-                    width: Math.round(rect.width),
-                    height: Math.round(rect.height),
-                },
-                selector: resolvedSelector,
-                visible: inViewport,
-                visibilityState: !inViewport ? 'offscreen' : fullyVisible ? 'full' : 'partial',
-            };
-        }, selectorValue);
-    };
-    const inspectNode = async (mode, value) => {
-        return page.evaluate(({ mode, value }) => {
-            const node = mode === 'selector'
-                ? document.querySelector(value)
-                : document.elementFromPoint(value.x, value.y);
-            if (!(node instanceof HTMLElement))
-                return null;
-            const rect = node.getBoundingClientRect();
-            const vw = window.innerWidth;
-            const vh = window.innerHeight;
-            const visibleWidth = Math.max(0, Math.min(rect.right, vw) - Math.max(rect.left, 0));
-            const visibleHeight = Math.max(0, Math.min(rect.bottom, vh) - Math.max(rect.top, 0));
-            const inViewport = visibleWidth > 0 && visibleHeight > 0;
-            const fullyVisible = rect.top >= 0 && rect.left >= 0 && rect.bottom <= vh && rect.right <= vw;
-            const getOwnText = (el) => {
-                let text = '';
-                for (const child of el.childNodes) {
-                    if (child.nodeType === Node.TEXT_NODE) {
-                        text += `${(child.textContent || '').trim()} `;
-                    }
-                }
-                return text.trim();
-            };
-            const text = (() => {
-                if (node.tagName === 'INPUT' || node.tagName === 'TEXTAREA') {
-                    const input = node;
-                    return (input.placeholder || input.value || '').slice(0, 80);
-                }
-                const shallow = getOwnText(node);
-                if (shallow)
-                    return shallow.slice(0, 80);
-                return ((node.textContent || '').trim() || node.getAttribute('title') || node.getAttribute('aria-label') || '').slice(0, 80);
-            })();
-            const role = node.getAttribute('role')
-                || (node.tagName === 'A' ? 'link' : '')
-                || (node.tagName === 'BUTTON' ? 'button' : '')
-                || (node.tagName === 'INPUT' ? `input[${node.type}]` : '')
-                || node.tagName.toLowerCase();
-            const inputType = (node.tagName === 'INPUT' || node.tagName === 'SELECT' || node.tagName === 'TEXTAREA')
-                ? node.type || node.tagName.toLowerCase()
-                : null;
-            return {
-                index: -1,
-                tag: node.tagName.toLowerCase(),
-                role,
-                text,
-                ariaLabel: node.getAttribute('aria-label'),
-                ariaControls: node.getAttribute('aria-controls'),
-                ariaExpanded: node.getAttribute('aria-expanded'),
-                ariaHasPopup: node.getAttribute('aria-haspopup'),
-                href: node.tagName === 'A' ? node.href : null,
-                inputType,
-                boundingBox: {
-                    x: Math.round(rect.x),
-                    y: Math.round(rect.y),
-                    width: Math.round(rect.width),
-                    height: Math.round(rect.height),
-                },
-                selector: mode === 'selector' ? value : '',
-                visible: inViewport,
-                visibilityState: !inViewport ? 'offscreen' : fullyVisible ? 'full' : 'partial',
-            };
-        }, { mode, value });
-    };
-    if (selector) {
-        const selectorCandidates = splitSelectorCandidates(selector);
-        const candidates = selectorCandidates.length > 0 ? selectorCandidates : [selector];
-        for (const candidate of candidates) {
-            try {
-                const locator = page.locator(candidate).first();
-                const count = await locator.count();
-                if (count === 0)
-                    continue;
-                const handle = await locator.elementHandle();
-                if (handle) {
-                    const target = await inspectElementHandle(handle, candidate).catch(() => null);
-                    await handle.dispose().catch(() => { });
-                    if (target)
-                        return target;
-                }
-            }
-            catch {
-                // Fall through to the DOM query fallback below.
-            }
-            const target = await inspectNode('selector', candidate).catch(() => null);
-            if (target)
-                return target;
-        }
-    }
-    if (coordinates) {
-        const target = await inspectNode('coordinates', coordinates).catch(() => null);
-        if (target)
-            return target;
-    }
-    return null;
-}
-// ── Step execution ────────────────────────────────────────────────────
-async function executeAssertStep(browser, step) {
-    if (!isFeatureEnabled('VIDEO_ASSERT_STEPS', true)) {
-        return;
-    }
-    const page = browser.currentPage;
-    const timeoutMs = step.timeoutMs ?? 6000;
-    const deadline = Date.now() + timeoutMs;
-    const waitForCondition = async (predicate, errorMessage) => {
-        while (Date.now() < deadline) {
-            try {
-                if (await predicate())
-                    return;
-            }
-            catch {
-                // Keep retrying until timeout
-            }
-            await page.waitForTimeout(250);
-        }
-        throw new Error(errorMessage);
-    };
-    if (step.type === 'assert_url') {
-        const expected = step.urlPattern ?? step.url ?? '';
-        const mode = step.matchMode ?? 'contains';
-        await waitForCondition(async () => {
-            const currentUrl = page.url();
-            if (mode === 'equals') {
-                return normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(expected);
-            }
-            return urlPatternMatches(currentUrl, expected, mode);
-        }, `assert_url failed (mode=${mode}, expected=${expected}, actual=${page.url()})`);
-        return;
-    }
-    if (step.type === 'assert_text') {
-        const expectedText = step.text ?? '';
-        const mode = step.matchMode ?? 'contains';
-        await waitForCondition(async () => {
-            if (step.scopeSelector) {
-                const locator = page.locator(step.scopeSelector).first();
-                const text = (await locator.innerText({ timeout: 1500 })).trim();
-                return matchStringWithMode(text, expectedText, mode);
-            }
-            const bodyText = await page.evaluate(() => document.body?.innerText ?? '');
-            return matchStringWithMode(bodyText.trim(), expectedText, mode);
-        }, `assert_text failed (mode=${mode}, expected=${expectedText})`);
-        return;
-    }
-    if (step.type === 'assert_element') {
-        if (!step.selector)
-            throw new Error('assert_element step missing selector');
-        const state = step.state ?? 'visible';
-        const locator = page.locator(step.selector).first();
-        await locator.waitFor({ state, timeout: timeoutMs });
-        return;
-    }
-    if (step.type === 'assert_page') {
-        if (!step.pageExpectation)
-            throw new Error('assert_page step missing pageExpectation');
-        await waitForCondition(async () => {
-            const signals = await browser.capturePageSignals();
-            const verdict = await evaluatePageExpectation(page, signals, step.pageExpectation);
-            return verdict.ok;
-        }, (() => {
-            const expectation = JSON.stringify(step.pageExpectation);
-            return `assert_page failed (expectation=${expectation}, actualUrl=${page.url()})`;
-        })());
-        return;
-    }
-    throw new Error(`Unsupported assert step type: ${step.type}`);
-}
-/**
- * Execute a single video step in the browser.
- * In 'dry_run' mode: instant execution (no animation).
- * In 'recording' mode: animated mouse + human-like typing.
- */
-async function executePlanStep(browser, step, mode, currentMousePos, credentials) {
-    const page = browser.currentPage;
-    const activeStep = resolveStepCredentials(step, credentials);
-    // Only capture observation in dry-run mode — reaction checks add latency
-    // (polling every 120ms) with no benefit during recording.
-    const beforeObservation = mode === 'dry_run' && shouldCaptureVideoStepReaction(activeStep)
-        ? await browser.captureObservation().catch(() => null)
-        : null;
-    try {
-        if (activeStep.waitMs && activeStep.type !== 'wait') {
-            await page.waitForTimeout(activeStep.waitMs);
-        }
-        if (containsInternalAutomationSelector(activeStep.selector) || containsInternalAutomationSelector(activeStep.toSelector)) {
-            throw new Error('Internal automation selector is not allowed in executable steps');
-        }
-        if (activeStep.type === 'assert_page' && activeStep.pageExpectation?.selectors?.some((selector) => containsInternalAutomationSelector(selector))) {
-            throw new Error('Internal automation selector is not allowed in assert_page expectations');
-        }
-        if (activeStep.expectedPageAfter?.selectors?.some((selector) => containsInternalAutomationSelector(selector))) {
-            throw new Error('Internal automation selector is not allowed in expectedPageAfter expectations');
-        }
-        switch (activeStep.type) {
-            case 'navigate': {
-                if (!activeStep.url)
-                    throw new Error('navigate step missing url');
-                // In recording mode: skip the navigation if we're already on the target page.
-                // This prevents a visible "refresh" flicker caused by consecutive navigate steps
-                // to the same URL (e.g. when the fixer replaces a highlight with a navigate but
-                // the next step was originally also a navigate to the same destination).
-                if (mode === 'recording') {
-                    const normalizeUrl = (u) => u.toLowerCase().replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/+$/, '').replace(/[?#].*$/, '').trim();
-                    if (normalizeUrl(page.url()) === normalizeUrl(activeStep.url)) {
-                        await page.waitForTimeout(activeStep.postStepWaitMs ?? 500);
-                        break;
-                    }
-                }
-                {
-                    const before = await browser.captureObservation().catch(() => undefined);
-                    await browser.navigateTo(activeStep.url);
-                    await browser.waitForPageReaction(before, {
-                        timeoutMs: activeStep.postStepWaitMs ?? 2500,
-                        settleMs: 350,
-                    });
-                    await dismissOverlaysWithLogging(browser, {
-                        context: `execute step navigate (${activeStep.description})`,
-                    });
-                    break;
-                }
-            }
-            case 'dismiss_overlays': {
-                await browser.dismissOverlays();
-                await page.waitForTimeout(activeStep.postStepWaitMs ?? 600);
-                break;
-            }
-            case 'wait': {
-                // Cap explicit waits in recording mode — the postStepWaitMs on the
-                // preceding action already provides settling time. Long waits were
-                // designed for dry-run verification; in recording they create dead air.
-                const rawWaitMs = activeStep.waitMs ?? 1000;
-                const waitMs = mode === 'recording' ? Math.min(rawWaitMs, 700) : rawWaitMs;
-                await page.waitForTimeout(waitMs);
-                break;
-            }
-            case 'click': {
-                let target = null;
-                if (activeStep.selector) {
-                    // Quick first attempt — if the element is present, find it immediately.
-                    target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    // One retry after a short wait — popovers may take a moment to render.
-                    if (!target) {
-                        await page.waitForTimeout(400);
-                        target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    }
-                }
-                // Fallback: use the same interactive element detection as the screenshot agent.
-                if (!target) {
-                    target = await findElementByDescription(browser, activeStep.description);
-                }
-                if (!target && activeStep.coordinates) {
-                    target = activeStep.coordinates;
-                }
-                if (!target)
-                    throw new Error(`No clickable target found (selector: ${activeStep.selector})`);
-                const before = await browser.captureObservation().catch(() => undefined);
-                if (mode === 'recording') {
-                    await animatedClick(page, target, currentMousePos);
-                }
-                else {
-                    await page.mouse.click(target.x, target.y);
-                }
-                // Dynamic wait — detects when popovers/modals/transitions are truly settled
-                await browser.waitForPageReaction(before, {
-                    timeoutMs: activeStep.postStepWaitMs ?? 1500,
-                    settleMs: 250,
-                });
-                await dismissOverlaysWithLogging(browser, {
-                    context: `execute step click (${activeStep.description})`,
-                });
-                currentMousePos = target;
-                break;
-            }
-            case 'type': {
-                // First click the field (with animation in recording mode)
-                let target = null;
-                if (activeStep.selector) {
-                    target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    if (!target) {
-                        await page.waitForTimeout(mode === 'recording' ? 120 : 400);
-                        target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    }
-                }
-                if (!target && activeStep.coordinates) {
-                    target = activeStep.coordinates;
-                }
-                if (target) {
-                    if (mode === 'recording') {
-                        await animatedClick(page, target, currentMousePos);
-                    }
-                    else {
-                        await page.mouse.click(target.x, target.y);
-                    }
-                    currentMousePos = target;
-                }
-                else if (activeStep.selector) {
-                    // Fallback: use Playwright fill with selector candidates
-                    const selectorCandidates = activeStep.selector
-                        .split(',')
-                        .map((s) => s.trim())
-                        .filter(Boolean);
-                    const fillTargets = selectorCandidates.length > 0 ? selectorCandidates : [activeStep.selector];
-                    let filled = false;
-                    for (const candidate of fillTargets) {
-                        try {
-                            const locator = page.locator(candidate).first();
-                            await locator.waitFor({ state: 'visible', timeout: pickModeTimeout(mode, 1200, 4500) });
-                            await locator.fill(activeStep.text ?? '', { timeout: pickModeTimeout(mode, 1200, 2500) });
-                            filled = true;
-                            break;
-                        }
-                        catch {
-                            // Try next selector candidate
-                        }
-                    }
-                    if (filled) {
-                        const waitMs = activeStep.postStepWaitMs ?? 600;
-                        await page.waitForTimeout(waitMs);
-                        break;
-                    }
-                    throw new Error(`Could not find element to type into (selector: ${activeStep.selector})`);
-                }
-                // Clear existing content and type
-                await page.keyboard.press('Control+A');
-                await page.waitForTimeout(100);
-                if (mode === 'recording' && activeStep.text) {
-                    await humanType(page, activeStep.text);
-                }
-                else if (activeStep.text) {
-                    await page.keyboard.type(activeStep.text);
-                }
-                const waitMs = activeStep.postStepWaitMs ?? 500;
-                await page.waitForTimeout(waitMs);
-                break;
-            }
-            case 'select_option': {
-                if (!activeStep.selector)
-                    throw new Error('select_option step missing selector');
-                const option = typeof activeStep.optionLabel === 'string' ? { label: activeStep.optionLabel }
-                    : typeof activeStep.optionValue === 'string' ? { value: activeStep.optionValue }
-                        : typeof activeStep.optionIndex === 'number' ? { index: activeStep.optionIndex }
-                            : null;
-                if (!option)
-                    throw new Error('select_option step missing optionLabel/optionValue/optionIndex');
-                const locator = page.locator(activeStep.selector).first();
-                await locator.waitFor({ state: 'visible', timeout: pickModeTimeout(mode, 1200, 4500) });
-                try {
-                    await locator.scrollIntoViewIfNeeded({ timeout: pickModeTimeout(mode, 800, 1200) });
-                }
-                catch {
-                    // Non-blocking
-                }
-                if (mode === 'recording') {
-                    const target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    if (target) {
-                        await animatedClick(page, target, currentMousePos);
-                        currentMousePos = target;
-                    }
-                }
-                await locator.selectOption(option, { timeout: pickModeTimeout(mode, 1500, 3000) });
-                await page.waitForTimeout(activeStep.postStepWaitMs ?? 500);
-                break;
-            }
-            case 'scroll': {
-                // During recording, move the cursor to the center of the viewport before scrolling.
-                // Without this, the cursor stays at its previous position (possibly off-screen)
-                // and the viewer doesn't see an active cursor during scroll-only clips.
-                if (mode === 'recording') {
-                    const vpCenter = { x: Math.round(page.viewportSize().width / 2), y: Math.round(page.viewportSize().height / 2) };
-                    await moveMouse(page, currentMousePos, vpCenter, { durationMs: 300 });
-                    currentMousePos = vpCenter;
-                }
-                // If a selector is provided, scroll that element to the center of the viewport.
-                // This is far more precise than guessing pixel amounts.
-                let scrollHandled = false;
-                const namedTarget = resolveNamedScrollTarget(activeStep);
-                const namedSearchSelectors = namedTarget
-                    ? dedupeSelectors(buildIntentSelectorCandidates({ ...activeStep, type: 'scroll' })).slice(0, mode === 'recording' ? 6 : 12)
-                    : [];
-                const namedProbeVisibleTimeout = namedTarget
-                    ? pickModeTimeout(mode, 120, 320)
-                    : pickModeTimeout(mode, 250, 600);
-                const namedProbeWaitMs = namedTarget
-                    ? pickModeTimeout(mode, 220, 320)
-                    : activeStep.postStepWaitMs ?? (mode === 'recording' ? 800 : 400);
-                const isScrollTargetVisible = async (selector) => {
-                    if (namedTarget) {
-                        try {
-                            const domState = await queryNamedTargetDomState(page, namedTarget, false, mode);
-                            if (domState.visible) {
-                                return true;
-                            }
-                        }
-                        catch {
-                            // Fall through to selector-based checks
-                        }
-                    }
-                    const candidates = selector
-                        ? splitSelectorCandidates(selector)
-                        : activeStep.selector
-                            ? splitSelectorCandidates(activeStep.selector)
-                            : [];
-                    const targetCandidates = namedTarget
-                        ? dedupeSelectors([...candidates, ...namedSearchSelectors])
-                        : candidates;
-                    for (const candidate of targetCandidates) {
-                        try {
-                            const locator = page.locator(candidate).first();
-                            if (await locator.isVisible({ timeout: namedProbeVisibleTimeout }) && await isLocatorMeaningfullyInViewport(locator)) {
-                                return true;
-                            }
-                        }
-                        catch {
-                            // Try next candidate
-                        }
-                    }
-                    return false;
-                };
-                if (activeStep.selector) {
-                    const selectorCandidates = splitSelectorCandidates(activeStep.selector);
-                    for (const candidate of selectorCandidates) {
-                        try {
-                            const locator = page.locator(candidate).first();
-                            await locator.waitFor({ state: 'attached', timeout: namedTarget ? pickModeTimeout(mode, 350, 1200) : pickModeTimeout(mode, 1200, 3000) });
-                            const behavior = mode === 'recording' ? 'smooth' : 'instant';
-                            await locator.evaluate((el, b) => {
-                                el.scrollIntoView({ block: 'center', behavior: b });
-                            }, behavior);
-                            await page.waitForTimeout(namedProbeWaitMs);
-                            if (await isScrollTargetVisible(candidate)) {
-                                scrollHandled = true;
-                                break;
-                            }
-                        }
-                        catch {
-                            // Try next candidate
-                        }
-                    }
-                    // Fallback: Playwright's built-in scrollIntoViewIfNeeded
-                    if (!scrollHandled) {
-                        for (const candidate of selectorCandidates) {
-                            try {
-                                const locator = page.locator(candidate).first();
-                                await locator.scrollIntoViewIfNeeded({ timeout: namedTarget ? pickModeTimeout(mode, 350, 1200) : pickModeTimeout(mode, 900, 2000) });
-                                await page.waitForTimeout(namedProbeWaitMs);
-                                if (await isScrollTargetVisible(candidate)) {
-                                    scrollHandled = true;
-                                    break;
-                                }
-                            }
-                            catch {
-                                // Try next candidate
-                            }
-                        }
-                    }
-                }
-                // Text-based fallback: extract quoted section name from description
-                if (!scrollHandled) {
-                    const quotedTarget = extractQuotedPhrases(activeStep.description)[0];
-                    if (quotedTarget) {
-                        try {
-                            const textLocator = page.locator(`text="${quotedTarget}"`).first();
-                            await textLocator.scrollIntoViewIfNeeded({ timeout: namedTarget ? pickModeTimeout(mode, 350, 1200) : pickModeTimeout(mode, 900, 2000) });
-                            await page.waitForTimeout(namedProbeWaitMs);
-                            scrollHandled = await isScrollTargetVisible(`text="${quotedTarget}"`);
-                        }
-                        catch {
-                            // Fall through to pixel scroll
-                        }
-                    }
-                }
-                if (!scrollHandled && namedTarget) {
-                    try {
-                        const domGroundedScroll = await scrollNamedTargetIntoViewFromDom(page, namedTarget, mode);
-                        if (domGroundedScroll) {
-                            await page.waitForTimeout(namedProbeWaitMs);
-                            scrollHandled = await isScrollTargetVisible();
-                        }
-                    }
-                    catch {
-                        // Fall through to incremental search
-                    }
-                }
-                if (!scrollHandled && namedTarget) {
-                    const viewportHeight = page.viewportSize()?.height ?? 900;
-                    const searchDeltaY = Math.round(viewportHeight * (mode === 'recording' ? 1.05 : 0.95));
-                    const scrollMetrics = await page.evaluate(() => ({
-                        scrollY: Math.round(window.scrollY),
-                        maxScrollY: Math.max(0, Math.round(document.documentElement.scrollHeight - window.innerHeight)),
-                    }));
-                    const remainingScroll = Math.max(0, scrollMetrics.maxScrollY - scrollMetrics.scrollY);
-                    const minimumAttempts = mode === 'recording' ? 6 : 10;
-                    const maximumAttempts = mode === 'recording' ? 36 : 48;
-                    const searchAttempts = Math.min(maximumAttempts, Math.max(minimumAttempts, Math.ceil(remainingScroll / Math.max(1, searchDeltaY)) + 1));
-                    const searchScrollPauseMs = mode === 'recording' ? 320 : 220;
-                    for (let searchAttempt = 0; searchAttempt < searchAttempts && !scrollHandled; searchAttempt += 1) {
-                        for (const candidate of namedSearchSelectors) {
-                            try {
-                                const locator = page.locator(candidate).first();
-                                if (await locator.count() === 0)
-                                    continue;
-                                await locator.scrollIntoViewIfNeeded({ timeout: pickModeTimeout(mode, 450, 1200) });
-                                await page.waitForTimeout(namedProbeWaitMs);
-                                if (await isScrollTargetVisible(candidate)) {
-                                    scrollHandled = true;
-                                    break;
-                                }
-                            }
-                            catch {
-                                // Try next selector candidate
-                            }
-                        }
-                        if (scrollHandled)
-                            break;
-                        if (mode === 'recording') {
-                            await page.evaluate(({ deltaY }) => window.scrollBy({ top: deltaY, behavior: 'smooth' }), { deltaY: searchDeltaY });
-                            await page.waitForTimeout(searchScrollPauseMs);
-                        }
-                        else {
-                            await page.evaluate(({ deltaY }) => window.scrollBy(0, deltaY), { deltaY: searchDeltaY });
-                            await page.waitForTimeout(searchScrollPauseMs);
-                        }
-                        if (!scrollHandled) {
-                            try {
-                                const domGroundedScroll = await scrollNamedTargetIntoViewFromDom(page, namedTarget, mode);
-                                if (domGroundedScroll) {
-                                    await page.waitForTimeout(namedProbeWaitMs);
-                                    scrollHandled = await isScrollTargetVisible();
-                                }
-                            }
-                            catch {
-                                // Continue the incremental search.
-                            }
-                        }
-                    }
-                }
-                if (!scrollHandled && namedTarget) {
-                    let diagnostic = '';
-                    try {
-                        const domState = await queryNamedTargetDomState(page, namedTarget, false, mode);
-                        const metrics = await page.evaluate(() => ({
-                            scrollY: Math.round(window.scrollY),
-                            scrollHeight: Math.round(document.documentElement.scrollHeight),
-                            viewportHeight: Math.round(window.innerHeight),
-                        }));
-                        diagnostic = ` (domFound=${domState.found}, domVisible=${domState.visible}, scrollY=${metrics.scrollY}, scrollHeight=${metrics.scrollHeight}, viewportHeight=${metrics.viewportHeight})`;
-                    }
-                    catch {
-                        // Keep the original failure if diagnostic capture fails.
-                    }
-                    throw new Error(`Could not reveal named section target: ${namedTarget}${diagnostic}`);
-                }
-                // Pixel-based scroll (generic scroll with no specific named target)
-                if (!scrollHandled) {
-                    const direction = activeStep.direction ?? 'down';
-                    const amount = activeStep.amount ?? 400;
-                    const dx = direction === 'right' ? amount : direction === 'left' ? -amount : 0;
-                    const dy = direction === 'down' ? amount : direction === 'up' ? -amount : 0;
-                    if (mode === 'recording') {
-                        await page.evaluate(({ deltaX, deltaY }) => {
-                            window.scrollBy({ left: deltaX, top: deltaY, behavior: 'smooth' });
-                        }, { deltaX: dx, deltaY: dy });
-                        await page.waitForTimeout(500);
-                    }
-                    else {
-                        await page.evaluate(({ deltaX, deltaY }) => window.scrollBy(deltaX, deltaY), { deltaX: dx, deltaY: dy });
-                    }
-                    const waitMs = activeStep.postStepWaitMs ?? 500;
-                    await page.waitForTimeout(waitMs);
-                }
-                break;
-            }
-            case 'hover': {
-                let target = null;
-                if (activeStep.selector) {
-                    target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    if (!target) {
-                        await page.waitForTimeout(mode === 'recording' ? 120 : 400);
-                        target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    }
-                }
-                if (!target && activeStep.coordinates) {
-                    target = activeStep.coordinates;
-                }
-                if (!target)
-                    throw new Error(`No hover target found (selector: ${activeStep.selector})`);
-                if (mode === 'recording') {
-                    await animatedHover(page, target, currentMousePos);
-                }
-                else {
-                    await page.mouse.move(target.x, target.y);
-                }
-                currentMousePos = target;
-                const waitMs = activeStep.postStepWaitMs ?? 300;
-                await page.waitForTimeout(waitMs);
-                break;
-            }
-            case 'drag': {
-                let fromTarget = null;
-                let toTarget = null;
-                if (activeStep.selector) {
-                    fromTarget = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                }
-                if (!fromTarget && activeStep.coordinates) {
-                    fromTarget = activeStep.coordinates;
-                }
-                if (activeStep.toSelector) {
-                    toTarget = await getElementCenter(browser, activeStep.toSelector, activeStep.description, mode);
-                }
-                if (!toTarget && activeStep.toCoordinates) {
-                    toTarget = activeStep.toCoordinates;
-                }
-                if (!fromTarget || !toTarget) {
-                    throw new Error('drag step missing a valid start or end target');
-                }
-                if (mode === 'recording') {
-                    await moveMouse(page, currentMousePos, fromTarget, { durationMs: 500 });
-                    await page.waitForTimeout(120);
-                    await page.mouse.down();
-                    await moveMouse(page, fromTarget, toTarget, {
-                        durationMs: activeStep.durationMs ?? 900,
-                        steps: 40,
-                    });
-                    await page.mouse.up();
-                }
-                else {
-                    await page.mouse.move(fromTarget.x, fromTarget.y);
-                    await page.mouse.down();
-                    await page.mouse.move(toTarget.x, toTarget.y, { steps: 10 });
-                    await page.mouse.up();
-                }
-                currentMousePos = toTarget;
-                await page.waitForTimeout(activeStep.postStepWaitMs ?? 700);
-                break;
-            }
-            case 'highlight': {
-                // Like hover, but with a longer pause to draw viewer attention
-                let target = null;
-                if (activeStep.selector) {
-                    target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    if (!target) {
-                        await page.waitForTimeout(mode === 'recording' ? 120 : 300);
-                        target = await getElementCenter(browser, activeStep.selector, activeStep.description, mode);
-                    }
-                }
-                if (!target && activeStep.coordinates) {
-                    target = activeStep.coordinates;
-                }
-                if (!target) {
-                    // Highlight is non-critical — skip silently if target not found
-                    break;
-                }
-                if (mode === 'recording') {
-                    await animatedHover(page, target, currentMousePos);
-                    // Extra pause for emphasis
-                    await page.waitForTimeout(150);
-                }
-                else {
-                    await page.mouse.move(target.x, target.y);
-                }
-                currentMousePos = target;
-                const waitMs = activeStep.postStepWaitMs ?? 400;
-                await page.waitForTimeout(waitMs);
-                break;
-            }
-            case 'key': {
-                if (!activeStep.key)
-                    throw new Error('key step missing key field');
-                await page.keyboard.press(activeStep.key);
-                const waitMs = activeStep.postStepWaitMs ?? 300;
-                await page.waitForTimeout(waitMs);
-                break;
-            }
-            case 'assert_url':
-            case 'assert_text':
-            case 'assert_element':
-            case 'assert_page': {
-                await executeAssertStep(browser, activeStep);
-                break;
-            }
-        }
-        const shouldEnforceExpectedPageAfter = !!activeStep.expectedPageAfter
-            && (activeStep.type === 'navigate'
-                || activeStep.type === 'click'
-                || activeStep.type === 'select_option'
-                || activeStep.type === 'type'
-                || activeStep.type === 'key');
-        if (shouldEnforceExpectedPageAfter && activeStep.expectedPageAfter) {
-            const deadline = Date.now() + (activeStep.timeoutMs ?? pickModeTimeout(mode, 2500, 5000));
-            let verdict = null;
-            while (Date.now() < deadline) {
-                const signals = await browser.capturePageSignals().catch(() => null);
-                if (signals) {
-                    verdict = await evaluatePageExpectation(page, signals, activeStep.expectedPageAfter);
-                    if (verdict.ok) {
-                        break;
-                    }
-                }
-                await page.waitForTimeout(200);
-            }
-            if (!verdict?.ok) {
-                const reason = verdict
-                    ? `Expected destination not reached (confidence=${verdict.confidence.toFixed(2)}; ${verdict.reasons.join(', ')})`
-                    : 'Expected destination not reached';
-                return {
-                    newMousePos: currentMousePos,
-                    error: reason,
-                };
-            }
-        }
-        let reactionSummary;
-        let reactionChanged;
-        if (beforeObservation) {
-            const reaction = await browser.waitForPageReaction(beforeObservation, getVideoStepReactionOptions(activeStep)).catch(() => null);
-            if (reaction) {
-                reactionSummary = reaction.summary;
-                reactionChanged = reaction.changed;
-                if (activeStep.type !== 'navigate' && reaction.before.url !== reaction.after.url) {
-                    const cleanup = await dismissOverlaysWithLogging(browser, {
-                        context: `reaction cleanup (${activeStep.description})`,
-                    });
-                    if (cleanup.dismissed) {
-                        const cleanupReaction = await browser.waitForPageReaction(reaction.after, {
-                            timeoutMs: 1200,
-                            settleMs: 200,
-                        }).catch(() => null);
-                        reactionSummary = cleanupReaction
-                            ? `${reaction.summary}; cleanup: ${cleanupReaction.summary}; page cleanup reapplied after navigation.`
-                            : `${reaction.summary}; page cleanup reapplied after navigation.`;
-                        reactionChanged = reaction.changed || cleanupReaction?.changed || reactionChanged;
-                    }
-                    else {
-                        reactionSummary = `${reaction.summary}; page cleanup checked after navigation.`;
-                    }
-                }
-                if (shouldRequireVideoStepReaction(activeStep) && !reactionChanged) {
-                    return {
-                        newMousePos: currentMousePos,
-                        error: reactionSummary,
-                        reactionSummary,
-                        reactionChanged,
-                    };
-                }
-            }
-        }
-        return { newMousePos: currentMousePos, reactionSummary, reactionChanged };
-    }
-    catch (err) {
-        return {
-            newMousePos: currentMousePos,
-            error: err.message,
-        };
-    }
-}
-function shouldCaptureStepArtifact(config, phase, success) {
-    if (!isFeatureEnabled('VIDEO_DEBUG_ARTIFACTS', true)) {
-        return false;
-    }
-    const mode = config.videoOptions?.debugArtifacts ?? 'failed_only';
-    if (mode === 'off')
-        return false;
-    if (mode === 'all_dry_run')
-        return phase === 'dry_run' || !success;
-    return !success;
-}
-async function executeStepWithDeterministicRecovery(browser, step, options) {
-    throwIfAborted(options.config.abortSignal, 'Video run cancelled.');
-    const page = browser.currentPage;
-    let currentMousePos = options.currentMousePos;
-    let activeStep = specializeStepSelectorForIntent(step);
-    const traces = [];
-    let attemptIndex = 0;
-    const executeAttempt = async (strategy, attemptStep, selector) => {
-        throwIfAborted(options.config.abortSignal, 'Video run cancelled.');
-        const interactiveElements = await browser.getInteractiveElements().catch(() => []);
-        const safetyDecision = await evaluateVideoStepSafety(attemptStep, options.config, page, page.url(), interactiveElements);
-        if (!safetyDecision.allowed) {
-            const trace = {
-                stepId: step.id,
-                stepIndex: options.stepIndex,
-                attemptIndex,
-                strategy,
-                selector,
-                success: false,
-                reason: safetyDecision.reason,
-            };
-            traces.push(trace);
-            options.callbacks.onStepAttempt?.(trace);
-            attemptIndex += 1;
-            return { success: false, reason: safetyDecision.reason };
-        }
-        const shouldCaptureBefore = shouldCaptureStepArtifact(options.config, options.mode, false);
-        const urlBefore = page.url();
-        const beforeScreenshot = shouldCaptureBefore ? await browser.takeScreenshotForAI().catch(() => undefined) : undefined;
-        const execResult = await executePlanStep(browser, attemptStep, options.mode, currentMousePos, options.config.credentials);
-        currentMousePos = execResult.newMousePos;
-        const success = !execResult.error;
-        const reason = execResult.error;
-        const urlAfter = page.url();
-        const trace = {
-            stepId: step.id,
-            stepIndex: options.stepIndex,
-            attemptIndex,
-            strategy,
-            selector,
-            success,
-            reason,
-        };
-        traces.push(trace);
-        options.callbacks.onStepAttempt?.(trace);
-        if (shouldCaptureStepArtifact(options.config, options.mode, success)) {
-            const afterScreenshot = await browser.takeScreenshotForAI().catch(() => undefined);
-            options.callbacks.onStepArtifact?.({
-                runId: options.config.runId,
-                variantId: options.config.variantId,
-                stepId: step.id,
-                stepIndex: options.stepIndex,
-                attemptIndex,
-                phase: options.mode,
-                strategy,
-                urlBefore,
-                urlAfter,
-                selectorUsed: selector,
-                reason,
-                beforeScreenshot,
-                afterScreenshot,
-            });
-            // Emit live preview screenshot for the UI (reuse already-captured screenshot)
-            if (afterScreenshot && options.callbacks.onScreenshot) {
-                options.callbacks.onScreenshot(afterScreenshot.toString('base64'));
-            }
-        }
-        else if (beforeScreenshot && options.callbacks.onScreenshot) {
-            // Reuse the pre-action screenshot for live preview — no extra capture needed
-            options.callbacks.onScreenshot(beforeScreenshot.toString('base64'));
-        }
-        attemptIndex += 1;
-        return { success, reason };
-    };
-    const selectorCandidates = splitSelectorCandidates(activeStep.selector);
-    // Keep the full comma-separated selector list for the primary attempt so that
-    // getElementCenter (inside executePlanStep) can iterate over ALL candidates.
-    // The old behavior of extracting only selectorCandidates[0] caused long timeouts
-    // when the first selector didn't match but an alternative would have worked instantly.
-    const primaryAttempt = await executeAttempt('primary', activeStep, activeStep.selector);
-    if (primaryAttempt.success
-        || !shouldUseDeterministicRecovery(step)
-        || !isFeatureEnabled('VIDEO_DETERMINISTIC_RECOVERY', true)) {
-        return {
-            success: primaryAttempt.success,
-            reason: primaryAttempt.reason,
-            step: activeStep,
-            newMousePos: currentMousePos,
-            traces,
-        };
-    }
-    // The primary attempt already tried ALL selector candidates via getElementCenter.
-    // If it failed, the element is genuinely not in the DOM. Doing more retries with
-    // the same selectors is redundant and wastes tens of seconds per retry cycle.
-    // Only try selector memory fallbacks (from previous runs) and one short wait+retry.
-    // Try selector memory fallbacks (selectors from previous successful runs)
-    const memoryOnlyFallbacks = dedupeSelectors(options.selectorFallbacks ?? [])
-        .filter((selector) => selectorPreservesStepIntent(selector, activeStep)
-        && !selectorCandidates.includes(selector));
-    for (const selector of memoryOnlyFallbacks) {
-        const candidateStep = applyStepSelector(step, selector);
-        const fallbackAttempt = await executeAttempt('selector_fallback', candidateStep, selector);
-        if (fallbackAttempt.success) {
-            return {
-                success: true,
-                step: candidateStep,
-                newMousePos: currentMousePos,
-                traces,
-            };
-        }
-    }
-    // One short wait + retry — the element might appear after a brief animation.
-    await page.waitForTimeout(500);
-    const retryAttempt = await executeAttempt('retry', activeStep, activeStep.selector);
-    return {
-        success: retryAttempt.success,
-        reason: retryAttempt.reason,
-        step: activeStep,
-        newMousePos: currentMousePos,
-        traces,
-    };
-}
-async function captureVideoVerificationArtifacts(browser, callbacks, helperTimeoutMs) {
-    const bundle = await browser.captureVideoVerificationBundle({
-        onRetry: (message) => log(`Verification snapshot retry: ${message}`, 'info', callbacks.onLog),
-        helperTimeoutMs: helperTimeoutMs ?? undefined,
-    });
-    log(`Verification snapshot ready [${bundle.coherenceKey}] @ ${bundle.url}`, 'info', callbacks.onLog);
-    const observationSummary = await captureVideoObservationSummary(bundle, {
-        maxAccessibilityChars: 2200,
-        maxElements: 12,
-        maxVisibleTextChars: 360,
-    });
-    return {
-        bundle,
-        observationSummary,
-        observationSnapshot: buildVideoObservationSnapshot({
-            coherenceKey: bundle.coherenceKey,
-            interactiveElements: bundle.interactiveElements,
-            pageSignals: bundle.pageSignals,
-            pageIdentity: null,
-        }),
-        pageContext: {
-            currentUrl: bundle.url,
-            pageTitle: bundle.title,
-        },
-    };
-}
-export async function verifyVideoStepDeterministically(browser, step) {
-    const page = browser.currentPage;
-    if (step.type === 'assert_text' && !step.scopeSelector && step.text) {
-        try {
-            const domState = await queryNamedTargetDomState(page, step.text, false, 'dry_run');
-            if (domState.found && domState.visible) {
-                return {
-                    ok: true,
-                    reason: `Asserted text "${step.text}" is already visible.`,
-                    usage: {},
-                };
-            }
-        }
-        catch {
-            // Fall through to text matching.
-        }
-        try {
-            const bodyText = await page.evaluate(() => document.body?.innerText ?? '');
-            if (matchStringWithMode(bodyText, step.text, step.matchMode ?? 'contains')) {
-                return {
-                    ok: true,
-                    reason: `Asserted text "${step.text}" already matches the current page.`,
-                    usage: {},
-                };
-            }
-        }
-        catch {
-            // Fall through to the remaining deterministic checks.
-        }
-    }
-    if (step.type === 'assert_url') {
-        const expected = step.urlPattern ?? step.url ?? '';
-        const mode = step.matchMode ?? 'contains';
-        const currentUrl = page.url();
-        const ok = mode === 'equals'
-            ? normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(expected)
-            : urlPatternMatches(currentUrl, expected, mode);
-        if (ok) {
-            return {
-                ok: true,
-                reason: `Current URL already satisfies ${expected}.`,
-                usage: {},
-            };
-        }
-    }
-    if (step.type === 'assert_page' && step.pageExpectation) {
-        const signals = await browser.capturePageSignals().catch(() => null);
-        if (signals) {
-            const verdict = await evaluatePageExpectation(page, signals, step.pageExpectation);
-            if (verdict.ok) {
-                return {
-                    ok: true,
-                    reason: `Page expectation verified deterministically (confidence=${verdict.confidence.toFixed(2)}).`,
-                    usage: {},
-                };
-            }
-        }
-    }
-    if (step.type === 'assert_element' && step.selector) {
-        try {
-            const locator = page.locator(step.selector).first();
-            const state = step.state ?? 'visible';
-            if (state === 'visible' && await locator.isVisible({ timeout: 400 })) {
-                return {
-                    ok: true,
-                    reason: `Element ${step.selector} is visible.`,
-                    usage: {},
-                };
-            }
-        }
-        catch {
-            // Fall through to the remaining deterministic checks.
-        }
-    }
-    const namedTarget = step.type === 'scroll' ? resolveNamedScrollTarget(step) : null;
-    if (namedTarget) {
-        try {
-            const domState = await queryNamedTargetDomState(page, namedTarget, false, 'dry_run');
-            if (domState.found && domState.visible) {
-                return {
-                    ok: true,
-                    reason: `Named scroll target "${namedTarget}" is visible.`,
-                    usage: {},
-                };
-            }
-        }
-        catch {
-            // Fall through to other verification paths.
-        }
-    }
-    if (step.expectedPageAfter) {
-        const signals = await browser.capturePageSignals().catch(() => null);
-        if (signals) {
-            const verdict = await evaluatePageExpectation(page, signals, step.expectedPageAfter);
-            if (verdict.ok) {
-                return {
-                    ok: true,
-                    reason: `Expected destination verified deterministically (confidence=${verdict.confidence.toFixed(2)}).`,
-                    usage: {},
-                };
-            }
-        }
-    }
-    return null;
-}
-async function verifyStep(client, model, step, screenshot, stepIndex, totalSteps, videoScript, pageContext, observationSummary, observationSnapshot, signal) {
-    throwIfAborted(signal, 'Video verification cancelled.');
-    const userText = buildVideoStepVerificationUserMessage(step, stepIndex, totalSteps, pageContext, observationSummary, observationSnapshot);
-    const base64 = screenshot.toString('base64');
-    const imageUrl = `data:image/jpeg;base64,${base64}`;
-    try {
-        const response = await client.chat.completions.create({
-            model,
-            messages: [
-                { role: 'system', content: buildVideoVerificationSystemPrompt(videoScript) },
-                {
-                    role: 'user',
-                    content: buildVideoPromptContentParts({
-                        text: userText,
-                        imageUrl,
-                        cacheLayoutV2: VIDEO_AGENT_CACHE_LAYOUT_V2,
-                    }),
-                },
-            ],
-            tools: videoVerificationTools,
-            tool_choice: 'required',
-            max_tokens: 300,
-            provider: { zdr: true },
-        }, { signal });
-        const usage = extractLlmUsageSnapshot(response);
-        const call = response.choices?.[0]?.message?.tool_calls?.[0];
-        if (!call || !('function' in call)) {
-            return {
-                ok: false,
-                giveUp: true,
-                reason: 'Verification failed: verifier did not return a structured decision.',
-                usage,
-            };
-        }
-        const args = JSON.parse(call.function.arguments || '{}');
-        if (call.function.name === 'step_ok') {
-            return { ok: true, usage };
-        }
-        else if (call.function.name === 'give_up') {
-            return { ok: false, giveUp: true, reason: String(args.reason || 'Give up requested'), usage };
-        }
-        else {
-            return {
-                ok: false,
-                reason: String(args.reason || 'Step failed'),
-                suggestion: args.suggestion ? String(args.suggestion) : undefined,
-                usage,
-            };
-        }
-    }
-    catch (err) {
-        if (isAbortError(err)) {
-            throw err;
-        }
-        return {
-            ok: false,
-            giveUp: true,
-            reason: `Verification failed: ${err.message}`,
-            usage: {},
-        };
-    }
-}
-/**
- * When a dry-run step fails, call the LLM with the screenshot + failure context
- * to propose a replacement sequence of steps. Returns empty array if no fix could be generated.
- */
-async function fixStep(client, model, step, failureReason, suggestion, screenshot, videoScript, observationSummary, observationSnapshot, signal) {
-    throwIfAborted(signal, 'Video fixer cancelled.');
-    const base64 = screenshot.toString('base64');
-    const imageUrl = `data:image/jpeg;base64,${base64}`;
-    try {
-        const response = await client.chat.completions.create({
-            model,
-            messages: [
-                { role: 'system', content: buildStepFixerSystemPrompt(videoScript) },
-                {
-                    role: 'user',
-                    content: buildVideoPromptContentParts({
-                        text: buildStepFixerUserMessage(step, failureReason, suggestion, observationSummary, observationSnapshot),
-                        imageUrl,
-                        cacheLayoutV2: VIDEO_AGENT_CACHE_LAYOUT_V2,
-                    }),
-                },
-            ],
-            max_tokens: 600,
-            response_format: { type: 'json_object' },
-            provider: { zdr: true },
-        }, { signal });
-        const usage = extractLlmUsageSnapshot(response);
-        const content = response.choices?.[0]?.message?.content ?? '';
-        if (!content)
-            return { steps: [], usage };
-        const parsed = JSON.parse(content);
-        // Support both { steps: [...] } and a bare step object (backwards compat)
-        const rawSteps = Array.isArray(parsed.steps)
-            ? parsed.steps
-            : parsed.type ? [parsed] : [];
-        if (rawSteps.length === 0)
-            return { steps: [], usage };
-        // Build valid VideoStep objects; first step keeps original id
-        const fixedSteps = rawSteps
-            .map((s, idx) => ({
-            ...step,
-            ...s,
-            id: idx === 0 ? step.id : (s.id ?? `${step.id}-fix-${idx + 1}`),
-        }))
-            .filter((candidate) => {
-            if (containsInternalAutomationSelector(candidate.selector))
-                return false;
-            if (containsInternalAutomationSelector(candidate.toSelector))
-                return false;
-            if (candidate.type === 'assert_page' && candidate.pageExpectation?.selectors?.some((selector) => containsInternalAutomationSelector(selector))) {
-                return false;
-            }
-            if (candidate.expectedPageAfter?.selectors?.some((selector) => containsInternalAutomationSelector(selector))) {
-                return false;
-            }
-            return true;
-        });
-        return { steps: fixedSteps, usage };
-    }
-    catch (err) {
-        if (isAbortError(err)) {
-            throw err;
-        }
-        return { steps: [], usage: {} };
-    }
-}
-async function classifyVariantStateWithLLMFallback(client, model, browser, requestedLang, requestedTheme, signal) {
-    throwIfAborted(signal, 'Video preflight cancelled.');
-    const screenshot = await browser.takeScreenshotForAI();
-    const base64 = screenshot.toString('base64');
-    const imageUrl = `data:image/jpeg;base64,${base64}`;
-    const response = await client.chat.completions.create({
-        model,
-        response_format: { type: 'json_object' },
-        max_tokens: 180,
-        messages: [
-            {
-                role: 'system',
-                content: 'You classify page language and theme from screenshot + hints. Return strict JSON: {"langActive": boolean|null, "themeActive": boolean|null}.',
-            },
-            {
-                role: 'user',
-                content: buildVideoPromptContentParts({
-                    text: `Requested language=${requestedLang ?? 'none'}, requested theme=${requestedTheme ?? 'none'}.`,
-                    imageUrl,
-                    cacheLayoutV2: VIDEO_AGENT_CACHE_LAYOUT_V2,
-                }),
-            },
-        ],
-        provider: { zdr: true },
-    }, { signal });
-    const parsed = JSON.parse(response.choices?.[0]?.message?.content ?? '{}');
-    return {
-        langActive: typeof parsed.langActive === 'boolean' ? parsed.langActive : undefined,
-        themeActive: typeof parsed.themeActive === 'boolean' ? parsed.themeActive : undefined,
-        usage: extractLlmUsageSnapshot(response),
-    };
-}
-function isPrepareOnlyStep(step) {
-    return step.recordingIntent === 'prepare_only';
-}
-function areEquivalentPreparedUrls(a, b) {
-    if (normalizeComparableUrl(a) === normalizeComparableUrl(b))
-        return true;
-    const parsedA = parseUrlMaybe(a);
-    const parsedB = parseUrlMaybe(b);
-    if (!parsedA || !parsedB)
-        return false;
-    if (parsedA.hostname.replace(/^www\./, '') !== parsedB.hostname.replace(/^www\./, ''))
-        return false;
-    return pathFamilyMatches(parsedA.pathname, parsedB.pathname);
-}
-async function attemptDeterministicLocaleActivation(browser, requestedLang, requestedTheme, signals, seedUrls, callbacks) {
-    let detected = await detectVariantStateDeterministic(browser, requestedLang, requestedTheme);
-    if (!requestedLang || detected.lang.active) {
-        return { detected };
-    }
-    const candidates = collectLocaleActivationCandidates(signals, requestedLang, seedUrls)
-        .filter((candidate) => normalizeComparableUrl(candidate.url) !== normalizeComparableUrl(browser.currentPage.url()))
-        .slice(0, 4);
-    if (candidates.length === 0) {
-        log(`Variant preflight locale fallback found no candidate URL for ${requestedLang}.`, 'info', callbacks.onLog);
-        return { detected };
-    }
-    for (const candidate of candidates) {
-        try {
-            log(`Variant preflight trying locale fallback via ${candidate.source}: ${candidate.url}`, 'info', callbacks.onLog);
-            await browser.navigateTo(candidate.url);
-            await dismissOverlaysWithLogging(browser, {
-                context: `locale fallback (${candidate.source})`,
-                onLog: callbacks.onLog,
-            });
-            detected = await detectVariantStateDeterministic(browser, requestedLang, requestedTheme);
-            if (detected.lang.active) {
-                log(`Variant preflight activated locale ${requestedLang} via ${candidate.source}.`, 'success', callbacks.onLog);
-                return { detected, candidateUsed: candidate };
-            }
-        }
-        catch (err) {
-            log(`Variant preflight locale fallback failed via ${candidate.source}: ${err.message}`, 'info', callbacks.onLog);
-        }
-    }
-    return { detected };
-}
-async function confirmPreparedVariantState(params) {
-    const { browser, client, model, config, callbacks, context } = params;
-    const contextLabel = context === 'dry_run' ? 'Dry-run' : 'Recording';
-    const signal = params.abortSignal ?? config.abortSignal;
-    const usage = [];
-    let usageStepNumber = 1;
-    if (!config.lang && !config.theme) {
-        const detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-        return { ok: true, detected, usage };
-    }
-    await dismissOverlaysWithLogging(browser, {
-        context: `${contextLabel.toLowerCase()} prepared-state check`,
-        onLog: callbacks.onLog,
-    });
-    let detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-    let langActive = !config.lang || detected.lang.active;
-    let themeActive = !config.theme || detected.theme.active;
-    if (langActive && themeActive) {
-        return { ok: true, detected, usage };
-    }
-    log(`[${contextLabel}] prepared variant mismatch detected after rehydration (lang=${config.lang ?? 'n/a'}:${detected.lang.detected ?? 'unknown'}, theme=${config.theme ?? 'n/a'}:${detected.theme.detected ?? 'unknown'}). Attempting local recovery.`, 'info', callbacks.onLog);
-    if (config.lang || config.theme) {
-        const controlFallback = await attemptVariantControlsActivation(browser, config.lang, config.theme, detected.pageSignals, callbacks);
-        detected = controlFallback.detected;
-    }
-    if ((config.lang && !detected.lang.active) || (config.theme && !detected.theme.active)) {
-        const storageFallback = await attemptVariantStorageActivation(browser, config.lang, config.theme, detected.pageSignals, callbacks);
-        detected = storageFallback.detected;
-    }
-    if (config.lang && !detected.lang.active) {
-        const localeFallback = await attemptDeterministicLocaleActivation(browser, config.lang, config.theme, detected.pageSignals, [config.preparedStartUrl ?? config.url, config.url], callbacks);
-        detected = localeFallback.detected;
-    }
-    langActive = !config.lang || detected.lang.active;
-    themeActive = !config.theme || detected.theme.active;
-    if ((detected.lang.ambiguous || detected.theme.ambiguous) && client && (config.lang || config.theme)) {
-        try {
-            const fallback = await classifyVariantStateWithLLMFallback(client, model, browser, config.lang, config.theme, signal);
-            usage.push(buildStepUsageFromSnapshot(normalizeLlmUsageSnapshot(fallback.usage), {
-                stepNumber: usageStepNumber++,
-                stepType: 'video_variant_classification',
-                modelRequested: model,
-                imagesInPrompt: 1,
-            }));
-            if (detected.lang.ambiguous && typeof fallback.langActive === 'boolean') {
-                langActive = fallback.langActive;
-            }
-            if (detected.theme.ambiguous && typeof fallback.themeActive === 'boolean') {
-                themeActive = fallback.themeActive;
-            }
-        }
-        catch (err) {
-            if (isAbortError(err)) {
-                throw err;
-            }
-            // Keep deterministic result when the fallback cannot complete.
-        }
-    }
-    const rebaseUrl = config.preparedStartUrl ?? config.url;
-    if (rebaseUrl && !areEquivalentPreparedUrls(browser.currentPage.url(), rebaseUrl)) {
-        log(`[${contextLabel}] rebasing to ${rebaseUrl} after local variant recovery.`, 'info', callbacks.onLog);
-        await browser.navigateTo(rebaseUrl);
-        await dismissOverlaysWithLogging(browser, {
-            context: `${contextLabel.toLowerCase()} prepared-state rebase`,
-            onLog: callbacks.onLog,
-        });
-        detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-        langActive = !config.lang || detected.lang.active;
-        themeActive = !config.theme || detected.theme.active;
-    }
-    if (langActive && themeActive) {
-        return { ok: true, detected, usage };
-    }
-    if (client && (config.lang || config.theme)) {
-        try {
-            log(`[${contextLabel}] escalating variant restoration to agent repair lane.`, 'info', callbacks.onLog);
-            const repairResult = await runPreparedVariantRepairLane({
-                browser,
-                config,
-                callbacks,
-                abortSignal: signal,
-                observedSummary: [
-                    config.lang
-                        ? `language requested=${config.lang}; detected=${detected.lang.detected ?? 'unknown'}; active=${detected.lang.active}; ambiguous=${detected.lang.ambiguous}`
-                        : null,
-                    config.theme
-                        ? `theme requested=${config.theme}; detected=${detected.theme.detected ?? 'unknown'}; active=${detected.theme.active}; ambiguous=${detected.theme.ambiguous}`
-                        : null,
-                ].filter(Boolean).join(' | '),
-            });
-            if (repairResult.success) {
-                const rebaseUrl = config.preparedStartUrl ?? config.url;
-                if (rebaseUrl && !areEquivalentPreparedUrls(browser.currentPage.url(), rebaseUrl)) {
-                    log(`[${contextLabel}] rebasing to ${rebaseUrl} after variant repair lane.`, 'info', callbacks.onLog);
-                    await browser.navigateTo(rebaseUrl);
-                }
-                await dismissOverlaysWithLogging(browser, {
-                    context: `${contextLabel.toLowerCase()} variant repair lane`,
-                    onLog: callbacks.onLog,
-                });
-                detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-                langActive = !config.lang || detected.lang.active;
-                themeActive = !config.theme || detected.theme.active;
-                if ((detected.lang.ambiguous || detected.theme.ambiguous) && (config.lang || config.theme)) {
-                    try {
-                        const fallback = await classifyVariantStateWithLLMFallback(client, model, browser, config.lang, config.theme, signal);
-                        usage.push(buildStepUsageFromSnapshot(normalizeLlmUsageSnapshot(fallback.usage), {
-                            stepNumber: usageStepNumber++,
-                            stepType: 'video_variant_classification',
-                            modelRequested: model,
-                            imagesInPrompt: 1,
-                        }));
-                        if (detected.lang.ambiguous && typeof fallback.langActive === 'boolean') {
-                            langActive = fallback.langActive;
-                        }
-                        if (detected.theme.ambiguous && typeof fallback.themeActive === 'boolean') {
-                            themeActive = fallback.themeActive;
-                        }
-                    }
-                    catch (err) {
-                        if (isAbortError(err)) {
-                            throw err;
-                        }
-                        // Keep deterministic result if the LLM fallback cannot complete.
-                    }
-                }
-                if (langActive && themeActive) {
-                    return { ok: true, detected, usage };
-                }
-            }
-        }
-        catch (err) {
-            if (isAbortError(err)) {
-                throw err;
-            }
-            log(`[${contextLabel}] variant repair lane failed: ${err.message}`, 'info', callbacks.onLog);
-        }
-    }
-    const reasons = [];
-    if (config.lang && !langActive) {
-        reasons.push(`requested lang=${config.lang}, detected=${detected.lang.detected ?? 'unknown'}`);
-    }
-    if (config.theme && !themeActive) {
-        reasons.push(`requested theme=${config.theme}, detected=${detected.theme.detected ?? 'unknown'}`);
-    }
-    return {
-        ok: false,
-        detected,
-        reason: `${contextLabel} prepared variant mismatch after rehydration: ${reasons.join('; ') || 'variant not active'}`,
-        usage,
-    };
-}
-function deriveExecutionSteps(plan, config) {
-    let steps = plan.steps.filter((step) => !isPrepareOnlyStep(step));
-    if (config.preparedStartUrl && steps[0]?.type === 'navigate' && steps[0].url && areEquivalentPreparedUrls(steps[0].url, config.preparedStartUrl)) {
-        steps = steps.slice(1);
-        if (steps[0]?.type === 'wait' && (steps[0].waitMs ?? 0) <= 2500) {
-            steps = steps.slice(1);
-        }
-    }
-    return steps;
-}
-export async function runVariantPreflight(config, prefixPlan, callbacks = {}) {
-    callbacks.onVariantPhase?.('preflight');
-    const client = createClient(config.apiKey);
-    throwIfAborted(config.abortSignal, 'Video preflight cancelled.');
-    const browser = await Browser.fromPool({
-        headed: false,
-        viewport: config.viewport,
-        deviceScaleFactor: normalizeOutputScale(config.outputScale),
-        lang: config.lang,
-        colorScheme: config.theme,
-        storageState: config.preparedStorageState,
-    });
-    const detachAbort = attachAbortToBrowser(config.abortSignal, browser);
-    let currentMousePos = { x: 0, y: 0 };
-    const usage = [];
-    let usageStepNumber = 1;
-    try {
-        throwIfAborted(config.abortSignal, 'Video preflight cancelled.');
-        if (config.theme) {
-            await browser.setColorScheme(config.theme);
-        }
-        if (config.lang) {
-            await browser.setLanguage(config.lang);
-        }
-        await prepareVideoSessionStorage(browser, config.preparedSessionStorage);
-        const entryUrl = config.preparedStartUrl ?? config.credentials?.loginUrl ?? config.url;
-        await browser.navigateTo(entryUrl);
-        const rawPrefixSteps = prefixPlan?.steps ?? [];
-        let detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-        let prefixSteps = rawPrefixSteps;
-        if ((config.lang ? detected.lang.active : true) && (config.theme ? detected.theme.active : true)) {
-            if (rawPrefixSteps.length > 0) {
-                log('Variant already active on entry page. Skipping prefix plan execution.', 'info', callbacks.onLog);
-            }
-            prefixSteps = [];
-        }
-        else {
-            const sanitizedPrefixSteps = sanitizeVariantPrefixSteps(rawPrefixSteps, config.lang, config.theme);
-            if (sanitizedPrefixSteps.length !== rawPrefixSteps.length) {
-                log(`Variant prefix sanitized: skipped ${rawPrefixSteps.length - sanitizedPrefixSteps.length} non-variant step(s) before preflight.`, 'info', callbacks.onLog);
-            }
-            prefixSteps = sanitizedPrefixSteps;
-        }
-        const hasConcreteVariantActivation = prefixSteps.some(isConcreteVariantActivationStep);
-        if ((config.lang || config.theme) && !hasConcreteVariantActivation) {
-            log('Variant prefix plan contains no concrete activation step. Preflight will rely on deterministic locale/theme fallback if needed.', 'info', callbacks.onLog);
-        }
-        for (let index = 0; index < prefixSteps.length; index++) {
-            throwIfAborted(config.abortSignal, 'Video preflight cancelled.');
-            const step = prefixSteps[index];
-            const stepSignature = buildStepSignature(step);
-            const selectorMemory = config.selectorMemory?.[stepSignature] ?? [];
-            const execResult = await executeStepWithDeterministicRecovery(browser, step, {
-                mode: 'dry_run',
-                stepIndex: index,
-                currentMousePos,
-                selectorFallbacks: selectorMemory,
-                config,
-                callbacks,
-            });
-            currentMousePos = execResult.newMousePos;
-            if (!execResult.success) {
-                const isAssertStep = step.type === 'assert_url' || step.type === 'assert_text' || step.type === 'assert_element' || step.type === 'assert_page';
-                if (isAssertStep) {
-                    // Assert steps in prefix plans are informational — the real variant validation
-                    // is done by detectVariantStateDeterministic below. Don't abort preflight here.
-                    log(`Prefix assert skipped (non-fatal): ${step.description}. ${execResult.reason ?? 'unknown reason'}`, 'info', callbacks.onLog);
-                }
-                else {
-                    const failed = {
-                        ok: false,
-                        code: 'PREFLIGHT_VARIANT_NOT_ACTIVE',
-                        reason: `Prefix step failed: ${step.description}. ${execResult.reason ?? 'unknown reason'}`,
-                        usage,
-                    };
-                    callbacks.onPreflightResult?.(failed);
-                    callbacks.onVariantPhase?.('failed');
-                    return failed;
-                }
-            }
-        }
-        detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-        if ((config.lang && !detected.lang.active) || (config.theme && !detected.theme.active)) {
-            const controlFallback = await attemptVariantControlsActivation(browser, config.lang, config.theme, detected.pageSignals, callbacks);
-            detected = controlFallback.detected;
-        }
-        if ((config.lang && !detected.lang.active) || (config.theme && !detected.theme.active)) {
-            const storageFallback = await attemptVariantStorageActivation(browser, config.lang, config.theme, detected.pageSignals, callbacks);
-            detected = storageFallback.detected;
-        }
-        if (config.lang && !detected.lang.active) {
-            const localeFallback = await attemptDeterministicLocaleActivation(browser, config.lang, config.theme, detected.pageSignals, [entryUrl, config.url], callbacks);
-            detected = localeFallback.detected;
-        }
-        let langActive = detected.lang.active;
-        let themeActive = detected.theme.active;
-        if ((detected.lang.ambiguous || detected.theme.ambiguous) && (config.lang || config.theme)) {
-            try {
-                const fallback = await classifyVariantStateWithLLMFallback(client, config.model, browser, config.lang, config.theme, config.abortSignal);
-                usage.push(buildStepUsageFromSnapshot(normalizeLlmUsageSnapshot(fallback.usage), {
-                    stepNumber: usageStepNumber++,
-                    stepType: 'video_variant_classification',
-                    modelRequested: config.model,
-                    imagesInPrompt: 1,
-                }));
-                if (detected.lang.ambiguous && typeof fallback.langActive === 'boolean') {
-                    langActive = fallback.langActive;
-                }
-                if (detected.theme.ambiguous && typeof fallback.themeActive === 'boolean') {
-                    themeActive = fallback.themeActive;
-                }
-            }
-            catch {
-                // Keep deterministic result
-            }
-        }
-        const rebaseUrl = config.preparedStartUrl ?? config.url;
-        if (rebaseUrl && !areEquivalentPreparedUrls(browser.currentPage.url(), rebaseUrl)) {
-            log(`Variant preflight rebasing to ${rebaseUrl} after variant detour.`, 'info', callbacks.onLog);
-            await browser.navigateTo(rebaseUrl);
-            await dismissOverlaysWithLogging(browser, {
-                context: 'variant preflight rebase',
-                onLog: callbacks.onLog,
-            });
-            detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-            langActive = detected.lang.active;
-            themeActive = detected.theme.active;
-            if ((detected.lang.ambiguous || detected.theme.ambiguous) && (config.lang || config.theme)) {
-                try {
-                    const fallback = await classifyVariantStateWithLLMFallback(client, config.model, browser, config.lang, config.theme, config.abortSignal);
-                    usage.push(buildStepUsageFromSnapshot(normalizeLlmUsageSnapshot(fallback.usage), {
-                        stepNumber: usageStepNumber++,
-                        stepType: 'video_variant_classification',
-                        modelRequested: config.model,
-                        imagesInPrompt: 1,
-                    }));
-                    if (detected.lang.ambiguous && typeof fallback.langActive === 'boolean') {
-                        langActive = fallback.langActive;
-                    }
-                    if (detected.theme.ambiguous && typeof fallback.themeActive === 'boolean') {
-                        themeActive = fallback.themeActive;
-                    }
-                }
-                catch {
-                    // Keep deterministic result after rebase.
-                }
-            }
-        }
-        let ok = langActive && themeActive;
-        // If deterministic fallbacks failed, escalate to the agent repair lane.
-        // This mirrors the behavior of confirmPreparedVariantState in the dry-run,
-        // where the repair lane is the last resort before declaring failure.
-        if (!ok && (config.lang || config.theme)) {
-            try {
-                log('Variant preflight escalating to agent repair lane.', 'info', callbacks.onLog);
-                const repairResult = await runPreparedVariantRepairLane({
-                    browser,
-                    config,
-                    callbacks,
-                    abortSignal: config.abortSignal,
-                    observedSummary: [
-                        config.lang
-                            ? `language requested=${config.lang}; detected=${detected.lang.detected ?? 'unknown'}; active=${detected.lang.active}; ambiguous=${detected.lang.ambiguous}`
-                            : null,
-                        config.theme
-                            ? `theme requested=${config.theme}; detected=${detected.theme.detected ?? 'unknown'}; active=${detected.theme.active}; ambiguous=${detected.theme.ambiguous}`
-                            : null,
-                    ].filter(Boolean).join(' | '),
-                });
-                if (repairResult.success) {
-                    const rebaseAfterRepair = config.preparedStartUrl ?? config.url;
-                    if (rebaseAfterRepair && !areEquivalentPreparedUrls(browser.currentPage.url(), rebaseAfterRepair)) {
-                        log(`Variant preflight rebasing to ${rebaseAfterRepair} after agent repair.`, 'info', callbacks.onLog);
-                        await browser.navigateTo(rebaseAfterRepair);
-                    }
-                    await dismissOverlaysWithLogging(browser, {
-                        context: 'variant preflight agent repair',
-                        onLog: callbacks.onLog,
-                    });
-                    detected = await detectVariantStateDeterministic(browser, config.lang, config.theme);
-                    langActive = detected.lang.active;
-                    themeActive = detected.theme.active;
-                    if ((detected.lang.ambiguous || detected.theme.ambiguous) && (config.lang || config.theme)) {
-                        try {
-                            const fallback = await classifyVariantStateWithLLMFallback(client, config.model, browser, config.lang, config.theme, config.abortSignal);
-                            usage.push(buildStepUsageFromSnapshot(normalizeLlmUsageSnapshot(fallback.usage), {
-                                stepNumber: usageStepNumber++,
-                                stepType: 'video_variant_classification',
-                                modelRequested: config.model,
-                                imagesInPrompt: 1,
-                            }));
-                            if (detected.lang.ambiguous && typeof fallback.langActive === 'boolean') {
-                                langActive = fallback.langActive;
-                            }
-                            if (detected.theme.ambiguous && typeof fallback.themeActive === 'boolean') {
-                                themeActive = fallback.themeActive;
-                            }
-                        }
-                        catch {
-                            // Keep deterministic result after repair.
-                        }
-                    }
-                    ok = langActive && themeActive;
-                }
-            }
-            catch (err) {
-                if (isAbortError(err)) {
-                    throw err;
-                }
-                log(`Variant preflight agent repair failed: ${err.message}`, 'error', callbacks.onLog);
-            }
-        }
-        if (!ok) {
-            const reasons = [];
-            if (!langActive && config.lang) {
-                reasons.push(`requested lang=${config.lang}, detected=${detected.lang.detected ?? 'unknown'}`);
-            }
-            if (!themeActive && config.theme) {
-                reasons.push(`requested theme=${config.theme}, detected=${detected.theme.detected ?? 'unknown'}`);
-            }
-            const failed = {
-                ok: false,
-                code: 'PREFLIGHT_VARIANT_NOT_ACTIVE',
-                reason: reasons.join(' | ') || 'Variant state not active',
-                detectedLang: detected.lang.detected,
-                detectedTheme: detected.theme.detected,
-                usage,
-            };
-            callbacks.onPreflightResult?.(failed);
-            callbacks.onVariantPhase?.('failed');
-            return failed;
-        }
-        const success = {
-            ok: true,
-            detectedLang: detected.lang.detected,
-            detectedTheme: detected.theme.detected,
-            finalUrl: browser.currentPage.url(),
-            storageState: await browser.exportStorageState().catch(() => undefined),
-            sessionStorage: await browser.exportSessionStorage().catch(() => undefined),
-            pageSignals: detected.pageSignals,
-            observationSummary: await captureVideoObservationSummary(browser, {
-                maxAccessibilityChars: 3500,
-                maxElements: 18,
-                maxVisibleTextChars: 500,
-            }).catch(() => undefined),
-            observationSnapshot: buildVideoObservationSnapshot({
-                coherenceKey: config.preparedCoherenceKey,
-                interactiveElements: await browser.getInteractiveElements({ timeoutMs: 3000 }).catch(() => []),
-                pageSignals: detected.pageSignals,
-                pageIdentity: config.preparedObservationSnapshot?.pageIdentity ?? null,
-            }),
-            usage,
-        };
-        callbacks.onPreflightResult?.(success);
-        return success;
-    }
-    catch (err) {
-        if (isAbortError(err)) {
-            throw err;
-        }
-        const failed = {
-            ok: false,
-            code: 'PREFLIGHT_VARIANT_NOT_ACTIVE',
-            reason: `Preflight execution failed: ${err.message}`,
-            usage,
-        };
-        callbacks.onPreflightResult?.(failed);
-        callbacks.onVariantPhase?.('failed');
-        return failed;
-    }
-    finally {
-        detachAbort();
-        await browser.close().catch(() => {
-            // Browser may already be closed by cancellation.
-        });
-    }
-}
-async function runDryRun(plan, config, client, callbacks, videoScript) {
-    log('Starting dry-run verification...', 'info', callbacks.onLog);
-    throwIfAborted(config.abortSignal, 'Video dry-run cancelled.');
-    const browser = await Browser.fromPool({
-        headed: false,
-        viewport: config.viewport,
-        deviceScaleFactor: normalizeOutputScale(config.outputScale),
-        lang: config.lang,
-        colorScheme: config.theme,
-        storageState: config.preparedStorageState,
-    });
-    const detachAbort = attachAbortToBrowser(config.abortSignal, browser);
-    const verificationUsage = [];
-    const executionSteps = deriveExecutionSteps(plan, config);
-    const preservedPrepareSteps = plan.steps.filter(isPrepareOnlyStep);
-    // Collect the final (possibly patched) steps for the recording phase
-    const fixedPlanSteps = [];
-    const memoryUpdates = [];
-    let abortReason;
-    let failure;
-    let currentMousePos = { x: 0, y: 0 };
-    let stepNumber = 1;
-    try {
-        throwIfAborted(config.abortSignal, 'Video dry-run cancelled.');
-        if (config.theme) {
-            await browser.setColorScheme(config.theme);
-        }
-        if (config.lang) {
-            await browser.setLanguage(config.lang);
-        }
-        await prepareVideoSessionStorage(browser, config.preparedSessionStorage);
-        if (config.preparedStartUrl) {
-            await browser.navigateTo(config.preparedStartUrl);
-        }
-        else if (config.credentials?.loginUrl) {
-            // Pre-login if credentials provided
-            await browser.navigateTo(config.credentials.loginUrl);
-        }
-        else if (executionSteps[0]?.type !== 'navigate') {
-            await browser.navigateTo(plan.startUrl);
-        }
-        await replayPreparedActions(browser, config, callbacks);
-        try {
-            const preparedVariant = await runDryRunSubphase({
-                config,
-                callbacks,
-                stepIndex: 0,
-                subphase: 'prepared_variant',
-                minBudgetMs: 5_000,
-                run: async (_timeoutMs, signal) => confirmPreparedVariantState({
-                    browser,
-                    client,
-                    model: config.model,
-                    config,
-                    callbacks,
-                    context: 'dry_run',
-                    abortSignal: signal,
-                }),
-            });
-            verificationUsage.push(...preparedVariant.usage);
-            if (!preparedVariant.ok) {
-                failure = {
-                    stepIndex: 0,
-                    subphase: 'prepared_variant',
-                    reason: preparedVariant.reason,
-                    resolvedTargetSummary: 'prepared variant state',
-                };
-                abortReason = preparedVariant.reason;
-                log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                return {
-                    success: false,
-                    patchedPlan: { ...plan, steps: [...preservedPrepareSteps, ...fixedPlanSteps] },
-                    verificationUsage,
-                    memoryUpdates,
-                    abortReason,
-                    failure,
-                };
-            }
-        }
-        catch (error) {
-            const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-            failure = {
-                stepIndex: 0,
-                subphase: 'prepared_variant',
-                reason,
-                resolvedTargetSummary: 'prepared variant state',
-            };
-            abortReason = reason;
-            log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-            return {
-                success: false,
-                patchedPlan: { ...plan, steps: [...preservedPrepareSteps, ...fixedPlanSteps] },
-                verificationUsage,
-                memoryUpdates,
-                abortReason,
-                failure,
-            };
-        }
-        for (let i = 0; i < executionSteps.length; i++) {
-            throwIfAborted(config.abortSignal, 'Video dry-run cancelled.');
-            const originalStep = executionSteps[i];
-            callbacks.onStep?.(i, executionSteps.length, originalStep.description, 'dry_run');
-            log(`[Dry-run ${i + 1}/${executionSteps.length}] ${originalStep.description} (target=${summarizeStepTarget(originalStep) || 'none'})`, 'info', callbacks.onLog);
-            const isAssertStep = originalStep.type === 'assert_url'
-                || originalStep.type === 'assert_text'
-                || originalStep.type === 'assert_element'
-                || originalStep.type === 'assert_page';
-            if (isAssertStep) {
-                const preAssertVerification = await verifyVideoStepDeterministically(browser, originalStep);
-                if (preAssertVerification?.ok) {
-                    callbacks.onStepResult?.(i, true, preAssertVerification.reason);
-                    log(`Step ${i + 1} deterministically verified: ${preAssertVerification.reason ?? 'ok'}`, 'info', callbacks.onLog);
-                    continue;
-                }
-            }
-            const preStepCheckpoint = await captureVideoStepCheckpoint(browser.currentPage);
-            const markFailure = (subphase, reason, step = originalStep) => {
-                failure = {
-                    stepIndex: i,
-                    subphase,
-                    reason,
-                    resolvedTargetSummary: summarizeStepTarget(step),
-                };
-            };
-            const stepSignature = buildStepSignature(originalStep);
-            const selectorMemory = config.selectorMemory?.[stepSignature] ?? [];
-            let deterministicExec;
-            try {
-                deterministicExec = await runDryRunSubphase({
-                    config,
-                    callbacks,
-                    stepIndex: i,
-                    subphase: 'deterministic_exec',
-                    run: async () => executeStepWithDeterministicRecovery(browser, originalStep, {
-                        mode: 'dry_run',
-                        stepIndex: i,
-                        currentMousePos,
-                        selectorFallbacks: selectorMemory,
-                        config,
-                        callbacks,
-                    }),
-                });
-            }
-            catch (error) {
-                const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                markFailure('deterministic_exec', reason);
-                abortReason = `Unresolved dry-run step ${i + 1}: ${reason}`;
-                callbacks.onStepResult?.(i, false, reason);
-                log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                break;
-            }
-            currentMousePos = deterministicExec.newMousePos;
-            let activeStep = deterministicExec.step;
-            if (deterministicExec.success
-                && activeStep.selector
-                && activeStep.selector !== originalStep.selector
-                && !containsInternalAutomationSelector(activeStep.selector)) {
-                memoryUpdates.push({
-                    stepSignature,
-                    selector: activeStep.selector,
-                    target: activeStep.target,
-                    source: 'deterministic',
-                    success: true,
-                });
-            }
-            let screenshot = null;
-            let observationSummary;
-            let verificationArtifacts = null;
-            let verification;
-            if (!deterministicExec.success) {
-                verification = {
-                    ok: false,
-                    reason: deterministicExec.reason ?? 'Step execution failed',
-                    usage: {},
-                };
-            }
-            else if (isAssertStep) {
-                verification = { ok: true, usage: {} };
-            }
-            else {
-                // For clip mode, skip expensive LLM verification on intermediate steps.
-                // Clips are short (2-4 steps) and often involve stateful UI flows (open menu →
-                // click item → select option). The 8-12s LLM verification pause between steps
-                // causes popovers/dropdowns to close, breaking the subsequent step.
-                // Only the final step gets full LLM verification; intermediate steps use
-                // deterministic checks or auto-accept when the execution succeeded.
-                const isClipMode = config.mode === 'clip';
-                const isLastStep = i >= executionSteps.length - 1;
-                const skipLlmVerification = isClipMode && !isLastStep && deterministicExec.success;
-                const deterministicVerification = await verifyVideoStepDeterministically(browser, activeStep);
-                if (deterministicVerification?.ok) {
-                    verification = deterministicVerification;
-                    log(`Step ${i + 1} deterministically verified: ${deterministicVerification.reason ?? 'ok'}`, 'info', callbacks.onLog);
-                }
-                else if (skipLlmVerification) {
-                    // Clip intermediate step: execution succeeded, accept without LLM to avoid
-                    // the 8-12s pause that would close popovers/dropdowns opened by this step.
-                    verification = { ok: true, usage: {} };
-                    log(`Step ${i + 1} auto-accepted (clip intermediate step — execution succeeded, skipping LLM verification to preserve UI state).`, 'info', callbacks.onLog);
-                }
-                else {
-                    try {
-                        verificationArtifacts = await runDryRunSubphase({
-                            config,
-                            callbacks,
-                            stepIndex: i,
-                            subphase: 'verification_snapshot',
-                            run: async (timeoutMs) => captureVideoVerificationArtifacts(browser, callbacks, timeoutMs),
-                        });
-                    }
-                    catch (error) {
-                        const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                        markFailure('verification_snapshot', reason, activeStep);
-                        verification = {
-                            ok: false,
-                            giveUp: true,
-                            reason,
-                            usage: {},
-                        };
-                        callbacks.onStepResult?.(i, verification.ok, verification.reason);
-                        abortReason = verification.reason;
-                        log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                        break;
-                    }
-                    if (!verificationArtifacts) {
-                        const reason = 'Verification artifacts were not captured.';
-                        markFailure('verification_snapshot', reason, activeStep);
-                        verification = {
-                            ok: false,
-                            giveUp: true,
-                            reason,
-                            usage: {},
-                        };
-                        callbacks.onStepResult?.(i, verification.ok, verification.reason);
-                        abortReason = verification.reason;
-                        log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                        break;
-                    }
-                    const verifiedArtifacts = verificationArtifacts;
-                    const verifiedScreenshot = verifiedArtifacts.bundle.screenshot;
-                    const verifiedPageContext = verifiedArtifacts.pageContext;
-                    const verifiedObservationSnapshot = verifiedArtifacts.observationSnapshot;
-                    screenshot = verifiedScreenshot;
-                    observationSummary = verifiedArtifacts.observationSummary;
-                    try {
-                        verification = await runDryRunSubphase({
-                            config,
-                            callbacks,
-                            stepIndex: i,
-                            subphase: 'verification_llm',
-                            run: async (_timeoutMs, signal) => verifyStep(client, config.model, activeStep, verifiedScreenshot, i, executionSteps.length, videoScript, verifiedPageContext, observationSummary, verifiedObservationSnapshot, signal),
-                        });
-                    }
-                    catch (error) {
-                        const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                        markFailure('verification_llm', reason, activeStep);
-                        verification = {
-                            ok: false,
-                            giveUp: true,
-                            reason,
-                            usage: {},
-                        };
-                        callbacks.onStepResult?.(i, verification.ok, verification.reason);
-                        abortReason = verification.reason;
-                        log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                        break;
-                    }
-                    verificationUsage.push({
-                        stepNumber: stepNumber++,
-                        stepType: 'video_step_verification',
-                        generationId: verification.usage.generationId ?? null,
-                        modelRequested: config.model,
-                        modelUsed: verification.usage.modelUsed ?? null,
-                        promptTokens: verification.usage.promptTokens ?? null,
-                        completionTokens: verification.usage.completionTokens ?? null,
-                        totalTokens: verification.usage.totalTokens ?? null,
-                        cacheReadTokens: verification.usage.cacheReadTokens ?? null,
-                        cacheWriteTokens: verification.usage.cacheWriteTokens ?? null,
-                        imagesInPrompt: 1,
-                    });
-                }
-            }
-            callbacks.onStepResult?.(i, verification.ok, verification.reason);
-            if (verification.giveUp) {
-                abortReason = verification.reason;
-                log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                break;
-            }
-            if (verification.ok) {
-                log(`Step ${i + 1} verified OK`, 'success', callbacks.onLog);
-                fixedPlanSteps.push(activeStep);
-                continue;
-            }
-            log(`Step ${i + 1} failed: ${verification.reason}. Generating fix...`, 'error', callbacks.onLog);
-            const failedSelector = deterministicExec.traces[deterministicExec.traces.length - 1]?.selector ?? activeStep.selector;
-            if (failedSelector && !containsInternalAutomationSelector(failedSelector)) {
-                memoryUpdates.push({
-                    stepSignature,
-                    selector: failedSelector,
-                    target: activeStep.target,
-                    source: 'deterministic',
-                    success: false,
-                });
-            }
-            try {
-                await runDryRunSubphase({
-                    config,
-                    callbacks,
-                    stepIndex: i,
-                    subphase: 'checkpoint_restore',
-                    run: async () => restoreVideoStepCheckpoint(browser, preStepCheckpoint),
-                });
-            }
-            catch (error) {
-                const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                markFailure('checkpoint_restore', reason, activeStep);
-                abortReason = `Unresolved dry-run step ${i + 1}: ${reason}`;
-                log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                break;
-            }
-            try {
-                const repairLaneResult = await runDryRunSubphase({
-                    config,
-                    callbacks,
-                    stepIndex: i,
-                    subphase: 'repair_lane',
-                    run: async (_timeoutMs, signal) => runScreenshotRepairLane({
-                        browser,
-                        config,
-                        callbacks,
-                        originalStep: activeStep,
-                        nextStep: executionSteps[i + 1],
-                        abortSignal: signal,
-                    }),
-                });
-                if (repairLaneResult?.steps.length) {
-                    fixedPlanSteps.push(...repairLaneResult.steps);
-                    const repairedTarget = repairLaneResult.steps[0]?.target;
-                    const repairedSelector = repairLaneResult.steps[0]?.selector;
-                    if (repairedSelector && !containsInternalAutomationSelector(repairedSelector)) {
-                        memoryUpdates.push({
-                            stepSignature,
-                            selector: repairedSelector,
-                            target: repairedTarget,
-                            source: 'manual',
-                            success: true,
-                        });
-                    }
-                    callbacks.onStepResult?.(i, true, 'Repaired via screenshot agent');
-                    log(`Repair lane successful — step ${i + 1} replaced with ${repairLaneResult.steps.length} step(s)`, 'success', callbacks.onLog);
-                    continue;
-                }
-            }
-            catch (error) {
-                markFailure('repair_lane', getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.'), activeStep);
-            }
-            if (!verificationArtifacts) {
-                try {
-                    verificationArtifacts = await runDryRunSubphase({
-                        config,
-                        callbacks,
-                        stepIndex: i,
-                        subphase: 'verification_snapshot',
-                        run: async (timeoutMs) => captureVideoVerificationArtifacts(browser, callbacks, timeoutMs),
-                    });
-                }
-                catch (error) {
-                    const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                    markFailure('verification_snapshot', reason, activeStep);
-                    abortReason = `Unresolved dry-run step ${i + 1}: ${reason}`;
-                    log(`Could not capture a stable verification snapshot for step ${i + 1}. Aborting dry-run...`, 'error', callbacks.onLog);
-                    break;
-                }
-            }
-            screenshot = verificationArtifacts.bundle.screenshot;
-            observationSummary = verificationArtifacts.observationSummary;
-            // Ask LLM to produce a replacement step sequence only after deterministic recovery failed
-            let fixResult;
-            try {
-                fixResult = await runDryRunSubphase({
-                    config,
-                    callbacks,
-                    stepIndex: i,
-                    subphase: 'llm_fixer',
-                    run: async (_timeoutMs, signal) => fixStep(client, config.model, activeStep, verification.reason ?? 'Step failed', verification.suggestion ?? '', screenshot, videoScript, observationSummary, verificationArtifacts.observationSnapshot, signal),
-                });
-            }
-            catch (error) {
-                const reason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                markFailure('llm_fixer', reason, activeStep);
-                abortReason = `Unresolved dry-run step ${i + 1}: ${reason}`;
-                log(`Could not generate a valid fix for step ${i + 1}. Aborting dry-run...`, 'error', callbacks.onLog);
-                break;
-            }
-            // Track fix LLM call cost
-            if (fixResult.usage.generationId || fixResult.usage.totalTokens) {
-                verificationUsage.push({
-                    stepNumber: stepNumber++,
-                    stepType: 'video_step_fix',
-                    generationId: fixResult.usage.generationId ?? null,
-                    modelRequested: config.model,
-                    modelUsed: fixResult.usage.modelUsed ?? null,
-                    promptTokens: fixResult.usage.promptTokens ?? null,
-                    completionTokens: fixResult.usage.completionTokens ?? null,
-                    totalTokens: fixResult.usage.totalTokens ?? null,
-                    cacheReadTokens: fixResult.usage.cacheReadTokens ?? null,
-                    cacheWriteTokens: fixResult.usage.cacheWriteTokens ?? null,
-                    imagesInPrompt: 1,
-                });
-            }
-            if (fixResult.steps.length === 0) {
-                markFailure('llm_fixer', verification.reason ?? 'no valid fix generated', activeStep);
-                abortReason = `Unresolved dry-run step ${i + 1}: ${verification.reason ?? 'no valid fix generated'}`;
-                log(`Could not generate a valid fix for step ${i + 1}. Aborting dry-run...`, 'error', callbacks.onLog);
-                break;
-            }
-            log(`Fix proposed (${fixResult.steps.length} step(s)) — rolling back and retrying...`, 'ai', callbacks.onLog);
-            try {
-                await runDryRunSubphase({
-                    config,
-                    callbacks,
-                    stepIndex: i,
-                    subphase: 'checkpoint_restore',
-                    run: async () => restoreVideoStepCheckpoint(browser, preStepCheckpoint),
-                });
-            }
-            catch (error) {
-                const abortMessage = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                markFailure('checkpoint_restore', abortMessage, activeStep);
-                if (config.abortSignal?.aborted) {
-                    abortReason = abortMessage;
-                    log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-                    break;
-                }
-            }
-            const executedFixSteps = [];
-            let fixExecutionFailed = false;
-            let fixExecutionReason;
-            for (let fixIndex = 0; fixIndex < fixResult.steps.length; fixIndex++) {
-                const candidate = fixResult.steps[fixIndex];
-                const fixSignature = buildStepSignature(candidate);
-                const fixMemorySelectors = config.selectorMemory?.[fixSignature] ?? [];
-                let fixExec;
-                try {
-                    fixExec = await runDryRunSubphase({
-                        config,
-                        callbacks,
-                        stepIndex: i,
-                        subphase: 'deterministic_exec',
-                        run: async () => executeStepWithDeterministicRecovery(browser, candidate, {
-                            mode: 'dry_run',
-                            stepIndex: i,
-                            currentMousePos,
-                            selectorFallbacks: fixMemorySelectors,
-                            config,
-                            callbacks,
-                        }),
-                    });
-                }
-                catch (error) {
-                    fixExecutionFailed = true;
-                    fixExecutionReason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                    break;
-                }
-                currentMousePos = fixExec.newMousePos;
-                executedFixSteps.push(fixExec.step);
-                if (!fixExec.success) {
-                    fixExecutionFailed = true;
-                    fixExecutionReason = fixExec.reason ?? 'Fix step execution failed';
-                    break;
-                }
-            }
-            let fixVerificationOk = !fixExecutionFailed;
-            if (!fixExecutionFailed) {
-                if (isAssertStep) {
-                    throwIfAborted(config.abortSignal, 'Video dry-run cancelled.');
-                    const deterministicAssertVerification = await verifyVideoStepDeterministically(browser, activeStep);
-                    if (deterministicAssertVerification?.ok) {
-                        fixVerificationOk = true;
-                        log(`Step ${i + 1} fix deterministically verified: ${deterministicAssertVerification.reason ?? 'ok'}`, 'info', callbacks.onLog);
-                    }
-                    else {
-                        const assertVerification = await executeStepWithDeterministicRecovery(browser, activeStep, {
-                            mode: 'dry_run',
-                            stepIndex: i,
-                            currentMousePos,
-                            selectorFallbacks: selectorMemory,
-                            config,
-                            callbacks,
-                        });
-                        currentMousePos = assertVerification.newMousePos;
-                        fixVerificationOk = assertVerification.success;
-                        if (!assertVerification.success) {
-                            fixExecutionReason = assertVerification.reason ?? 'Assertion still failing after fix';
-                        }
-                    }
-                }
-                else {
-                    const deterministicFixVerification = await verifyVideoStepDeterministically(browser, originalStep);
-                    if (deterministicFixVerification?.ok) {
-                        fixVerificationOk = true;
-                        log(`Step ${i + 1} fix deterministically verified: ${deterministicFixVerification.reason ?? 'ok'}`, 'info', callbacks.onLog);
-                    }
-                    else {
-                        try {
-                            const fixArtifacts = await runDryRunSubphase({
-                                config,
-                                callbacks,
-                                stepIndex: i,
-                                subphase: 'verification_snapshot',
-                                run: async (timeoutMs) => captureVideoVerificationArtifacts(browser, callbacks, timeoutMs),
-                            });
-                            const fixVerification = await runDryRunSubphase({
-                                config,
-                                callbacks,
-                                stepIndex: i,
-                                subphase: 'verification_llm',
-                                run: async (_timeoutMs, signal) => verifyStep(client, config.model, originalStep, fixArtifacts.bundle.screenshot, i, executionSteps.length, videoScript, fixArtifacts.pageContext, fixArtifacts.observationSummary, fixArtifacts.observationSnapshot, signal),
-                            });
-                            verificationUsage.push({
-                                stepNumber: stepNumber++,
-                                stepType: 'video_step_verification',
-                                generationId: fixVerification.usage.generationId ?? null,
-                                modelRequested: config.model,
-                                modelUsed: fixVerification.usage.modelUsed ?? null,
-                                promptTokens: fixVerification.usage.promptTokens ?? null,
-                                completionTokens: fixVerification.usage.completionTokens ?? null,
-                                totalTokens: fixVerification.usage.totalTokens ?? null,
-                                cacheReadTokens: fixVerification.usage.cacheReadTokens ?? null,
-                                cacheWriteTokens: fixVerification.usage.cacheWriteTokens ?? null,
-                                imagesInPrompt: 1,
-                            });
-                            fixVerificationOk = fixVerification.ok;
-                            if (!fixVerification.ok) {
-                                fixExecutionReason = fixVerification.reason ?? 'Fix verification failed';
-                            }
-                        }
-                        catch (error) {
-                            fixVerificationOk = false;
-                            fixExecutionReason = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-                            markFailure('verification_llm', fixExecutionReason, originalStep);
-                        }
-                    }
-                }
-            }
-            if (fixVerificationOk) {
-                fixedPlanSteps.push(...executedFixSteps);
-                const fixedSelector = executedFixSteps[0]?.selector;
-                if (fixedSelector && !containsInternalAutomationSelector(fixedSelector)) {
-                    memoryUpdates.push({
-                        stepSignature,
-                        selector: fixedSelector,
-                        target: executedFixSteps[0]?.target,
-                        source: 'llm_fix',
-                        success: true,
-                    });
-                }
-                log(`Fix successful — step ${i + 1} replaced with ${executedFixSteps.length} step(s) in plan`, 'success', callbacks.onLog);
-                callbacks.onStepResult?.(i, true, 'Fixed and verified');
-            }
-            else {
-                if (executedFixSteps[0]?.selector && !containsInternalAutomationSelector(executedFixSteps[0].selector)) {
-                    memoryUpdates.push({
-                        stepSignature,
-                        selector: executedFixSteps[0].selector,
-                        target: executedFixSteps[0].target,
-                        source: 'llm_fix',
-                        success: false,
-                    });
-                }
-                markFailure('llm_fixer', fixExecutionReason ?? verification.reason ?? 'fix failed', executedFixSteps[0] ?? activeStep);
-                log(`Fix also failed for step ${i + 1}. Aborting dry-run... ${fixExecutionReason ?? ''}`, 'error', callbacks.onLog);
-                abortReason = `Unresolved dry-run step ${i + 1}: ${fixExecutionReason ?? verification.reason ?? 'fix failed'}`;
-                try {
-                    await restoreVideoStepCheckpoint(browser, preStepCheckpoint);
-                }
-                catch {
-                    // Keep the original dry-run failure reason.
-                }
-                break;
-            }
-        }
-        // Apply the fixed plan so the recording phase uses corrected steps
-        plan.steps = preservedPrepareSteps.length > 0
-            ? [...preservedPrepareSteps, ...fixedPlanSteps]
-            : fixedPlanSteps;
-    }
-    catch (error) {
-        const abortMessage = getAbortAwareErrorMessage(config.abortSignal, error, 'Video dry-run cancelled.');
-        if (config.abortSignal?.aborted || isAbortError(error)) {
-            abortReason = abortMessage;
-            log(`Aborting dry-run: ${abortReason}`, 'error', callbacks.onLog);
-        }
-        else {
-            throw error;
-        }
-    }
-    finally {
-        detachAbort();
-        await browser.close().catch(() => {
-            // Browser may already be closed by cancellation.
-        });
-    }
-    return {
-        success: !abortReason,
-        abortReason,
-        failure,
-        verificationUsage,
-        patchedPlan: {
-            ...plan,
-            steps: preservedPrepareSteps.length > 0
-                ? [...preservedPrepareSteps, ...fixedPlanSteps]
-                : fixedPlanSteps,
-        },
-        memoryUpdates,
-    };
-}
-// ── Phase 3: Video recording ──────────────────────────────────────────
-async function runRecording(plan, config, callbacks) {
-    log('Starting video recording...', 'info', callbacks.onLog);
-    // Create temp directory for the video file
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'autokap-video-'));
-    const outputPath = path.join(tempDir, 'recording.webm');
-    const startTime = Date.now();
-    const executionSteps = deriveExecutionSteps(plan, config);
-    let stepsExecuted = 0;
-    let setupDurationSec = 0;
-    let videoPath = null;
-    const usage = [];
-    let browser = null;
-    let detachAbort = () => { };
-    // We need a reference to the Video object before closing the context,
-    // because Playwright only finalizes the WebM file after the context is closed.
-    // The correct order is: capture ref → close context → saveAs().
-    let videoRef = null;
-    try {
-        throwIfAborted(config.abortSignal, 'Video recording cancelled.');
-        const client = createClient(config.apiKey);
-        browser = await Browser.forVideoRecording({
-            headed: false,
-            viewport: config.viewport,
-            deviceScaleFactor: normalizeOutputScale(config.outputScale),
-            lang: config.lang,
-            colorScheme: config.theme,
-            storageState: config.preparedStorageState,
-        }, tempDir, buildCursorOverlayScript(config.videoOptions?.cursorTheme ?? 'minimal'));
-        detachAbort = attachAbortToBrowser(config.abortSignal, browser);
-        if (config.theme) {
-            await browser.setColorScheme(config.theme);
-        }
-        await prepareVideoSessionStorage(browser, config.preparedSessionStorage);
-        // Pre-navigate only when step 1 won't navigate to the same URL (avoids visible reload flicker).
-        const normalizeForDedup = (u) => u.toLowerCase().replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/+$/, '').replace(/[?#].*$/, '').trim();
-        const firstStepUrl = executionSteps[0]?.type === 'navigate' ? executionSteps[0].url : null;
-        const preNavUrl = config.preparedStartUrl
-            ?? config.credentials?.loginUrl
-            ?? (executionSteps[0]?.type !== 'navigate' ? plan.startUrl : null);
-        if (preNavUrl && (!firstStepUrl || normalizeForDedup(preNavUrl) !== normalizeForDedup(firstStepUrl))) {
-            await browser.navigateTo(preNavUrl);
-        }
-        // When storageState restored auth and we already navigated to preparedStartUrl,
-        // replaying intermediate navigation actions is redundant and adds visible setup time.
-        if (!config.preparedStorageState || !config.preparedStartUrl) {
-            await replayPreparedActions(browser, config, callbacks);
-        }
-        // Skip variant confirmation in recording when the dry-run already confirmed it.
-        // This saves 10-30s of deterministic checks + potential LLM fallback.
-        if (!config.dryRunVariantConfirmed) {
-            const preparedVariant = await confirmPreparedVariantState({
-                browser,
-                client,
-                model: config.model,
-                config,
-                callbacks,
-                context: 'recording',
-            });
-            usage.push(...preparedVariant.usage);
-            if (!preparedVariant.ok) {
-                throw new Error(preparedVariant.reason);
-            }
-        }
-        // Wait for the page to be fully loaded before recording any steps.
-        // The video is already recording (Playwright limitation), so this "setup"
-        // time is trimmed away by the post-processing trimStart.
-        await browser.currentPage.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => { });
-        await dismissOverlaysWithLogging(browser, {
-            context: 'recording setup first dismiss',
-            onLog: callbacks.onLog,
-        });
-        // Brief settle time for late-loading elements (fonts, lazy images)
-        await browser.currentPage.waitForTimeout(400);
-        // Second dismiss pass — some overlays appear after networkidle (delayed popups)
-        await dismissOverlaysWithLogging(browser, {
-            context: 'recording setup second dismiss',
-            onLog: callbacks.onLog,
-        });
-        // Randomize cursor starting position within the central area of the viewport
-        // so it never appears from the same top-left corner on every recording.
-        const vpW = config.viewport.width;
-        const vpH = config.viewport.height;
-        const startX = Math.floor(vpW * 0.3 + Math.random() * vpW * 0.4);
-        const startY = Math.floor(vpH * 0.3 + Math.random() * vpH * 0.4);
-        await browser.currentPage.mouse.move(startX, startY);
-        let currentMousePos = { x: startX, y: startY };
-        // Record how long the setup took — this will be trimmed from the final video
-        setupDurationSec = (Date.now() - startTime) / 1000;
-        // Filter out assert steps — they are only useful during dry-run verification
-        // and add dead time (up to 6s each) with no visual benefit during recording.
-        // Also filter out consecutive wait steps that are redundant.
-        const recordableSteps = executionSteps.filter((s) => s.type !== 'assert_url' && s.type !== 'assert_text' && s.type !== 'assert_element' && s.type !== 'assert_page');
-        let firstNavDone = false;
-        for (let i = 0; i < recordableSteps.length; i++) {
-            throwIfAborted(config.abortSignal, 'Video recording cancelled.');
-            const step = recordableSteps[i];
-            callbacks.onStep?.(i, recordableSteps.length, step.description, 'recording');
-            log(`[Recording ${i + 1}/${recordableSteps.length}] ${step.description}`, 'info', callbacks.onLog);
-            const result = await executePlanStep(browser, step, 'recording', currentMousePos, config.credentials);
-            // Auto-dismiss overlays (cookie banners, consent walls) after the first
-            // navigation so they don't persist throughout the entire video.
-            if (!firstNavDone && step.type === 'navigate') {
-                firstNavDone = true;
-                await dismissOverlaysWithLogging(browser, {
-                    context: 'recording post-first-navigation dismiss',
-                    onLog: callbacks.onLog,
-                });
-            }
-            currentMousePos = result.newMousePos;
-            stepsExecuted++;
-            if (result.error) {
-                callbacks.onStepResult?.(i, false, result.error);
-                if (config.mode === 'clip') {
-                    // Graceful degradation for clips: log and continue with remaining steps.
-                    // A partial clip (3/4 interactions) is better than no clip at all.
-                    log(`[Recording] Step ${i + 1} failed (continuing): ${result.error}`, 'error', callbacks.onLog);
-                }
-                else {
-                    // For videos, abort — longer plans are more likely to have cascading failures.
-                    throw new Error(`Recording step ${i + 1} failed: ${result.error}`);
-                }
-            }
-        }
-        // Final pause so the last frame is visible
-        throwIfAborted(config.abortSignal, 'Video recording cancelled.');
-        await browser.currentPage.waitForTimeout(800);
-        // Capture video ref before closing anything
-        videoRef = browser.currentPage.video() ?? null;
-        // Step 1: close only the context — this finalizes the WebM on disk
-        // while the browser process (and its IPC channel) remains alive.
-        await browser.closeContext();
-        // Step 2: saveAs() can now copy the finalized file (IPC channel still open)
-        if (videoRef) {
-            await videoRef.saveAs(outputPath);
-            videoPath = outputPath;
-            log('Recording saved successfully', 'success', callbacks.onLog);
-        }
-    }
-    catch (err) {
-        if (isAbortError(err)) {
-            throw err;
-        }
-        log(`Recording error: ${err.message}`, 'error', callbacks.onLog);
-    }
-    finally {
-        detachAbort();
-        // Step 3: shut down the browser process
-        if (browser)
-            await browser.close().catch(() => {
-                // Browser may already be closed by cancellation.
-            });
-    }
-    const durationMs = Date.now() - startTime;
-    return { videoPath, durationMs, stepsExecuted, setupDurationSec, usage };
-}
-// ── Exported phase functions (for multi-viewport orchestration) ───────
-function withStepIdPrefix(steps, idPrefix) {
-    return steps.map((step, index) => ({
-        ...step,
-        id: `${idPrefix}${index + 1}`,
-    }));
-}
-function withRecordingIntent(steps, recordingIntent) {
-    return steps.map((step) => ({
-        ...step,
-        recordingIntent,
-    }));
-}
-export function composeHybridPlan(basePlan, variantPrefixPlan) {
-    const prefixSteps = variantPrefixPlan?.steps ?? [];
-    const prefixedVariant = withRecordingIntent(withStepIdPrefix(prefixSteps, 'prefix-step-'), 'prepare_only');
-    const prefixedBase = withRecordingIntent(withStepIdPrefix(basePlan.steps, 'base-step-'), 'visible');
-    return {
-        title: `${basePlan.title}`,
-        estimatedDurationSec: basePlan.estimatedDurationSec + (variantPrefixPlan?.estimatedDurationSec ?? 0),
-        startUrl: variantPrefixPlan?.startUrl ?? basePlan.startUrl,
-        steps: [...prefixedVariant, ...prefixedBase],
-    };
-}
-async function collectPlannerObservation(config) {
-    if (config.preparedObservationSummary && config.preparedObservationSnapshot && !(config.enablePlannerVision ?? false)) {
-        return {
-            summary: config.preparedObservationSummary,
-            snapshot: config.preparedObservationSnapshot,
-        };
-    }
-    if (config.preparedObservationSummary && !(config.enablePlannerVision ?? false)) {
-        return { summary: config.preparedObservationSummary, snapshot: config.preparedObservationSnapshot };
-    }
-    try {
-        const obs = await observePlanningContext({
-            url: config.url,
-            startUrl: config.preparedStartUrl,
-            viewport: config.viewport,
-            outputScale: normalizeOutputScale(config.outputScale),
-            lang: config.lang,
-            theme: config.theme,
-            storageState: config.preparedStorageState,
-            sessionStorage: config.preparedSessionStorage,
-            abortSignal: config.abortSignal,
-            captureScreenshot: config.enablePlannerVision ?? false,
-            pageIdentity: config.preparedObservationSnapshot?.pageIdentity ?? null,
-        });
-        return {
-            summary: obs.summary ?? config.preparedObservationSummary,
-            screenshot: obs.screenshot,
-            snapshot: obs.snapshot ?? config.preparedObservationSnapshot,
-        };
-    }
-    catch (err) {
-        if (isAbortError(err)) {
-            throw err;
-        }
-        logger.info(`Planning observation skipped: ${err.message}`);
-        return config.preparedObservationSummary
-            ? { summary: config.preparedObservationSummary, snapshot: config.preparedObservationSnapshot }
-            : {};
-    }
-}
-export async function createBasePlan(config) {
-    const obs = await collectPlannerObservation(config);
-    const result = await planFromScript(config.script, config.preparedStartUrl ?? config.url, config.model, config.apiKey, config.maxPlanRetries ?? 2, {
-        mode: config.mode === 'clip' ? 'clip' : 'base',
-        credentials: config.credentials,
-        variant: {
-            lang: config.lang,
-            theme: config.theme,
-            langInstructions: config.langInstructions,
-            themeInstructions: config.themeInstructions,
-        },
-        observationSummary: obs.summary,
-        observationSnapshot: obs.snapshot,
-        screenshot: obs.screenshot,
-    }, config.abortSignal);
-    return result;
-}
-export async function createVariantPrefixPlan(config) {
-    const obs = await collectPlannerObservation(config);
-    const result = await planFromScript(config.script, config.url, config.model, config.apiKey, config.maxPlanRetries ?? 2, {
-        mode: 'variant_prefix',
-        credentials: config.credentials,
-        variant: {
-            lang: config.lang,
-            theme: config.theme,
-            langInstructions: config.langInstructions,
-            themeInstructions: config.themeInstructions,
-        },
-        observationSummary: obs.summary,
-        observationSnapshot: obs.snapshot,
-        screenshot: obs.screenshot,
-    }, config.abortSignal);
-    return result;
-}
-export async function verifyAndPatchPlan(plan, config, callbacks = {}) {
-    const client = createClient(config.apiKey);
-    callbacks.onVariantPhase?.('dry_run');
-    callbacks.onPhaseChange?.('dry_run');
-    log('Phase 2: Running verification dry-run...', 'info', callbacks.onLog);
-    const dryRunResult = await runDryRun({ ...plan, steps: [...plan.steps] }, config, client, callbacks, config.script);
-    if (!dryRunResult.success) {
-        log(`Dry-run aborted: ${dryRunResult.abortReason}`, 'error', callbacks.onLog);
-        callbacks.onPhaseChange?.('failed');
-        callbacks.onVariantPhase?.('failed');
-        return {
-            success: false,
-            error: `Dry-run failed: ${dryRunResult.abortReason}`,
-            usage: dryRunResult.verificationUsage,
-            memoryUpdates: dryRunResult.memoryUpdates,
-            failedStepIndex: dryRunResult.failure?.stepIndex,
-            failedSubphase: dryRunResult.failure?.subphase,
-        };
-    }
-    log('Dry-run completed successfully', 'success', callbacks.onLog);
-    return {
-        success: true,
-        plan: dryRunResult.patchedPlan,
-        usage: dryRunResult.verificationUsage,
-        memoryUpdates: dryRunResult.memoryUpdates,
-    };
-}
-/**
- * Backward-compatible helper: full planning + verify in one call.
- */
-export async function planAndVerify(config, callbacks = {}) {
-    const allUsage = [];
-    callbacks.onVariantPhase?.('planning');
-    callbacks.onPhaseChange?.('planning');
-    log('Phase 1: Analyzing script and generating execution plan...', 'ai', callbacks.onLog);
-    let plan;
-    try {
-        const obs = await collectPlannerObservation(config);
-        const planResult = await planFromScript(config.script, config.url, config.model, config.apiKey, config.maxPlanRetries ?? 2, {
-            mode: config.mode === 'clip' ? 'clip' : 'full',
-            credentials: config.credentials,
-            observationSummary: obs.summary,
-            screenshot: obs.screenshot,
-        }, config.abortSignal);
-        plan = planResult.plan;
-        allUsage.push(planResult.usage);
-        log(`Plan ready: "${plan.title}" — ${plan.steps.length} steps (~${plan.estimatedDurationSec}s)`, 'success', callbacks.onLog);
-    }
-    catch (err) {
-        if (isAbortError(err)) {
-            throw err;
-        }
-        const error = err.message;
-        log(`Planning failed: ${error}`, 'error', callbacks.onLog);
-        callbacks.onPhaseChange?.('failed');
-        callbacks.onVariantPhase?.('failed');
-        return { success: false, error: `Planning failed: ${error}`, usage: allUsage, memoryUpdates: [] };
-    }
-    const verified = await verifyAndPatchPlan(plan, config, callbacks);
-    allUsage.push(...verified.usage);
-    if (!verified.success) {
-        return {
-            success: false,
-            error: verified.error,
-            usage: allUsage,
-            memoryUpdates: verified.memoryUpdates,
-        };
-    }
-    return {
-        success: true,
-        plan: verified.plan,
-        usage: allUsage,
-        memoryUpdates: verified.memoryUpdates,
-    };
-}
-/**
- * Run phase 3 (recording only) using a pre-verified plan.
- * Call after `planAndVerify()` to record across multiple lang/theme combinations.
- */
-export async function recordPlan(plan, config, callbacks = {}) {
-    callbacks.onPhaseChange?.('recording');
-    callbacks.onVariantPhase?.('recording');
-    log('Phase 3: Recording video with animated mouse...', 'info', callbacks.onLog);
-    return runRecording(plan, config, callbacks);
-}
-// ── Main entry point ──────────────────────────────────────────────────
-/**
- * Run the full 3-phase video capture pipeline:
- * 1. Planning: script → structured plan (LLM)
- * 2. Dry-run: verify all steps work
- * 3. Recording: execute with Bezier mouse + cursor overlay
- */
-export async function runVideoAgent(config, callbacks = {}) {
-    const allUsage = [];
-    const planResult = await planAndVerify(config, callbacks);
-    allUsage.push(...planResult.usage);
-    if (!planResult.success) {
-        callbacks.onPhaseChange?.('failed');
-        return {
-            success: false,
-            plan: null,
-            videoPath: null,
-            thumbnailBuffer: null,
-            durationMs: 0,
-            stepsExecuted: 0,
-            assessment: planResult.error,
-            usage: allUsage,
-        };
-    }
-    const plan = planResult.plan;
-    const recordingResult = await recordPlan(plan, config, callbacks);
-    allUsage.push(...recordingResult.usage);
-    callbacks.onPhaseChange?.('done');
-    callbacks.onVariantPhase?.('done');
-    log('Video capture complete!', 'success', callbacks.onLog);
-    return {
-        success: recordingResult.videoPath !== null,
-        plan,
-        videoPath: recordingResult.videoPath,
-        thumbnailBuffer: null, // Thumbnail generation is optional (V1: skip)
-        durationMs: recordingResult.durationMs,
-        stepsExecuted: recordingResult.stepsExecuted,
-        assessment: `Recorded ${recordingResult.stepsExecuted}/${plan.steps.length} steps in ${Math.round(recordingResult.durationMs / 1000)}s`,
-        usage: allUsage,
-    };
-}
-//# sourceMappingURL=video-agent.js.map