autokap 1.0.2 → 1.0.3

package/dist/hybrid-navigator.d.ts

@@ -1,138 +0,0 @@
-/**
- * Hybrid Navigator — Uses the screenshot agent for navigation (Phase 1),
- * then exports the session for video recording (Phase 2).
- *
- * This wrapper around `runAgent()` provides:
- * - Agent-driven navigation with full self-healing
- * - Session export (storageState + sessionStorage + scroll position)
- * - Post-transfer auth detection (silent re-auth wait)
- * - Lightweight selector pre-validation for clip plans
- * - Fresh observation capture on recording browser
- */
-import { Browser } from './browser.js';
-import { type VariantStateDetection } from './video-variant-state.js';
-import type { BrowserStorageState, BrowserSessionStorageState, CapturePageIdentity, ExecutedAction, InteractiveElement, LoginCredentials, StepUsage, VerificationResult, VideoPlan, VideoObservationSnapshot, VideoPageSignals, VideoStep } from './types.js';
-export interface NavigationResult {
-    success: boolean;
-    finalUrl: string;
-    scrollPosition: {
-        x: number;
-        y: number;
-    };
-    storageState?: BrowserStorageState;
-    sessionStorage?: BrowserSessionStorageState;
-    observationSummary?: string;
-    observationSnapshot?: VideoObservationSnapshot;
-    coherenceKey?: string;
-    interactiveElements?: InteractiveElement[];
-    pageIdentity?: CapturePageIdentity | null;
-    actions?: ExecutedAction[];
-    replayableActions?: ExecutedAction[];
-    verification?: VerificationResult | null;
-    verificationMode?: VerificationResult['mode'];
-    exactStartStateVerified: boolean;
-    detectedLang?: string | null;
-    detectedTheme?: 'light' | 'dark' | null;
-    pageSignals?: VideoPageSignals;
-    variantState?: VariantStateDetection;
-    error?: string;
-    usage: StepUsage[];
-}
-export interface NavigateWithAgentConfig {
-    /** Target URL — can be relative (e.g. "/docs") if baseUrl is provided. */
-    url: string;
-    /** Base URL of the project (e.g. "https://example.com"). Used to resolve relative urls. */
-    baseUrl?: string;
-    navigationPrompt: string;
-    /**
-     * When provided (two-part mode), this describes the RECORDED interaction separately
-     * from the navigation. The navigation agent only needs to know what will be recorded
-     * to stop at the right pre-recording state — it must NOT perform the recorded actions.
-     */
-    recordingScript?: string;
-    viewport: {
-        width: number;
-        height: number;
-    };
-    outputScale?: number;
-    lang?: string;
-    theme?: 'light' | 'dark';
-    credentials?: LoginCredentials;
-    langInstructions?: string;
-    themeInstructions?: string;
-    navigationInstructions?: string;
-    model: string;
-    apiKey: string;
-    maxIterations?: number;
-    abortSignal?: AbortSignal;
-    onLog?: (entry: {
-        level: 'info' | 'action' | 'success' | 'error' | 'ai';
-        message: string;
-        timestamp: number;
-    }) => void;
-    onScreenshot?: (base64: string) => void;
-}
-export interface SelectorValidationResult {
-    valid: boolean;
-    missingSelectors: Array<{
-        stepIndex: number;
-        step: VideoStep;
-        selector: string;
-    }>;
-}
-export interface FreshObservationConfig {
-    url: string;
-    viewport: {
-        width: number;
-        height: number;
-    };
-    outputScale?: number;
-    lang?: string;
-    theme?: 'light' | 'dark';
-    storageState?: BrowserStorageState;
-    sessionStorage?: BrowserSessionStorageState;
-    scrollPosition?: {
-        x: number;
-        y: number;
-    };
-    abortSignal?: AbortSignal;
-}
-/**
- * Phase 1: Use the screenshot agent to navigate to a target state.
- * Exports the full session (cookies, localStorage, sessionStorage, scroll)
- * for reuse in the video recording phase.
- */
-export declare function navigateWithAgent(config: NavigateWithAgentConfig): Promise<NavigationResult>;
-/**
- * Capture a fresh observation from a browser that already has the session loaded.
- * Use this on Browser B (recording browser) AFTER navigation, not the stale
- * observation from Browser A (agent browser).
- */
-export declare function captureFreshObservation(browser: Browser): Promise<string>;
-/**
- * Capture a fresh observation by opening a temporary pool browser with the
- * exported session. Closes the browser automatically.
- */
-export declare function captureFreshObservationFromSession(config: FreshObservationConfig): Promise<string>;
-/**
- * After transferring session to a new browser context, detect if the page
- * ended up in a logged-out state (e.g., due to IndexedDB/in-memory JWT loss).
- * If detected, waits for silent re-auth to complete.
- *
- * Returns true if auth is confirmed or no auth issues detected.
- */
-export declare function waitForAuthStabilization(browser: Browser, options?: {
-    timeoutMs?: number;
-}): Promise<{
-    ok: boolean;
-    reason?: string;
-}>;
-/**
- * Validate selectors in a plan that can be checked on the current page.
- *
- * Only validates selectors up to the first page-mutating step (click, hover,
- * type, select_option, key). After such a step the DOM changes and later
- * selectors cannot be verified without actually executing the plan.
- */
-export declare function validatePlanSelectors(browser: Browser, plan: VideoPlan): Promise<SelectorValidationResult>;
-export declare function buildNavigationPrompt(resolvedUrl: string, config: NavigateWithAgentConfig): string;

