autokap 1.0.7 → 1.0.10

package/dist/legacy/credential-templates.d.ts

@@ -0,0 +1,5 @@
+import type { LoginCredentials } from "../types.js";
+export declare function resolveCredentialTemplates(value: string | undefined, credentials?: LoginCredentials): string | undefined;
+export declare function ensureNoCredentialTemplate(field: string, value: string | undefined): void;
+export declare function sanitizeCredentialParams(params: Record<string, unknown>, credentials?: LoginCredentials): Record<string, unknown>;
+export declare function resolveActionCredentialArgs(action: string, args: Record<string, unknown>, credentials?: LoginCredentials): Record<string, unknown>;

package/dist/legacy/credential-templates.js

@@ -0,0 +1,60 @@
+const TEMPLATE_RE = /\{\{credential\.(loginUrl|email|password)\}\}/g;
+export function resolveCredentialTemplates(value, credentials) {
+    if (!value)
+        return value;
+    const replacements = {
+        loginUrl: credentials?.loginUrl,
+        email: credentials?.email,
+        password: credentials?.password,
+    };
+    return value.replace(TEMPLATE_RE, (match, key) => {
+        const replacement = replacements[key];
+        return typeof replacement === "string" ? replacement : match;
+    });
+}
+export function ensureNoCredentialTemplate(field, value) {
+    if (value && TEMPLATE_RE.test(value)) {
+        TEMPLATE_RE.lastIndex = 0;
+        throw new Error(`Missing credential value for ${field}`);
+    }
+    TEMPLATE_RE.lastIndex = 0;
+}
+function sanitizeCredentialString(value, credentials) {
+    if (!credentials)
+        return value;
+    if (credentials.password && value === credentials.password) {
+        return "{{credential.password}}";
+    }
+    if (credentials.email && value === credentials.email) {
+        return "{{credential.email}}";
+    }
+    if (credentials.loginUrl && value === credentials.loginUrl) {
+        return "{{credential.loginUrl}}";
+    }
+    return value;
+}
+export function sanitizeCredentialParams(params, credentials) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(params)) {
+        sanitized[key] =
+            typeof value === "string"
+                ? sanitizeCredentialString(value, credentials)
+                : value;
+    }
+    return sanitized;
+}
+export function resolveActionCredentialArgs(action, args, credentials) {
+    if (!credentials)
+        return args;
+    const resolved = { ...args };
+    if ((action === "type_text" || action === "type") && typeof resolved.text === "string") {
+        resolved.text = resolveCredentialTemplates(resolved.text, credentials);
+        ensureNoCredentialTemplate(`${action}.text`, resolved.text);
+    }
+    if (action === "navigate_to" && typeof resolved.url === "string") {
+        resolved.url = resolveCredentialTemplates(resolved.url, credentials);
+        ensureNoCredentialTemplate("navigate_to.url", resolved.url);
+    }
+    return resolved;
+}
+//# sourceMappingURL=credential-templates.js.map

package/dist/legacy/hybrid-navigator.d.ts

@@ -0,0 +1,138 @@
+/**
+ * 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/legacy/hybrid-navigator.js

@@ -0,0 +1,468 @@
+/**
+ * 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 capture',
+        '4. Navigate to the specific page/state described below',
+        '5. Once the page is clean (no overlays, no spinners, correct page), call 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 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 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 capture once the exact pre-recording start state is visible.');
+    }
+    parts.push('');
+    parts.push('IMPORTANT — Before calling capture:\n' +
+        '- Dismiss ALL overlays: cookie banners, analytics prompts, consent walls, feedback widgets, onboarding tooltips. Tap dismiss/close buttons or press Escape.\n' +
+        '- If the URL is /home, /dashboard, /app, or / you are on a GENERIC dashboard, NOT inside a specific project/workspace. ' +
+        'Do NOT call 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 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 capture.\n` +
+            `If the fixed chrome is in a different language, you MUST switch it before calling 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 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