autokap 1.0.6 → 1.0.8

package/dist/provider-config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared OpenRouter provider configuration.
+ *
+ * Zero Data Retention (ZDR) tells OpenRouter to only route requests to
+ * providers that guarantee they won't store or train on request data.
+ * Controlled by the ENABLE_ZDR environment variable (default: off).
+ */
+export declare function isZdrEnabled(): boolean;
+/** Build the `provider.zdr` fragment for OpenRouter requests. */
+export declare function zdrParam(): {
+    zdr?: true;
+};

package/dist/provider-config.js

@@ -0,0 +1,15 @@
+/**
+ * Shared OpenRouter provider configuration.
+ *
+ * Zero Data Retention (ZDR) tells OpenRouter to only route requests to
+ * providers that guarantee they won't store or train on request data.
+ * Controlled by the ENABLE_ZDR environment variable (default: off).
+ */
+export function isZdrEnabled() {
+    return process.env.ENABLE_ZDR === '1' || process.env.ENABLE_ZDR === 'true';
+}
+/** Build the `provider.zdr` fragment for OpenRouter requests. */
+export function zdrParam() {
+    return isZdrEnabled() ? { zdr: true } : {};
+}
+//# sourceMappingURL=provider-config.js.map

package/dist/recovery-chain.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Capture Agent — Recovery Chain
+ *
+ * Ordered recovery strategies when a deterministic opcode fails:
+ * 1. Deterministic retry (same opcode, fresh observation)
+ * 2. Selector memory lookup (known-good selectors from Supabase)
+ * 3. Alternative interaction (keyboard, JS dispatch, coordinates)
+ * 4. Targeted reload (reload page and retry)
+ * 5. LLM Healer (last resort)
+ */
+import type { ExecutionOpcode, RuntimeAdapter } from './execution-types.js';
+import type { RecoveryChain as IRecoveryChain, RecoveryAttemptResult, RecoveryAttemptOptions } from './opcode-runner.js';
+import { type HealerLLMProvider } from './llm-healer.js';
+export interface RecoveryChainOptions {
+    /** Selector memory: stepSignature -> known-good selectors */
+    selectorMemory?: Record<string, string[]>;
+    /** LLM provider for the healer (optional, disables healer if not provided) */
+    llmProvider?: HealerLLMProvider;
+    /** Max healer invocations per run. Default: 3 */
+    maxHealerInvocations?: number;
+    /** Full program steps for healer context */
+    programSteps?: ExecutionOpcode[];
+    /** Credentials for {{email}}/{{password}}/{{loginUrl}} substitution during recovery */
+    credentials?: {
+        email?: string;
+        password?: string;
+        loginUrl?: string;
+    };
+}
+export declare class RecoveryChainImpl implements IRecoveryChain {
+    private healer;
+    private selectorMemory;
+    private programSteps;
+    private credentials?;
+    constructor(options?: RecoveryChainOptions);
+    attempt(failedOpcode: ExecutionOpcode, opcodeIndex: number, adapter: RuntimeAdapter, options?: RecoveryAttemptOptions): Promise<RecoveryAttemptResult>;
+}

package/dist/recovery-chain.js