package/dist/hybrid-navigator.js

@@ -1,468 +0,0 @@
-/**
- * Hybrid Navigator — Uses the screenshot agent for navigation (Phase 1),
- * then exports the session for video recording (Phase 2).
- *
- * This wrapper around `runAgent()` provides:
- * - Agent-driven navigation with full self-healing
- * - Session export (storageState + sessionStorage + scroll position)
- * - Post-transfer auth detection (silent re-auth wait)
- * - Lightweight selector pre-validation for clip plans
- * - Fresh observation capture on recording browser
- */
-import { Browser } from './browser.js';
-import { analyzeReplayCandidate, runAgent } from './agent.js';
-import { buildVideoObservationSnapshot, buildVideoObservationSummary, captureVideoObservationSummary, } from './video-observation.js';
-import { detectVariantStateDeterministic } from './video-variant-state.js';
-import { logger, runWithLoggerCallbacks } from './logger.js';
-import { throwIfAborted } from './abort.js';
-import { dismissOverlaysWithLogging } from './overlay-utils.js';
-// ── Navigation ───────────────────────────────────────────────────────
-/**
- * Phase 1: Use the screenshot agent to navigate to a target state.
- * Exports the full session (cookies, localStorage, sessionStorage, scroll)
- * for reuse in the video recording phase.
- */
-export async function navigateWithAgent(config) {
-    throwIfAborted(config.abortSignal, 'Hybrid navigation cancelled.');
-    // Resolve relative URLs (e.g. "/docs") against the project base URL.
-    const resolvedUrl = resolveUrl(config.url, config.baseUrl);
-    const log = (msg, level = 'info') => {
-        if (level === 'error')
-            logger.error(msg);
-        else
-            logger.info(msg);
-        config.onLog?.({ level, message: msg, timestamp: Date.now() });
-    };
-    log(`[hybrid-nav] Starting agent navigation to: ${resolvedUrl}`);
-    const browser = await Browser.fromPool({
-        headed: false,
-        viewport: config.viewport,
-        deviceScaleFactor: config.outputScale,
-        lang: config.lang,
-        colorScheme: config.theme,
-    });
-    try {
-        // Navigate to the target URL before starting the agent.
-        // The agent expects the browser to already be on the page (same as capture pipeline).
-        // Without this, the browser starts on about:blank and relative URLs fail.
-        await browser.navigateTo(resolvedUrl);
-        await dismissOverlaysWithLogging(browser, {
-            context: 'hybrid navigation bootstrap',
-            onLog: config.onLog,
-        });
-        // Wrap runAgent with logger callbacks so that agent logs (reasoning, actions,
-        // verification) and live screenshots are forwarded to the SSE stream.
-        const agentResult = await runWithLoggerCallbacks({
-            onLog: config.onLog ? (entry) => config.onLog(entry) : undefined,
-            onScreenshot: config.onScreenshot ?? undefined,
-        }, () => runAgent(browser, {
-            url: resolvedUrl,
-            prompt: buildNavigationPrompt(resolvedUrl, config),
-            dark: config.theme === 'dark',
-            langs: config.lang ? [config.lang] : ['en'],
-            outputDir: '',
-            headed: false,
-            viewport: config.viewport,
-            maxIterations: config.maxIterations ?? 30,
-            model: config.model,
-            credentials: config.credentials,
-            langInstructions: config.langInstructions,
-            themeInstructions: config.themeInstructions,
-            currentLang: config.lang,
-            currentTheme: config.theme,
-            runMode: 'video_navigation_preflight',
-            abortSignal: config.abortSignal,
-        }, config.apiKey));
-        if (!agentResult.success) {
-            log(`[hybrid-nav] Agent navigation failed: ${agentResult.assessment}`, 'error');
-            return {
-                success: false,
-                finalUrl: browser.currentPage.url(),
-                scrollPosition: { x: 0, y: 0 },
-                exactStartStateVerified: false,
-                error: agentResult.assessment,
-                usage: agentResult.usage,
-            };
-        }
-        const verification = agentResult.verification ?? null;
-        const verificationMode = verification?.mode;
-        const exactStartStateVerified = verification?.verified === true
-            && (verificationMode === 'vision' || verificationMode === 'text_fallback');
-        const captureVerificationBundle = typeof browser.captureVideoVerificationBundle === 'function'
-            ? browser.captureVideoVerificationBundle({ maxAttempts: 1 }).catch(() => null)
-            : Promise.resolve(null);
-        const [storageState, sessionStorage, scrollPosition, variantState, pageState, pageTitle, verificationBundle] = await Promise.all([
-            browser.exportStorageState().catch(() => undefined),
-            browser.exportSessionStorage().catch(() => undefined),
-            browser.currentPage.evaluate(() => ({
-                x: Math.round(window.scrollX),
-                y: Math.round(window.scrollY),
-            })).catch(() => ({ x: 0, y: 0 })),
-            detectVariantStateDeterministic(browser, config.lang, config.theme).catch(() => undefined),
-            browser.getPageState().catch(() => undefined),
-            browser.currentPage.title().catch(() => ''),
-            captureVerificationBundle,
-        ]);
-        const finalUrl = browser.currentPage.url();
-        const observationSummary = verificationBundle
-            ? buildVideoObservationSummary({
-                url: verificationBundle.url,
-                title: verificationBundle.title,
-                accessibilityTree: verificationBundle.accessibilityTree,
-                interactiveElements: verificationBundle.interactiveElements,
-                pageSignals: verificationBundle.pageSignals,
-                maxAccessibilityChars: 3500,
-                maxElements: 18,
-                maxVisibleTextChars: 500,
-            })
-            : pageState && variantState
-                ? buildVideoObservationSummary({
-                    url: finalUrl,
-                    title: pageTitle,
-                    accessibilityTree: pageState.accessibilityTree,
-                    interactiveElements: pageState.interactiveElements,
-                    pageSignals: variantState.pageSignals,
-                    maxAccessibilityChars: 3500,
-                    maxElements: 18,
-                    maxVisibleTextChars: 500,
-                })
-                : await captureVideoObservationSummary(browser).catch(() => undefined);
-        const observationSnapshot = verificationBundle
-            ? buildVideoObservationSnapshot({
-                coherenceKey: verificationBundle.coherenceKey,
-                interactiveElements: verificationBundle.interactiveElements,
-                pageSignals: verificationBundle.pageSignals,
-                pageIdentity: null,
-            })
-            : pageState && variantState
-                ? buildVideoObservationSnapshot({
-                    interactiveElements: pageState.interactiveElements,
-                    pageSignals: variantState.pageSignals,
-                    pageIdentity: null,
-                })
-                : undefined;
-        const replayAnalysis = analyzeReplayCandidate(agentResult.actions, {
-            currentUrl: finalUrl,
-            targetUrl: finalUrl,
-            currentViewport: browser.currentPage.viewportSize(),
-            isAuthenticated: !!config.credentials,
-            currentDialogCount: verificationBundle?.observation.dialogCount ?? null,
-            pageIdentity: null,
-        });
-        log(`[hybrid-nav] Navigation complete. Final URL: ${finalUrl} (runMode=video_navigation_preflight, verificationMode=${verificationMode ?? 'unknown'})`);
-        return {
-            success: true,
-            finalUrl,
-            scrollPosition,
-            storageState,
-            sessionStorage,
-            observationSummary,
-            observationSnapshot,
-            coherenceKey: verificationBundle?.coherenceKey,
-            interactiveElements: verificationBundle?.interactiveElements ?? pageState?.interactiveElements,
-            pageIdentity: null,
-            actions: agentResult.actions,
-            replayableActions: replayAnalysis.skipReason ? [] : replayAnalysis.replayableActions,
-            verification,
-            verificationMode,
-            exactStartStateVerified,
-            detectedLang: variantState?.lang.detected ?? null,
-            detectedTheme: variantState?.theme.detected ?? null,
-            pageSignals: variantState?.pageSignals,
-            variantState,
-            usage: agentResult.usage,
-        };
-    }
-    finally {
-        await browser.close().catch(() => { });
-    }
-}
-// ── Fresh Observation on Recording Browser ───────────────────────────
-/**
- * Capture a fresh observation from a browser that already has the session loaded.
- * Use this on Browser B (recording browser) AFTER navigation, not the stale
- * observation from Browser A (agent browser).
- */
-export async function captureFreshObservation(browser) {
-    return captureVideoObservationSummary(browser, {
-        maxAccessibilityChars: 3500,
-        maxElements: 18,
-        maxVisibleTextChars: 500,
-    });
-}
-/**
- * Capture a fresh observation by opening a temporary pool browser with the
- * exported session. Closes the browser automatically.
- */
-export async function captureFreshObservationFromSession(config) {
-    throwIfAborted(config.abortSignal, 'Observation capture cancelled.');
-    const browser = await Browser.fromPool({
-        headed: false,
-        viewport: config.viewport,
-        deviceScaleFactor: config.outputScale,
-        lang: config.lang,
-        colorScheme: config.theme,
-        storageState: config.storageState,
-    });
-    try {
-        if (config.sessionStorage && Object.keys(config.sessionStorage).length > 0) {
-            await browser.prepareSessionStorage(config.sessionStorage, { replace: true });
-        }
-        await browser.navigateTo(config.url);
-        await dismissOverlaysWithLogging(browser, { context: 'fresh observation bootstrap' });
-        // Restore scroll position
-        if (config.scrollPosition && (config.scrollPosition.x !== 0 || config.scrollPosition.y !== 0)) {
-            await browser.currentPage.evaluate(({ x, y }) => window.scrollTo({ left: x, top: y, behavior: 'instant' }), config.scrollPosition).catch(() => { });
-            await browser.currentPage.waitForTimeout(250);
-        }
-        return await captureVideoObservationSummary(browser, {
-            maxAccessibilityChars: 3500,
-            maxElements: 18,
-            maxVisibleTextChars: 500,
-        });
-    }
-    finally {
-        await browser.close().catch(() => { });
-    }
-}
-// ── Post-Transfer Auth Detection ─────────────────────────────────────
-/**
- * After transferring session to a new browser context, detect if the page
- * ended up in a logged-out state (e.g., due to IndexedDB/in-memory JWT loss).
- * If detected, waits for silent re-auth to complete.
- *
- * Returns true if auth is confirmed or no auth issues detected.
- */
-export async function waitForAuthStabilization(browser, options = {}) {
-    const timeout = options.timeoutMs ?? 5000;
-    const page = browser.currentPage;
-    // Check 1: Did the page redirect to a login URL?
-    const url = page.url().toLowerCase();
-    const loginPatterns = [
-        '/login',
-        '/signin',
-        '/sign-in',
-        '/auth',
-        '/sso',
-        '/oauth',
-        '/accounts/login',
-        '/connexion',
-        '/anmeldung',
-        '/acceso',
-        '/accedi',
-    ];
-    const isOnLoginPage = loginPatterns.some(p => url.includes(p));
-    if (isOnLoginPage) {
-        logger.info('[hybrid-nav] Detected redirect to login page after session transfer. Waiting for silent re-auth...');
-        // Wait for navigation away from login page (silent OAuth/OIDC redirect)
-        try {
-            await page.waitForURL((u) => !loginPatterns.some(p => u.toString().toLowerCase().includes(p)), { timeout });
-            logger.info('[hybrid-nav] Silent re-auth completed successfully.');
-            return { ok: true };
-        }
-        catch {
-            return { ok: false, reason: 'Session transfer failed: stuck on login page after re-auth timeout' };
-        }
-    }
-    // Check 2: Does the page contain visible login/sign-in buttons suggesting logged-out state?
-    const hasLoginPrompt = await page.evaluate(() => {
-        const buttons = Array.from(document.querySelectorAll('button, a, [role="button"]'));
-        const loginLabels = [
-            'log in',
-            'login',
-            'sign in',
-            'signin',
-            'sign up',
-            'get started',
-            'se connecter',
-            'connexion',
-            'anmelden',
-            'iniciar sesion',
-            'accedi',
-        ];
-        return buttons.some(el => {
-            const text = (el.textContent || '').trim().toLowerCase();
-            return loginLabels.some(label => text === label) && el.checkVisibility?.();
-        });
-    }).catch(() => false);
-    if (hasLoginPrompt) {
-        logger.info('[hybrid-nav] Detected login prompt on page. Waiting briefly for potential silent re-auth...');
-        // Brief wait — some SPAs show login state briefly before silent auth completes
-        await page.waitForTimeout(2000);
-        // Re-check
-        const stillHasLogin = await page.evaluate(() => {
-            const buttons = Array.from(document.querySelectorAll('button, a, [role="button"]'));
-            const loginLabels = ['log in', 'login', 'sign in', 'signin', 'se connecter', 'connexion', 'anmelden', 'iniciar sesion', 'accedi'];
-            return buttons.some(el => {
-                const text = (el.textContent || '').trim().toLowerCase();
-                return loginLabels.some(label => text === label) && el.checkVisibility?.();
-            });
-        }).catch(() => false);
-        if (stillHasLogin) {
-            return { ok: false, reason: 'Session transfer may have failed: login prompt still visible' };
-        }
-    }
-    return { ok: true };
-}
-// ── Lightweight Selector Pre-Validation ──────────────────────────────
-/**
- * Validate selectors in a plan that can be checked on the current page.
- *
- * Only validates selectors up to the first page-mutating step (click, hover,
- * type, select_option, key). After such a step the DOM changes and later
- * selectors cannot be verified without actually executing the plan.
- */
-export async function validatePlanSelectors(browser, plan) {
-    const page = browser.currentPage;
-    const missing = [];
-    // Types that mutate the page state — hover is intentionally excluded so
-    // we can keep validating selectors that come after a non-committal reveal.
-    const mutatingTypes = new Set(['click', 'type', 'select_option', 'key', 'drag']);
-    const skipTypes = new Set(['navigate', 'wait', 'dismiss_overlays', 'assert_url', 'assert_text', 'assert_element', 'assert_page']);
-    for (let i = 0; i < plan.steps.length; i++) {
-        const step = plan.steps[i];
-        if (skipTypes.has(step.type))
-            continue;
-        if (!step.selector) {
-            // First mutating step without a selector — stop here
-            if (mutatingTypes.has(step.type))
-                break;
-            continue;
-        }
-        // Validate this selector
-        try {
-            const selectorParts = step.selector.split(',').map(s => s.trim()).filter(Boolean);
-            let found = false;
-            for (const part of selectorParts) {
-                const count = await page.locator(part).count().catch(() => 0);
-                if (count > 0) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                missing.push({ stepIndex: i, step, selector: step.selector });
-            }
-        }
-        catch {
-            missing.push({ stepIndex: i, step, selector: step.selector });
-        }
-        // After validating this step, if it mutates the page, stop
-        if (mutatingTypes.has(step.type))
-            break;
-    }
-    return {
-        valid: missing.length === 0,
-        missingSelectors: missing,
-    };
-}
-// ── URL Resolution ───────────────────────────────────────────────────
-/**
- * Resolve a potentially relative URL against a base URL.
- * - "/docs" + "https://example.com" → "https://example.com/docs"
- * - "https://other.com/page" + "https://example.com" → "https://other.com/page" (absolute, untouched)
- * - "/docs" + undefined → "/docs" (no base, pass through as-is)
- */
-function resolveUrl(url, baseUrl) {
-    // Already absolute — nothing to resolve
-    if (/^https?:\/\//i.test(url))
-        return url;
-    if (!baseUrl)
-        return url;
-    try {
-        return new URL(url, baseUrl).href;
-    }
-    catch {
-        // Fallback: simple concatenation if URL constructor fails
-        const base = baseUrl.replace(/\/+$/, '');
-        const path = url.startsWith('/') ? url : `/${url}`;
-        return `${base}${path}`;
-    }
-}
-// ── Prompt Builder ───────────────────────────────────────────────────
-export function buildNavigationPrompt(resolvedUrl, config) {
-    // Two-part mode: navigationPrompt = WHERE to navigate, recordingScript = WHAT will be recorded.
-    // Legacy mode: navigationPrompt = full clip script used for both.
-    const hasTwoPartPrompt = !!config.recordingScript;
-    const parts = [
-        `Navigate to ${resolvedUrl} and prepare the exact pre-recording start state for a clip recording.`,
-        '',
-        'Your tasks:',
-        '1. Load the page at the URL above',
-        '2. Handle login if credentials are provided',
-        '3. Dismiss ALL cookie banners, consent walls, analytics prompts, overlays, and popups — do this BEFORE calling ready_to_capture',
-        '4. Navigate to the specific page/state described below',
-        '5. Once the page is clean (no overlays, no spinners, correct page), call ready_to_capture',
-    ];
-    if (hasTwoPartPrompt) {
-        // Two-part mode: clear separation between navigation goal and what will be recorded.
-        parts.push('');
-        parts.push('<navigation_goal>');
-        parts.push(config.navigationPrompt);
-        parts.push('</navigation_goal>');
-        parts.push('');
-        parts.push('<recording_preview>');
-        parts.push(`After you call ready_to_capture, the recording system will perform: ${config.recordingScript}`);
-        parts.push('You must NOT perform these recording actions yourself. Your job is ONLY to reach the state where the recording can begin.');
-        parts.push('</recording_preview>');
-        parts.push('');
-        parts.push('Follow the <navigation_goal> instructions exactly. Navigate to the described page/state. ' +
-            'Dismiss all overlays and popups along the way. ' +
-            'Once you are on the correct page with no obstructions, call ready_to_capture.');
-    }
-    else if (config.navigationPrompt) {
-        // Legacy mode: single script for both navigation and recording.
-        parts.push('');
-        parts.push(`Clip description: "${config.navigationPrompt}"`);
-        parts.push('');
-        parts.push('Read the clip description above carefully. If it mentions navigation steps to perform BEFORE the main action ' +
-            '(e.g. "go to Settings", "open the API tab", "navigate to the pricing page"), you MUST perform those navigation steps now. ' +
-            'Opening the correct project, workspace, section, tab, or source dialog counts as preparation and MUST be done now when requested. ' +
-            'However, do NOT perform the final interaction that should be RECORDED (e.g. "click Regenerate", "click New", "click New preset", "scroll down", "toggle dark mode"). ' +
-            'The recording system will handle the recorded interaction. Your job is to stop on the exact pre-recording start state for that interaction, not on a generic dashboard that only roughly matches the site.');
-    }
-    else {
-        parts.push('');
-        parts.push('No specific navigation required. Just load the page, dismiss overlays, and call ready_to_capture once the exact pre-recording start state is visible.');
-    }
-    parts.push('');
-    parts.push('IMPORTANT — Before calling ready_to_capture:\n' +
-        '- Dismiss ALL overlays: cookie banners, analytics prompts, consent walls, feedback widgets, onboarding tooltips. Use dismiss_overlays or click dismiss/close buttons.\n' +
-        '- If the URL is /home, /dashboard, /app, or / you are on a GENERIC dashboard, NOT inside a specific project/workspace. ' +
-        'Do NOT call ready_to_capture from a generic dashboard unless explicitly targeting the homepage.\n' +
-        '- Check the URL path: it must match the specific entity/page required.\n' +
-        '- If you changed language or theme via settings, navigate BACK to the target page before calling ready_to_capture.');
-    if (config.credentials) {
-        parts.push('');
-        parts.push('If the page requires authentication, use the provided credentials to log in.');
-    }
-    if (config.lang) {
-        parts.push('');
-        parts.push(`<variant_requirement type="language" value="${config.lang}">\n` +
-            `The app\'s fixed UI chrome (menus, buttons, labels, navigation) MUST be in "${config.lang}" when you call ready_to_capture.\n` +
-            `If the fixed chrome is in a different language, you MUST switch it before calling ready_to_capture.\n` +
-            `Ignore user-generated content (project names, preset names, imported data) that may remain in another language.\n` +
-            `</variant_requirement>`);
-    }
-    if (config.theme) {
-        parts.push('');
-        parts.push(`<variant_requirement type="theme" value="${config.theme}">\n` +
-            `The app MUST be in "${config.theme}" theme when you call ready_to_capture.\n` +
-            `If the app has an in-app theme toggle/selector, use it to switch to "${config.theme}" mode.\n` +
-            `</variant_requirement>`);
-    }
-    if (config.navigationInstructions) {
-        parts.push('');
-        parts.push(`Additional navigation instructions: ${config.navigationInstructions}`);
-    }
-    if (config.langInstructions) {
-        parts.push('');
-        parts.push(`Language instructions: ${config.langInstructions}`);
-    }
-    if (config.themeInstructions) {
-        parts.push('');
-        parts.push(`Theme instructions: ${config.themeInstructions}`);
-    }
-    return parts.join('\n');
-}
-//# sourceMappingURL=hybrid-navigator.js.map

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-export { Browser } from './browser.js';
-export { runAgent } from './agent.js';
-export { captureIsolatedElement } from './element-capture.js';
-export { dismissCookiesAndWidgets } from './cookie-dismiss.js';
-export { logger, setOnLog, setOnScreenshot, emitScreenshot } from './logger.js';
-export type { LogEntry, LogLevel, OnLogCallback, OnScreenshotCallback } from './logger.js';
-export { applyDeviceFrame, getDeviceFrames, getDeviceFrame, invalidateDeviceConfigCache, resolveDeviceFrameDescriptor, rasterizeDeviceFrame, } from './mockup.js';
-export type { DeviceFrameId, DeviceFrameDefinition, DeviceCategory, MockupOptions, MockupOrientation, ResolvedDeviceFrameDescriptor, } from './mockup.js';
-export { generateStatusBarHtml } from './status-bar.js';
-export { generateBrowserBarHtml } from './browser-bar.js';
-export type { BrowserBarConfig, BrowserBarRenderOptions } from './browser-bar.js';
-export { convertToGif, convertToMp4, ensureFfmpegAvailable, extractThumbnail, getMediaDurationMs, } from './clip-postprocess.js';
-export { evaluateActionSecurity, describeSecurityTarget } from './security.js';
-export type { StatusBarConfig, StatusBarLayout, StatusBarDeviceType, StatusBarRenderOptions } from './status-bar.js';
-export type * from './types.js';

package/dist/index.js

@@ -1,11 +0,0 @@
-export { Browser } from './browser.js';
-export { runAgent } from './agent.js';
-export { captureIsolatedElement } from './element-capture.js';
-export { dismissCookiesAndWidgets } from './cookie-dismiss.js';
-export { logger, setOnLog, setOnScreenshot, emitScreenshot } from './logger.js';
-export { applyDeviceFrame, getDeviceFrames, getDeviceFrame, invalidateDeviceConfigCache, resolveDeviceFrameDescriptor, rasterizeDeviceFrame, } from './mockup.js';
-export { generateStatusBarHtml } from './status-bar.js';
-export { generateBrowserBarHtml } from './browser-bar.js';
-export { convertToGif, convertToMp4, ensureFfmpegAvailable, extractThumbnail, getMediaDurationMs, } from './clip-postprocess.js';
-export { evaluateActionSecurity, describeSecurityTarget } from './security.js';
-//# sourceMappingURL=index.js.map

package/dist/llm-usage.d.ts

@@ -1,17 +0,0 @@
-import type { ChatCompletion } from 'openai/resources/chat/completions';
-import type { StepUsage } from './types.js';
-export type LlmUsageSnapshot = Pick<StepUsage, 'generationId' | 'modelUsed' | 'promptTokens' | 'completionTokens' | 'totalTokens' | 'cacheReadTokens' | 'cacheWriteTokens' | 'reasoningTokens'>;
-export declare function extractLlmUsageSnapshot(response: ChatCompletion): LlmUsageSnapshot;
-export declare function buildStepUsageFromSnapshot(snapshot: LlmUsageSnapshot, params: {
-    stepNumber: number;
-    stepType: StepUsage['stepType'];
-    modelRequested: string;
-    imagesInPrompt: number;
-}): StepUsage;
-export declare function normalizeLlmUsageSnapshot(snapshot: Partial<LlmUsageSnapshot>): LlmUsageSnapshot;
-export declare function extractStepUsage(response: ChatCompletion, params: {
-    stepNumber: number;
-    stepType: StepUsage['stepType'];
-    modelRequested: string;
-    imagesInPrompt: number;
-}): StepUsage;