autokap 1.0.7 → 1.0.8

package/dist/v2/web-playwright-local.js

@@ -0,0 +1,392 @@
+/**
+ * Capture Agent — WebPlaywrightLocal RuntimeAdapter
+ *
+ * Thin adapter delegating to the existing Browser class from src/browser.ts.
+ * This is the first (and for now only) RuntimeAdapter implementation.
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { humanType, moveMouse } from '../mouse-animation.js';
+import { resolveTarget } from './semantic-resolver.js';
+export class WebPlaywrightLocal {
+    browser;
+    recordingDir;
+    sessionStartedAt = Date.now();
+    recording = null;
+    clipCursor = null;
+    constructor(browser, recordingDir) {
+        this.browser = browser;
+        this.recordingDir = recordingDir;
+    }
+    async navigate(url) {
+        await this.browser.navigateTo(url);
+    }
+    async getCurrentUrl() {
+        const page = await this.browser.currentPage;
+        return page.url();
+    }
+    async getAKTree() {
+        return this.browser.getAKTree();
+    }
+    async getPageSignals() {
+        return this.browser.capturePageSignals();
+    }
+    async click(selector, options) {
+        const page = await this.browser.currentPage;
+        if (options?.coordinates) {
+            await this.moveClipCursorToPoint(options.coordinates);
+            await this.browser.clickByCoordinates(options.coordinates.x, options.coordinates.y);
+            return;
+        }
+        const locator = page.locator(selector).first();
+        await this.moveClipCursorToLocator(locator);
+        if (options?.useKeyboard) {
+            await locator.focus();
+            await page.keyboard.press('Enter');
+            return;
+        }
+        if (options?.useJsDispatch) {
+            await locator.dispatchEvent('click');
+            return;
+        }
+        await this.browser.clickBySelector(selector, { force: options?.force });
+    }
+    /**
+     * Click an element using semantic target resolution.
+     * Tries CSS selector first, falls back to Playwright semantic locators.
+     */
+    async clickByTarget(opts) {
+        const page = await this.browser.currentPage;
+        const resolved = await resolveTarget(page, opts);
+        if (!resolved) {
+            throw new Error(`cannot find target: ${describeResolveOptions(opts)}`);
+        }
+        await this.moveClipCursorToLocator(resolved.locator);
+        await resolved.locator.click({ timeout: 5000 });
+    }
+    /**
+     * Type into an element using semantic target resolution.
+     */
+    async typeByTarget(opts, text, clearFirst = true) {
+        const page = await this.browser.currentPage;
+        const resolved = await resolveTarget(page, opts);
+        if (!resolved) {
+            throw new Error(`cannot find target for typing: ${describeResolveOptions(opts)}`);
+        }
+        if (this.clipCursor) {
+            await this.typeIntoLocator(resolved.locator, text, clearFirst);
+            return;
+        }
+        if (clearFirst) {
+            await resolved.locator.fill(text);
+            return;
+        }
+        await resolved.locator.click();
+        await resolved.locator.pressSequentially(text);
+    }
+    /**
+     * Wait for an element using semantic target resolution.
+     */
+    async waitForTarget(opts, timeoutMs = 10000) {
+        const page = await this.browser.currentPage;
+        const resolved = await resolveTarget(page, { ...opts, timeoutMs });
+        return resolved !== null;
+    }
+    /**
+     * Scroll an element into view using semantic target resolution.
+     */
+    async scrollIntoViewByTarget(opts) {
+        const page = await this.browser.currentPage;
+        const resolved = await resolveTarget(page, opts);
+        if (!resolved) {
+            throw new Error(`cannot find target to scroll into view: ${describeResolveOptions(opts)}`);
+        }
+        if (this.clipCursor) {
+            await this.moveClipCursorToViewportCenter();
+            await resolved.locator.evaluate((node) => {
+                node.scrollIntoView({ block: 'center', behavior: 'smooth' });
+            });
+            await page.waitForTimeout(350);
+            return;
+        }
+        await resolved.locator.scrollIntoViewIfNeeded({ timeout: 5000 });
+    }
+    async type(selector, text, clearFirst = true) {
+        if (this.clipCursor) {
+            const page = await this.browser.currentPage;
+            await this.typeIntoLocator(page.locator(selector).first(), text, clearFirst);
+            return;
+        }
+        await this.browser.typeText(text, { selector, clearFirst });
+    }
+    async pressKey(key) {
+        const page = await this.browser.currentPage;
+        if (this.clipCursor) {
+            await page.waitForTimeout(90);
+            await page.keyboard.press(key);
+            return;
+        }
+        await this.browser.pressKey(key);
+    }
+    async scroll(direction, amount) {
+        if (this.clipCursor) {
+            const page = await this.browser.currentPage;
+            await this.moveClipCursorToViewportCenter();
+            const dx = direction === 'right' ? (amount ?? 500) : direction === 'left' ? -(amount ?? 500) : 0;
+            const dy = direction === 'down' ? (amount ?? 500) : direction === 'up' ? -(amount ?? 500) : 0;
+            await page.evaluate(({ deltaX, deltaY }) => {
+                window.scrollBy({ left: deltaX, top: deltaY, behavior: 'smooth' });
+            }, { deltaX: dx, deltaY: dy });
+            await page.waitForTimeout(420);
+            return;
+        }
+        await this.browser.scroll(direction, amount);
+    }
+    async scrollIntoView(selector) {
+        const page = await this.browser.currentPage;
+        if (this.clipCursor) {
+            await this.moveClipCursorToViewportCenter();
+            await page.locator(selector).first().evaluate((node) => {
+                node.scrollIntoView({ block: 'center', behavior: 'smooth' });
+            });
+            await page.waitForTimeout(350);
+            return;
+        }
+        await page.locator(selector).first().scrollIntoViewIfNeeded({ timeout: 5000 });
+    }
+    async waitFor(condition) {
+        try {
+            const page = await this.browser.currentPage;
+            const stateMap = { visible: 'visible', attached: 'attached' };
+            await page.locator(condition.selector).waitFor({
+                state: stateMap[condition.state],
+                timeout: condition.timeoutMs,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async dismissOverlays() {
+        // Pass 1: Built-in cookie/widget dismissal (cookie-dismiss.ts)
+        const result = await this.browser.dismissOverlays();
+        if (result.dismissed)
+            return result;
+        // Pass 2: Playwright-level sweep for common accept/close buttons
+        // in cookie-like containers that the built-in module might miss
+        const page = await this.browser.currentPage;
+        const acceptPatterns = [
+            'button:has-text("Accept")',
+            'button:has-text("Accept all")',
+            'button:has-text("Accepter")',
+            'button:has-text("Tout accepter")',
+            'button:has-text("Got it")',
+            'button:has-text("I agree")',
+            'button:has-text("OK")',
+            '[role="button"]:has-text("Accept")',
+            '[role="button"]:has-text("Accept all")',
+        ];
+        for (const pattern of acceptPatterns) {
+            try {
+                const btn = page.locator(pattern).first();
+                if (await btn.isVisible({ timeout: 500 })) {
+                    // Check if the button is near the bottom of the viewport (likely a banner)
+                    const box = await btn.boundingBox();
+                    const viewport = page.viewportSize();
+                    if (box && viewport && box.y > viewport.height * 0.6) {
+                        await btn.click({ timeout: 2000 });
+                        await page.waitForTimeout(500);
+                        return { dismissed: true, method: `v2-sweep:${pattern}` };
+                    }
+                }
+            }
+            catch {
+                // Try next pattern
+            }
+        }
+        // Pass 3: Try Escape key for modal overlays
+        try {
+            await page.keyboard.press('Escape');
+            await page.waitForTimeout(300);
+        }
+        catch {
+            // Non-fatal
+        }
+        return result;
+    }
+    async takeScreenshot() {
+        return this.browser.takeScreenshot();
+    }
+    async takeElementScreenshot(selector) {
+        const { buffer } = await this.browser.screenshotBySelector(selector);
+        return buffer;
+    }
+    async takeCleanScreenshot() {
+        return this.browser.takeScreenshot();
+    }
+    async beginRecording(options) {
+        const page = await this.browser.currentPage;
+        if (!page.video()) {
+            throw new Error(`recording is not enabled for ${options.mediaMode} mode`);
+        }
+        const recordingDir = this.recordingDir
+            ?? await fs.mkdtemp(path.join(os.tmpdir(), 'autokap-v2-recording-'));
+        this.recording = {
+            mediaMode: options.mediaMode,
+            startedAt: Date.now(),
+            trimStartMs: Math.max(0, Date.now() - this.sessionStartedAt),
+            outputPath: path.join(recordingDir, `${options.mediaMode}.webm`),
+            finalized: false,
+        };
+        this.clipCursor = { currentPosition: null };
+        await this.seedClipCursor();
+    }
+    async endRecording() {
+        if (!this.recording) {
+            throw new Error('recording was not started');
+        }
+        if (this.recording.finalized) {
+            const buffer = await fs.readFile(this.recording.outputPath);
+            return {
+                buffer,
+                durationMs: Date.now() - this.recording.startedAt,
+                mimeType: 'video/webm',
+                trimStartMs: this.recording.trimStartMs,
+            };
+        }
+        const videoRef = this.browser.currentPage.video();
+        if (!videoRef) {
+            throw new Error('recording finalization failed: no Playwright video handle found');
+        }
+        await this.browser.closeContext();
+        await videoRef.saveAs(this.recording.outputPath);
+        this.recording.finalized = true;
+        this.clipCursor = null;
+        const buffer = await fs.readFile(this.recording.outputPath);
+        return {
+            buffer,
+            durationMs: Date.now() - this.recording.startedAt,
+            mimeType: 'video/webm',
+            trimStartMs: this.recording.trimStartMs,
+        };
+    }
+    async setLocale(locale) {
+        await this.browser.setLanguage(locale);
+    }
+    async setColorScheme(scheme) {
+        await this.browser.setColorScheme(scheme);
+    }
+    async reloadPage() {
+        await this.browser.reloadCurrentPage();
+    }
+    async writeStorageHint(params) {
+        return this.browser.writeStorageHintCandidate({
+            storageName: params.storage,
+            key: params.key,
+            candidate: params.value,
+            kind: params.kind,
+        });
+    }
+    async close() {
+        await this.browser.close();
+    }
+    async typeIntoLocator(locator, text, clearFirst) {
+        const page = await this.browser.currentPage;
+        await locator.waitFor({ state: 'visible', timeout: 5000 });
+        await locator.scrollIntoViewIfNeeded({ timeout: 5000 }).catch(() => undefined);
+        await this.moveClipCursorToLocator(locator);
+        await locator.click({ timeout: 5000 });
+        if (clearFirst) {
+            await page.keyboard.press('Control+A');
+        }
+        await page.waitForTimeout(70);
+        await humanType(page, text);
+    }
+    async seedClipCursor() {
+        if (!this.clipCursor)
+            return;
+        const page = await this.browser.currentPage;
+        const viewport = page.viewportSize();
+        if (!viewport)
+            return;
+        const startX = Math.round(viewport.width * (0.3 + Math.random() * 0.4));
+        const startY = Math.round(viewport.height * (0.3 + Math.random() * 0.4));
+        await page.mouse.move(startX, startY);
+        this.clipCursor.currentPosition = { x: startX, y: startY };
+        await page.waitForTimeout(60);
+    }
+    async moveClipCursorToViewportCenter() {
+        if (!this.clipCursor)
+            return;
+        const page = await this.browser.currentPage;
+        const viewport = page.viewportSize();
+        if (!viewport)
+            return;
+        await this.moveClipCursorToPoint({
+            x: Math.round(viewport.width / 2),
+            y: Math.round(viewport.height / 2),
+        }, { durationMs: 280, steps: 18 });
+    }
+    async moveClipCursorToLocator(locator) {
+        if (!this.clipCursor)
+            return;
+        await locator.waitFor({ state: 'visible', timeout: 5000 });
+        await locator.scrollIntoViewIfNeeded({ timeout: 5000 }).catch(() => undefined);
+        const page = await this.browser.currentPage;
+        const viewport = page.viewportSize();
+        const box = await locator.boundingBox();
+        if (!box || !viewport)
+            return;
+        await this.moveClipCursorToPoint(getHumanPointInBox(box, viewport));
+    }
+    async moveClipCursorToPoint(point, options) {
+        if (!this.clipCursor)
+            return;
+        const page = await this.browser.currentPage;
+        const from = this.clipCursor.currentPosition;
+        if (from) {
+            await moveMouse(page, from, point, options);
+        }
+        else {
+            await page.mouse.move(point.x, point.y);
+        }
+        this.clipCursor.currentPosition = point;
+    }
+}
+function describeResolveOptions(opts) {
+    const parts = [];
+    if (opts.selector)
+        parts.push(`selector="${opts.selector}"`);
+    if (opts.target?.text)
+        parts.push(`text="${opts.target.text}"`);
+    if (opts.target?.role)
+        parts.push(`role="${opts.target.role}"`);
+    if (opts.target?.label)
+        parts.push(`label="${opts.target.label}"`);
+    if (opts.target?.placeholder)
+        parts.push(`placeholder="${opts.target.placeholder}"`);
+    return parts.join(', ') || 'no target specified';
+}
+function getHumanPointInBox(box, viewport) {
+    const insetX = Math.min(Math.max(box.width * 0.2, 6), Math.max(6, box.width / 2));
+    const insetY = Math.min(Math.max(box.height * 0.2, 6), Math.max(6, box.height / 2));
+    const minX = box.x + insetX;
+    const maxX = box.x + Math.max(insetX, box.width - insetX);
+    const minY = box.y + insetY;
+    const maxY = box.y + Math.max(insetY, box.height - insetY);
+    const targetX = maxX <= minX ? box.x + box.width / 2 : randomBetween(minX, maxX);
+    const targetY = maxY <= minY ? box.y + box.height / 2 : randomBetween(minY, maxY);
+    return {
+        x: clampPoint(targetX, 4, viewport.width - 4),
+        y: clampPoint(targetY, 4, viewport.height - 4),
+    };
+}
+function randomBetween(min, max) {
+    return min + Math.random() * Math.max(0, max - min);
+}
+function clampPoint(value, min, max) {
+    return Math.round(Math.max(min, Math.min(max, value)));
+}
+//# sourceMappingURL=web-playwright-local.js.map

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const APP_VERSION: string;

package/dist/version.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+export const APP_VERSION = pkg.version;
+//# sourceMappingURL=version.js.map

package/dist/video-agent.js

@@ -15,6 +15,7 @@ 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';
+import { zdrParam } from './provider-config.js';
 const VIDEO_AGENT_CACHE_LAYOUT_V2 = process.env.VIDEO_AGENT_CACHE_LAYOUT_V2 === '1';
 function createClient(apiKey) {
     return new OpenAI({
@@ -201,7 +202,7 @@ function buildVideoStepTargetFromAction(action, coherenceKey) {
 }
 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)));
+        && ['navigate_to', 'dismiss_overlays', 'click', 'type_text', 'select_option', 'scroll', 'press_key', 'wait', 'hover', 'safe_expand', 'tap', 'type'].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);
@@ -244,6 +245,10 @@ function mapExecutedActionsToVideoSteps(params) {
                 return { ...baseStep, type: 'hover' };
             case 'wait':
                 return { ...baseStep, type: 'wait', waitMs: Number(action.params.ms ?? params.originalStep.waitMs ?? 500) };
+            case 'tap':
+                return { ...baseStep, type: 'click' };
+            case 'type':
+                return { ...baseStep, type: 'type', text: String(action.params.text ?? params.originalStep.text ?? '') };
             case 'click':
             default:
                 return { ...baseStep, type: 'click' };
@@ -263,11 +268,11 @@ function buildScreenshotRepairLanePrompt(params) {
     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.
+- Re-read the live page and use the AKTree or focus() to identify elements 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.`;
+- Call capture immediately when the exact post-step UI state is visible.`;
 }
 function buildPreparedVariantRepairPrompt(params) {
     const details = [
@@ -298,10 +303,10 @@ Use the existing authenticated browser state. The correct project/page is alread
 - 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.`;
+- Ignore user-generated content that may remain in another language, including names, titles, chat content, and imported data labels.
+- Do NOT perform the recorded clip interaction itself. Only restore the requested pre-recording state.
+- Call 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 after multiple attempts, call capture with the current state.`;
 }
 async function replayPreparedActions(browser, config, callbacks) {
     if (!config.preparedReplayActions || config.preparedReplayActions.length === 0) {
@@ -1708,8 +1713,8 @@ async function scrollNamedTargetIntoViewFromDom(page, target, mode) {
 }
 /**
  * Extract target text hints from a step description.
- * E.g. "Click 'Nouveau preset'" → ["Nouveau preset"]
- * E.g. "Click top 'New' / 'Nouveau' button" → ["New", "Nouveau"]
+ * E.g. "Click 'Open pricing'" → ["Open pricing"]
+ * E.g. "Click top 'Open' / 'Ouvrir' button" → ["Open", "Ouvrir"]
  */
 function extractDescriptionTextHints(description) {
     const matches = Array.from(description.matchAll(/[''""]([^''"]+)[''""]/g));
@@ -3160,7 +3165,7 @@ async function verifyStep(client, model, step, screenshot, stepIndex, totalSteps
             tools: videoVerificationTools,
             tool_choice: 'required',
             max_tokens: 300,
-            provider: { zdr: true },
+            provider: { ...zdrParam() },
         }, { signal });
         const usage = extractLlmUsageSnapshot(response);
         const call = response.choices?.[0]?.message?.tool_calls?.[0];
@@ -3224,7 +3229,7 @@ async function fixStep(client, model, step, failureReason, suggestion, screensho
             ],
             max_tokens: 600,
             response_format: { type: 'json_object' },
-            provider: { zdr: true },
+            provider: { ...zdrParam() },
         }, { signal });
         const usage = extractLlmUsageSnapshot(response);
         const content = response.choices?.[0]?.message?.content ?? '';
@@ -3289,7 +3294,7 @@ async function classifyVariantStateWithLLMFallback(client, model, browser, reque
                 }),
             },
         ],
-        provider: { zdr: true },
+        provider: { ...zdrParam() },
     }, { signal });
     const parsed = JSON.parse(response.choices?.[0]?.message?.content ?? '{}');
     return {
@@ -4404,7 +4409,7 @@ async function runDryRun(plan, config, client, callbacks, videoScript) {
 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 tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'screenshot-agent-video-'));
     const outputPath = path.join(tempDir, 'recording.webm');
     const startTime = Date.now();
     const executionSteps = deriveExecutionSteps(plan, config);

package/dist/video-planner.js

@@ -2,6 +2,7 @@ import OpenAI from 'openai';
 import { buildVideoPlannerSystemPrompt, buildVideoPlannerUserMessage, } from './video-prompts.js';
 export { observePlanningContext } from './video-observation.js';
 import { throwIfAborted } from './abort.js';
+import { zdrParam } from './provider-config.js';
 import { extractStepUsage } from './llm-usage.js';
 function createClient(apiKey) {
     return new OpenAI({
@@ -424,7 +425,7 @@ export async function planFromScript(script, url, model, apiKey, maxRetries = 2,
             messages,
             max_tokens: 4000,
             response_format: { type: 'json_object' },
-            provider: { zdr: true },
+            provider: { ...zdrParam() },
         }, { signal: abortSignal });
         lastResponse = response;
         const content = response.choices?.[0]?.message?.content ?? '';

package/dist/video-prompts.js

@@ -70,7 +70,7 @@ Given the failed step, the failure reason, a runtime page observation summary, a
 If a cookie banner, modal, sticky feedback widget, newsletter popup, or consent wall is blocking the intended interaction or making the frame unusable:
 - Add a \`dismiss_overlays\` step first
 - Then retry the intended action or continue with the next recovery strategy
-- Do NOT hide the product's own chat/assistant widget if the overall demo goal is to show that widget
+- Do NOT hide the site's own chat/support widget if the overall demo goal is to show that widget
 
 ### 1. Use direct navigation ONLY for technical preparation steps
 Direct \`navigate\` is allowed only when at least one of these is true:
@@ -330,7 +330,7 @@ You MUST respond with a single valid JSON object matching this exact structure:
 | assert_page | pageExpectation | timeoutMs |
 
 For \`target\` and \`toTarget\`, prefer this structured shape when the page has several similar controls:
-\`{"label":"New preset","labelMatchMode":"exact","role":"button","tag":"button","href":null,"selector":"button:has-text('New preset')","selectorAlternates":["[role='menuitem']:has-text('New preset')"],"containerLabel":"New menu"}\`
+\`{"label":"Open pricing","labelMatchMode":"exact","role":"button","tag":"button","href":null,"selector":"button:has-text('Open pricing')","selectorAlternates":["a:has-text('Pricing')","[role='menuitem']:has-text('Open pricing')"],"containerLabel":"Primary navigation"}\`
 Use \`coordinates\` only as a tie-breaker, never as the sole durable anchor when a label, href, role, or selector exists.
 
 For \`assert_page\`, use a JSON object like:
@@ -421,7 +421,7 @@ For \`key\` steps, Playwright key names are **case-sensitive**. Always use exact
 
 - This is a showcase video, not a QA trace. The viewer should only see intentional actions.
 - Use \`dismiss_overlays\` whenever a cookie banner, newsletter modal, consent wall, sticky feedback widget, or unrelated popup blocks the content.
-- Do NOT dismiss or hide the product's own chat/assistant/support widget if the user explicitly wants to demonstrate it.
+- Do NOT dismiss or hide the site's own chat/support widget if the user explicitly wants to demonstrate it.
 - Prefer stable navigation elements. Use direct navigation only for initial landing or hidden preparation.
 - Use \`select_option\` for real dropdown controls instead of brittle click chains when possible.
 - Keep the flow concise. Do not wander through irrelevant UI or perform redundant clicks.

package/dist/web-playwright-local.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Capture Agent — WebPlaywrightLocal RuntimeAdapter
+ *
+ * Thin adapter delegating to the existing Browser class from src/browser.ts.
+ * This is the first (and for now only) RuntimeAdapter implementation.
+ */
+import type { Browser } from './browser.js';
+import type { AKTree, VideoPageSignals } from './types.js';
+import type { RuntimeAdapter, ClickOptions, WaitCondition, RecordingOptions, RecordingResult } from './execution-types.js';
+import { type ResolveOptions } from './semantic-resolver.js';
+export declare class WebPlaywrightLocal implements RuntimeAdapter {
+    private browser;
+    private recordingDir?;
+    private readonly sessionStartedAt;
+    private recording;
+    private clipCursor;
+    constructor(browser: Browser, recordingDir?: string | undefined);
+    navigate(url: string): Promise<void>;
+    getCurrentUrl(): Promise<string>;
+    getAKTree(): Promise<AKTree>;
+    getPageSignals(): Promise<VideoPageSignals>;
+    click(selector: string, options?: ClickOptions): Promise<void>;
+    /**
+     * Click an element using semantic target resolution.
+     * Tries CSS selector first, falls back to Playwright semantic locators.
+     */
+    clickByTarget(opts: ResolveOptions): Promise<void>;
+    /**
+     * Type into an element using semantic target resolution.
+     */
+    typeByTarget(opts: ResolveOptions, text: string, clearFirst?: boolean): Promise<void>;
+    /**
+     * Wait for an element using semantic target resolution.
+     */
+    waitForTarget(opts: ResolveOptions, timeoutMs?: number): Promise<boolean>;
+    /**
+     * Scroll an element into view using semantic target resolution.
+     */
+    scrollIntoViewByTarget(opts: ResolveOptions): Promise<void>;
+    type(selector: string, text: string, clearFirst?: boolean): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    scroll(direction: 'up' | 'down' | 'left' | 'right', amount?: number): Promise<void>;
+    scrollIntoView(selector: string): Promise<void>;
+    waitFor(condition: WaitCondition): Promise<boolean>;
+    dismissOverlays(): Promise<{
+        dismissed: boolean;
+        method: string | null;
+    }>;
+    takeScreenshot(): Promise<Buffer>;
+    takeElementScreenshot(selector: string): Promise<Buffer>;
+    takeCleanScreenshot(): Promise<Buffer>;
+    beginRecording(options: RecordingOptions): Promise<void>;
+    endRecording(): Promise<RecordingResult>;
+    setLocale(locale: string): Promise<void>;
+    setColorScheme(scheme: 'light' | 'dark'): Promise<void>;
+    reloadPage(): Promise<void>;
+    writeStorageHint(params: {
+        storage: 'localStorage' | 'sessionStorage' | 'cookie';
+        key: string;
+        value: string;
+        kind: 'locale' | 'theme';
+    }): Promise<boolean>;
+    hover(selector: string): Promise<void>;
+    hoverByTarget(opts: ResolveOptions): Promise<void>;
+    selectOption(selector: string, option: {
+        label?: string;
+        value?: string;
+        index?: number;
+    }): Promise<void>;
+    check(selector: string, checked: boolean): Promise<void>;
+    doubleClick(selector: string): Promise<void>;
+    cloneElement(opts: {
+        sourceSelector: string;
+        containerSelector: string;
+        count: number;
+        removeSource?: boolean;
+    }): Promise<{
+        clonedCount: number;
+    }>;
+    setAttribute(opts: {
+        selector: string;
+        attribute: string;
+        value: string;
+    }): Promise<void>;
+    setTextContent(opts: {
+        selector: string;
+        text: string;
+    }): Promise<void>;
+    removeElement(opts: {
+        selector: string;
+    }): Promise<{
+        removedCount: number;
+    }>;
+    setInputValue(opts: {
+        selector: string;
+        value: string;
+    }): Promise<void>;
+    clickHidden(opts: {
+        selector: string;
+    }): Promise<void>;
+    serializeDom(selector?: string): Promise<{
+        html: string;
+        assetUrls: string[];
+        viewport: {
+            width: number;
+            height: number;
+        };
+        capturedAt: string;
+    }>;
+    serializeFragment(selector: string): Promise<{
+        html: string;
+        assetUrls: string[];
+        capturedAt: string;
+    }>;
+    extractFavicon(): Promise<{
+        buffer: Buffer;
+        mimeType: string;
+    } | null>;
+    close(): Promise<void>;
+    private typeIntoLocator;
+    private seedClipCursor;
+    private moveClipCursorToViewportCenter;
+    private moveClipCursorToLocator;
+    private moveClipCursorToPoint;
+    private emitClipClickPulse;
+}