@@ -0,0 +1,350 @@
+/**
+ * Capture Agent — Recovery Chain
+ *
+ * Ordered recovery strategies when a deterministic opcode fails:
+ * 1. Deterministic retry (same opcode, fresh observation)
+ * 2. Selector memory lookup (known-good selectors from Supabase)
+ * 3. Alternative interaction (keyboard, JS dispatch, coordinates)
+ * 4. Targeted reload (reload page and retry)
+ * 5. LLM Healer (last resort)
+ */
+import { resolveSelector } from './selector-resolver.js';
+import { evaluatePostcondition } from './postcondition.js';
+import { LLMHealer } from './llm-healer.js';
+import { serializeAKTree } from './ak-tree.js';
+import { executeOpcodeCoreAction, substituteCredentialPlaceholders } from './opcode-actions.js';
+import { dismissAllOverlays } from './overlay-engine.js';
+import { logger } from './logger.js';
+export class RecoveryChainImpl {
+    healer;
+    selectorMemory;
+    programSteps;
+    credentials;
+    constructor(options = {}) {
+        this.selectorMemory = options.selectorMemory ?? {};
+        this.programSteps = options.programSteps ?? [];
+        this.credentials = options.credentials;
+        this.healer = options.llmProvider
+            ? new LLMHealer(options.llmProvider, { maxInvocations: options.maxHealerInvocations ?? 3 })
+            : null;
+    }
+    async attempt(failedOpcode, opcodeIndex, adapter, options = {}) {
+        const recovery = failedOpcode.recovery;
+        logger.debug(`[recovery ${opcodeIndex}] starting — remainingMs=${options.remainingTimeMs ?? '∞'}, flags=[retries=${recovery.retries},selMem=${recovery.useSelectorMemory},alt=${recovery.useAltInteraction},reload=${recovery.allowReload},healer=${recovery.allowHealer}]`);
+        // Strategy 1: Deterministic retry
+        const retryBudget = Math.max(0, Math.min(recovery.retries, options.maxDeterministicRetries ?? recovery.retries));
+        if (retryBudget > 0) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 1 (retry x${retryBudget})`);
+            const result = await retryOpcode(failedOpcode, adapter, retryBudget, options.remainingTimeMs, options.currentVariant, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 1 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 2: Selector memory + alternate selectors
+        if (recovery.useSelectorMemory && hasSelector(failedOpcode)) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 2 (selector memory)`);
+            const result = await trySelectorAlternatives(failedOpcode, opcodeIndex, adapter, this.selectorMemory, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 2 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 3: Alternative interaction methods
+        if (recovery.useAltInteraction && hasSelector(failedOpcode)) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 3 (alt interaction: keyboard, js_dispatch, coords)`);
+            const result = await tryAltInteraction(failedOpcode, adapter, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 3 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 4: Targeted reload
+        if (recovery.allowReload) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 4 (reload)`);
+            const result = await tryReload(failedOpcode, adapter, options.currentVariant, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 4 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 5: LLM Healer
+        if (recovery.allowHealer && this.healer && this.healer.remainingInvocations > 0) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 5 (LLM healer)`);
+            const result = await tryHealer(failedOpcode, opcodeIndex, adapter, this.healer, this.programSteps, options.currentVariant, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 5 → recovered=${result.recovered}, reason=${result.reason}`);
+            return result;
+        }
+        logger.debug(`[recovery ${opcodeIndex}] all strategies exhausted`);
+        return { recovered: false, reason: 'all recovery strategies exhausted' };
+    }
+}
+// ── Strategy 1: Deterministic retry ─────────────────────────────────
+async function retryOpcode(opcode, adapter, maxRetries, remainingTimeMs, currentVariant, credentials) {
+    const deadlineMs = typeof remainingTimeMs === 'number'
+        ? Date.now() + remainingTimeMs
+        : Number.POSITIVE_INFINITY;
+    for (let i = 0; i < maxRetries; i++) {
+        if (Date.now() >= deadlineMs) {
+            return { recovered: false, reason: 'retry budget exhausted by timeout' };
+        }
+        await sleep(500 * (i + 1)); // backoff
+        try {
+            await executeRawAction(opcode, adapter, currentVariant, credentials);
+            const postcondition = await evaluatePostcondition(adapter, clampPostconditionWait(opcode.postcondition, deadlineMs));
+            if (postcondition.passed) {
+                return { recovered: true, strategy: 'retry', reason: `retry ${i + 1}/${maxRetries} succeeded` };
+            }
+        }
+        catch {
+            // continue to next retry
+        }
+    }
+    return { recovered: false, reason: `${maxRetries} retries exhausted` };
+}
+// ── Strategy 2: Selector memory ─────────────────────────────────────
+async function trySelectorAlternatives(opcode, opcodeIndex, adapter, selectorMemory, credentials) {
+    if (!hasSelector(opcode)) {
+        return { recovered: false, reason: 'opcode has no selector' };
+    }
+    const selectorOpcode = opcode;
+    const primarySelector = selectorOpcode.selector ?? '';
+    const stepSignature = `${opcode.kind}:${primarySelector}`;
+    const resolved = await resolveSelector(adapter, {
+        primary: primarySelector,
+        fingerprint: selectorOpcode.fingerprint,
+        alternates: selectorOpcode.selectorAlternates,
+        selectorMemory,
+        stepSignature,
+        description: opcode.description,
+    });
+    if (!resolved || resolved.strategy === 'primary') {
+        return { recovered: false, reason: 'no alternative selectors found' };
+    }
+    // Try the resolved selector
+    try {
+        await executeWithSelector(opcode, adapter, resolved.selector, credentials);
+        const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+        if (postcondition.passed) {
+            return {
+                recovered: true,
+                strategy: 'selector_memory',
+                reason: `resolved via ${resolved.strategy}: "${resolved.selector}"`,
+            };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { recovered: false, reason: `resolved selector "${resolved.selector}" also failed` };
+}
+// ── Strategy 3: Alternative interaction ─────────────────────────────
+async function tryAltInteraction(opcode, adapter, _credentials) {
+    if (opcode.kind !== 'CLICK' || !opcode.selector) {
+        return { recovered: false, reason: 'alt interaction only for CLICK opcodes with selectors' };
+    }
+    const clickOpcode = opcode;
+    const sel = clickOpcode.selector;
+    const methods = [
+        { name: 'keyboard', options: { useKeyboard: true } },
+        { name: 'js_dispatch', options: { useJsDispatch: true } },
+    ];
+    for (const method of methods) {
+        try {
+            await adapter.click(sel, method.options);
+            await sleep(500);
+            const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+            if (postcondition.passed) {
+                return {
+                    recovered: true,
+                    strategy: 'alt_interaction',
+                    reason: `${method.name} interaction succeeded`,
+                };
+            }
+        }
+        catch {
+            // continue to next method
+        }
+    }
+    // Try coordinate-based click from AKTree
+    try {
+        const tree = await adapter.getAKTree();
+        const node = findInteractiveNodeBySelector(tree, sel);
+        if (node) {
+            const x = node.bounds.x + node.bounds.w / 2;
+            const y = node.bounds.y + node.bounds.h / 2;
+            await adapter.click(sel, { coordinates: { x, y } });
+            await sleep(500);
+            const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+            if (postcondition.passed) {
+                return {
+                    recovered: true,
+                    strategy: 'alt_interaction',
+                    reason: `coordinate click at (${x}, ${y}) succeeded`,
+                };
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { recovered: false, reason: 'all alternative interactions failed' };
+}
+// ── Strategy 4: Targeted reload ─────────────────────────────────────
+async function tryReload(opcode, adapter, currentVariant, credentials) {
+    try {
+        if (adapter.reloadPage) {
+            await adapter.reloadPage();
+        }
+        else {
+            const url = await adapter.getCurrentUrl();
+            await adapter.navigate(url);
+        }
+        await sleep(1000);
+        await dismissAllOverlays(adapter);
+        await executeRawAction(opcode, adapter, currentVariant, credentials);
+        const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+        if (postcondition.passed) {
+            return { recovered: true, strategy: 'reload', reason: 'reload + retry succeeded' };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { recovered: false, reason: 'reload + retry failed' };
+}
+// ── Strategy 5: LLM Healer ─────────────────────────────────────────
+async function tryHealer(failedOpcode, opcodeIndex, adapter, healer, programSteps, currentVariant, credentials) {
+    try {
+        const tree = await adapter.getAKTree();
+        const akTreeSerialized = serializeAKTree(tree);
+        const currentUrl = await adapter.getCurrentUrl();
+        let screenshot;
+        try {
+            screenshot = await adapter.takeScreenshot();
+        }
+        catch { /* optional */ }
+        // Get surrounding opcodes for context
+        const start = Math.max(0, opcodeIndex - 3);
+        const end = Math.min(programSteps.length, opcodeIndex + 4);
+        const surroundingOpcodes = programSteps.slice(start, end).filter((_, i) => start + i !== opcodeIndex);
+        const context = {
+            failedOpcode,
+            opcodeIndex,
+            akTreeSerialized,
+            currentUrl,
+            screenshot,
+            surroundingOpcodes,
+            errorMessage: `opcode ${failedOpcode.kind} failed after all deterministic recovery strategies`,
+        };
+        const result = await healer.heal(context);
+        if (result.healed && result.patch) {
+            // Execute the replacement opcode(s) to verify they work
+            for (const replacementOp of result.patch.replacementOpcodes) {
+                try {
+                    await executeRawAction(replacementOp, adapter, currentVariant, credentials);
+                }
+                catch (err) {
+                    return {
+                        recovered: false,
+                        llmResult: result.llmResult,
+                        reason: `healer patch failed during execution: ${err instanceof Error ? err.message : String(err)}`,
+                    };
+                }
+            }
+            // Verify the last replacement's postcondition
+            const lastOp = result.patch.replacementOpcodes[result.patch.replacementOpcodes.length - 1];
+            const postcondition = await evaluatePostcondition(adapter, lastOp.postcondition);
+            if (postcondition.passed) {
+                return {
+                    recovered: true,
+                    strategy: 'healer',
+                    patch: result.patch,
+                    llmResult: result.llmResult,
+                    reason: result.reason,
+                };
+            }
+            return {
+                recovered: false,
+                llmResult: result.llmResult,
+                reason: `healer patch executed but postcondition failed: ${postcondition.reason}`,
+            };
+        }
+        return { recovered: false, llmResult: result.llmResult, reason: result.reason };
+    }
+    catch (err) {
+        return {
+            recovered: false,
+            reason: `healer error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+// ── Shared helpers ──────────────────────────────────────────────────
+function hasSelector(opcode) {
+    return 'selector' in opcode && typeof opcode.selector === 'string' && !!opcode.selector;
+}
+async function executeRawAction(opcode, adapter, currentVariant, credentials) {
+    const result = await executeOpcodeCoreAction(opcode, adapter, { currentVariant, credentials });
+    if (!result.success) {
+        throw new Error(result.error ?? `opcode ${opcode.kind} could not be replayed`);
+    }
+}
+async function executeWithSelector(opcode, adapter, newSelector, credentials) {
+    switch (opcode.kind) {
+        case 'CLICK':
+            await adapter.click(newSelector, opcode.button ? { button: opcode.button } : undefined);
+            break;
+        case 'TYPE': {
+            const text = substituteCredentialPlaceholders(opcode.text, credentials);
+            await adapter.type(newSelector, text, opcode.clearFirst);
+            break;
+        }
+        case 'HOVER':
+            if (!adapter.hover)
+                throw new Error('adapter does not support HOVER');
+            await adapter.hover(newSelector);
+            break;
+        case 'SELECT_OPTION':
+            if (!adapter.selectOption)
+                throw new Error('adapter does not support SELECT_OPTION');
+            await adapter.selectOption(newSelector, {
+                label: opcode.optionLabel,
+                value: opcode.optionValue,
+                index: opcode.optionIndex,
+            });
+            break;
+        case 'CHECK':
+            if (!adapter.check)
+                throw new Error('adapter does not support CHECK');
+            await adapter.check(newSelector, opcode.checked);
+            break;
+        case 'DOUBLE_CLICK':
+            if (!adapter.doubleClick)
+                throw new Error('adapter does not support DOUBLE_CLICK');
+            await adapter.doubleClick(newSelector);
+            break;
+        default:
+            throw new Error(`cannot swap selector for opcode kind: ${opcode.kind}`);
+    }
+}
+function findInteractiveNodeBySelector(tree, selector) {
+    function walk(node) {
+        if (node.visible && node.interactive && node.sourceRef.includes(selector.replace(/[[\]"#.]/g, ''))) {
+            return node;
+        }
+        for (const child of node.children) {
+            const found = walk(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    return walk(tree.root);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function clampPostconditionWait(spec, deadlineMs) {
+    const remainingTimeMs = Math.max(1, deadlineMs - Date.now());
+    return {
+        ...spec,
+        waitMs: Math.max(1, Math.min(spec.waitMs ?? remainingTimeMs, remainingTimeMs)),
+    };
+}
+//# sourceMappingURL=recovery-chain.js.map

package/dist/remote-browser.d.ts

@@ -0,0 +1,215 @@
+/**
+ * RemoteBrowser — Server-side proxy that mirrors the Browser interface
+ * but forwards every method call to a remote CLI via WebSocket.
+ *
+ * Used by the WS server to control a Playwright browser running on the user's machine.
+ */
+import type { WebSocket } from 'ws';
+import type { PageState, PageStateLite, InteractiveElement, BrowserStorageState, BrowserSessionStorageState, VideoPageSignals, OutscaleConfig, SelectorValidationResult, AKTree, AKNode, AKNodeRuntimeIndexEntry, FocusQuery } from './types.js';
+import type { BrowserObservation, BrowserReaction, BrowserSelectorProbe, BrowserStorageHintWriteParams, BrowserVerificationBundle, BrowserVideoVerificationBundle } from './browser.js';
+export interface WsCommand {
+    id: string;
+    method: string;
+    params: Record<string, unknown>;
+}
+export interface WsResult {
+    id: string;
+    result?: unknown;
+    error?: string;
+}
+export interface WsEvent {
+    type: 'done' | 'error' | 'progress' | 'live_url';
+    message?: string;
+    url?: string;
+    summary?: {
+        successes: number;
+        total: number;
+    };
+}
+export declare const REMOTE_BROWSER_PROTOCOL_VERSION = 3;
+export interface RemoteBrowserClientInfo {
+    version?: string;
+    protocolVersion?: number;
+}
+export interface WsClientHello {
+    type: 'client_hello';
+    client: RemoteBrowserClientInfo;
+    apiKey?: string;
+}
+export declare function buildRemoteBrowserClientHello(version: string, apiKey?: string): WsClientHello;
+export declare function getRemoteBrowserCompatibilityError(client: RemoteBrowserClientInfo | null | undefined): string | null;
+/**
+ * Lightweight proxy for `browser.currentPage` — only exposes the methods
+ * that `runAgent` actually calls: `.url()`, `.viewportSize()`, `.title()`.
+ */
+declare class RemotePageProxy {
+    private callFn;
+    constructor(callFn: (method: string, params: Record<string, unknown>) => Promise<unknown>);
+    url(): string;
+    viewportSize(): {
+        width: number;
+        height: number;
+    } | null;
+    title(): Promise<string>;
+    _cachedUrl: string;
+    _cachedViewport: {
+        width: number;
+        height: number;
+    } | null;
+    _sync(): Promise<void>;
+}
+export declare class RemoteBrowser {
+    private ws;
+    private pending;
+    private idCounter;
+    private _pageProxy;
+    /** Proxy for browser.currentPage — provides url(), viewportSize(), title() */
+    get currentPage(): RemotePageProxy;
+    constructor(ws: WebSocket);
+    launch(): Promise<void>;
+    close(): Promise<void>;
+    closeContext(): Promise<void>;
+    recreateContext(options: {
+        viewport?: {
+            width: number;
+            height: number;
+        };
+        deviceScaleFactor?: number;
+        lang?: string;
+        colorScheme?: 'light' | 'dark';
+        storageState?: BrowserStorageState;
+    }): Promise<void>;
+    setDeviceScaleFactor(deviceScaleFactor: number): Promise<void>;
+    navigateTo(url: string): Promise<void>;
+    addCookies(cookies: Array<Record<string, unknown>>): Promise<void>;
+    takeScreenshot(): Promise<Buffer>;
+    takeScreenshotForAI(options?: {
+        timeoutMs?: number;
+    }): Promise<Buffer>;
+    screenshotElement(index: number, padding?: number): Promise<Buffer>;
+    screenshotRegion(x: number, y: number, width: number, height: number, padding?: number): Promise<Buffer>;
+    screenshotBySelector(selector: string, outscale?: OutscaleConfig | number): Promise<{
+        buffer: Buffer;
+        validation: SelectorValidationResult;
+    }>;
+    screenshotByRegion(region: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, outscale?: OutscaleConfig | number): Promise<Buffer>;
+    getPageState(opts?: {
+        skipAnnotation?: boolean;
+    }): Promise<PageState>;
+    getPageStateLite(): Promise<PageStateLite>;
+    getAccessibilityTree(options?: {
+        timeoutMs?: number;
+    }): Promise<string>;
+    getInteractiveElements(options?: {
+        timeoutMs?: number;
+    }): Promise<InteractiveElement[]>;
+    getSimplifiedDOM(): Promise<string>;
+    captureObservation(): Promise<BrowserObservation>;
+    capturePageSignals(options?: {
+        timeoutMs?: number;
+    }): Promise<VideoPageSignals>;
+    captureVerificationBundle(options?: {
+        settleMs?: number;
+        maxAttempts?: number;
+    }): Promise<BrowserVerificationBundle>;
+    captureVideoVerificationBundle(options?: {
+        settleMs?: number;
+        maxAttempts?: number;
+        helperTimeoutMs?: number;
+    }): Promise<BrowserVideoVerificationBundle>;
+    clickByIndex(index: number): Promise<void>;
+    clickBySelector(selector: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    clickByCoordinates(x: number, y: number): Promise<void>;
+    hoverByIndex(index: number): Promise<void>;
+    hoverBySelector(selector: string): Promise<void>;
+    hoverByCoordinates(x: number, y: number): Promise<void>;
+    typeText(text: string, options?: {
+        index?: number;
+        selector?: string;
+        clearFirst?: boolean;
+    }): Promise<void>;
+    selectOption(options: {
+        index?: number;
+        selector?: string;
+        optionLabel?: string;
+        optionValue?: string;
+        optionIndex?: number;
+    }): Promise<void>;
+    scroll(direction: string, amount?: number, selector?: string): Promise<void>;
+    scrollElementIntoView(index: number, options?: {
+        align?: 'start' | 'center' | 'end';
+        margin?: number;
+    }): Promise<void>;
+    safeExpand(options: {
+        index?: number;
+        selector?: string;
+        expectedText?: string;
+        expectedSelector?: string;
+    }): Promise<void>;
+    pressKey(key: string): Promise<void>;
+    searchText(query: string): Promise<Array<Record<string, unknown>>>;
+    getAKTree(): Promise<AKTree>;
+    resolveAKNode(nodeId: string, options?: {
+        reparse?: boolean;
+    }): Promise<AKNodeRuntimeIndexEntry | null>;
+    tapNode(nodeId: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    typeIntoNode(nodeId: string, text: string, options?: {
+        clearFirst?: boolean;
+    }): Promise<void>;
+    captureNode(nodeId?: string): Promise<Buffer>;
+    focusTree(query: FocusQuery): Promise<{
+        tree: AKTree;
+        serialized: string;
+        matches: AKNode[];
+    }>;
+    centerNodeInView(centerNodeId: string, options?: {
+        containerNodeId?: string;
+        offset?: number;
+    }): Promise<void>;
+    waitForPageReaction(before?: BrowserObservation, options?: {
+        timeoutMs?: number;
+        settleMs?: number;
+        idleGraceMs?: number;
+    }): Promise<BrowserReaction>;
+    wait(ms: number): Promise<void>;
+    dismissOverlays(): Promise<{
+        dismissed: boolean;
+        method: string | null;
+    }>;
+    setColorScheme(scheme: 'light' | 'dark'): Promise<void>;
+    setLanguage(lang: string): Promise<void>;
+    resizeViewport(width: number, height: number): Promise<void>;
+    forceLoadLazyImages(options?: {
+        timeout?: number;
+    }): Promise<void>;
+    exportStorageState(): Promise<BrowserStorageState>;
+    exportSessionStorage(): Promise<BrowserSessionStorageState>;
+    reloadCurrentPage(options?: {
+        waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
+        timeout?: number;
+    }): Promise<void>;
+    writeStorageHintCandidate(params: BrowserStorageHintWriteParams): Promise<boolean>;
+    probeSelector(selector: string): Promise<BrowserSelectorProbe | null>;
+    prepareSessionStorage(bundle: BrowserSessionStorageState | undefined, options?: {
+        replace?: boolean;
+    }): Promise<void>;
+    observeNetworkRequests(url: string, waitMs?: number): Promise<Array<Record<string, unknown>>>;
+    setupRouteInterception(mocks: Array<Record<string, unknown>>): Promise<void>;
+    clearRouteInterception(): Promise<void>;
+    /** Explicit allowlist of callable RPC methods — defense-in-depth. */
+    private static readonly ALLOWED_METHODS;
+    private call;
+    private callAndSyncPageInfo;
+    sendEvent(event: WsEvent): void;
+    destroy(): void;
+}
+export {};