@silasfmartins/testhub 1.0.0

package/dist/src/utils/testRecovery/ResilientPlaywright.js

@@ -0,0 +1,715 @@
+import * as fs from "fs";
+import { analyzeFailure, markSuccess, reportResult, inferActionType, getRecoveryMetadata, } from "./TestRecoveryClient.js";
+import { TestContext } from "../../testContext/TestContext.js";
+import { Logger } from "../Logger.js";
+const HUB_MIN_CONFIDENCE = Number(process.env.AUTOCORE_RECOVERY_MIN_CONFIDENCE || "0.7");
+const HUB_MAX_RETRIES = Number(process.env.AUTOCORE_RECOVERY_MAX_RETRIES || "8");
+/**
+ * Captura o HTML completo da página atual
+ * Use como fallback quando MCP não está disponível
+ *
+ * @example
+ * ```typescript
+ * const html = await capturePageHtml(page)
+ * // Enviar para analyzeFailure({ ..., pageHtml: html })
+ * ```
+ */
+export async function capturePageHtml(page) {
+    try {
+        return await page.content();
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Captura screenshot da página em Base64
+ * Útil para auditoria visual
+ *
+ * @example
+ * ```typescript
+ * const screenshot = await captureScreenshotBase64(page)
+ * // Enviar para analyzeFailure({ ..., screenshot })
+ * ```
+ */
+export async function captureScreenshotBase64(page) {
+    try {
+        const buffer = await page.screenshot({ type: "png" });
+        return buffer.toString("base64");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Extrai contexto do elemento para melhorar inferência de actionType
+ */
+async function extractElementContext(page, xpath) {
+    try {
+        return await page.evaluate((selector) => {
+            const el = document.evaluate(selector, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+            if (!el)
+                return {};
+            return {
+                text: el.textContent?.trim().slice(0, 100) || undefined,
+                role: el.getAttribute("role") || undefined,
+                ariaLabel: el.getAttribute("aria-label") || undefined,
+                type: el.type || el.tagName.toLowerCase(),
+            };
+        }, xpath);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Extrai estrutura básica da página para envio ao Test Recovery
+ * (fallback quando MCP não está disponível)
+ */
+async function extractBasicPageStructure(page) {
+    try {
+        return await page.evaluate(() => {
+            // Helper: coleta elementos de um root (document ou shadowRoot)
+            const collectFromRoot = (root, depth = 0) => {
+                const btns = [];
+                const inps = [];
+                const lks = [];
+                if (depth > 3)
+                    return { btns, inps, lks }; // Limitar profundidade de Shadow DOM
+                const queryAll = (sel) => {
+                    try {
+                        return Array.from(root.querySelectorAll(sel));
+                    }
+                    catch {
+                        return [];
+                    }
+                };
+                queryAll('button, [role="button"], input[type="button"], input[type="submit"]')
+                    .slice(0, 30)
+                    .forEach((el) => {
+                    btns.push({
+                        tag: el.tagName.toLowerCase(),
+                        text: el.textContent?.trim().slice(0, 100) || "",
+                        id: el.id || undefined,
+                        className: el.className || undefined,
+                        ariaLabel: el.getAttribute("aria-label") || undefined,
+                        dataTestId: el.getAttribute("data-testid") || undefined,
+                    });
+                });
+                queryAll("input, textarea, select")
+                    .slice(0, 30)
+                    .forEach((el) => {
+                    const input = el;
+                    inps.push({
+                        tag: el.tagName.toLowerCase(),
+                        type: input.type || undefined,
+                        name: input.name || undefined,
+                        id: el.id || undefined,
+                        placeholder: input.placeholder || undefined,
+                        ariaLabel: el.getAttribute("aria-label") || undefined,
+                        dataTestId: el.getAttribute("data-testid") || undefined,
+                    });
+                });
+                queryAll("a[href]")
+                    .slice(0, 30)
+                    .forEach((el) => {
+                    lks.push({
+                        text: el.textContent?.trim().slice(0, 100) || "",
+                        href: el.href || undefined,
+                        id: el.id || undefined,
+                        ariaLabel: el.getAttribute("aria-label") || undefined,
+                    });
+                });
+                // 🔄 Pierce Shadow DOM: buscar em shadowRoots de Custom Elements
+                queryAll("*").forEach((el) => {
+                    if (el.shadowRoot) {
+                        const shadow = collectFromRoot(el.shadowRoot, depth + 1);
+                        btns.push(...shadow.btns);
+                        inps.push(...shadow.inps);
+                        lks.push(...shadow.lks);
+                    }
+                });
+                return { btns, inps, lks };
+            };
+            const result = collectFromRoot(document);
+            return {
+                buttons: result.btns.slice(0, 50),
+                inputs: result.inps.slice(0, 50),
+                links: result.lks.slice(0, 50),
+                elements: [],
+            };
+        });
+    }
+    catch {
+        return { buttons: [], inputs: [], links: [], elements: [] };
+    }
+}
+class PlaywrightTestRecovery {
+    sessionId;
+    systemName;
+    environment;
+    constructor(sessionId, systemName, environment) {
+        this.sessionId = sessionId || TestContext.getOrCreateSessionId();
+        this.systemName = systemName;
+        this.environment = environment;
+    }
+    async recoverFromFailure(page, xpath, errorType, actionType, context) {
+        const url = page.url();
+        try {
+            // Captura estrutura da página para envio ao backend
+            const pageStructure = await extractBasicPageStructure(page);
+            // Captura HTML como fallback caso pageStructure esteja vazio
+            let pageHtml;
+            const hasContent = pageStructure &&
+                ((pageStructure.buttons?.length ?? 0) > 0 ||
+                    (pageStructure.inputs?.length ?? 0) > 0 ||
+                    (pageStructure.links?.length ?? 0) > 0);
+            if (!hasContent) {
+                try {
+                    const html = await page.content();
+                    pageHtml =
+                        html.length > 50000
+                            ? html.substring(0, 50000) + "... (truncated)"
+                            : html;
+                }
+                catch { }
+            }
+            // Enriquecer contexto com informações do elemento
+            const elementContext = await extractElementContext(page, xpath);
+            const enrichedContext = {
+                ...elementContext,
+                ...context,
+                originalMethod: context?.originalMethod || actionType,
+            };
+            // Se actionType não foi fornecido ou é genérico, tenta inferir
+            const finalActionType = actionType ||
+                inferActionType(xpath, enrichedContext);
+            const meta = getRecoveryMetadata();
+            const body = {
+                url,
+                failedXPath: xpath,
+                errorType,
+                actionType: finalActionType,
+                sessionId: this.sessionId,
+                systemName: this.systemName,
+                environment: this.environment,
+                executionSource: meta.executionSource,
+                testCaseName: meta.testCaseName,
+                testCaseId: meta.testCaseId,
+                testMethodName: meta.testMethodName,
+                context: enrichedContext,
+                pageStructure,
+                pageHtml,
+            };
+            const result = await analyzeFailure(body);
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    async markSuccess(attempt) {
+        await markSuccess(this.sessionId, attempt);
+    }
+}
+export class ResilientPlaywright {
+    recovery;
+    page;
+    constructor(page, sessionId, systemName, environment) {
+        this.page = page;
+        const sid = sessionId || TestContext.getOrCreateSessionId();
+        this.recovery = new PlaywrightTestRecovery(sid, systemName, environment);
+    }
+    detectErrorType(error) {
+        const message = error?.message?.toLowerCase() ?? "";
+        if (message.includes("strict mode violation") ||
+            message.includes("multiple elements")) {
+            return "multiple_elements";
+        }
+        if (message.includes("timeout") || message.includes("timed out")) {
+            return "timeout";
+        }
+        if (message.includes("detached") || message.includes("stale")) {
+            return "stale_element";
+        }
+        return "not_found";
+    }
+    /** Tracks whether we switched into a frame during recovery */
+    _inRecoveryFrame = false;
+    async executeAction(action) {
+        if (!action)
+            return;
+        switch (action.type) {
+            case "wait":
+                await this.page.waitForTimeout(action.waitMs || 2000);
+                break;
+            case "click_other":
+                if (action.selector)
+                    await this.page.locator(action.selector).click();
+                break;
+            case "navigate":
+                if (action.url)
+                    await this.page.goto(action.url);
+                break;
+            case "refresh":
+                await this.page.reload();
+                break;
+            case "switch_frame":
+                if (action.selector) {
+                    try {
+                        // Try using WebActions.switchTo if available
+                        const mod = await import("../../playwright/WebActions.js").catch(() => null);
+                        const WebActions = mod ? mod.WebActions : null;
+                        if (WebActions && typeof WebActions.switchTo === "function") {
+                            await WebActions.switchTo(action.selector, "Recovery frame switch", false);
+                        }
+                        else {
+                            // Fallback: use Playwright frameLocator directly
+                            const frame = this.page.frameLocator(action.selector);
+                            // Validate frame exists by trying to locate something inside it
+                            await frame
+                                .locator("body")
+                                .waitFor({ timeout: 5000 })
+                                .catch(() => { });
+                        }
+                        this._inRecoveryFrame = true;
+                    }
+                    catch (e) {
+                        Logger.warning(`[ResilientPlaywright] switch_frame falhou para ${action.selector}: ${e}`);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    /**
+     * Retorna ao contexto default após switch_frame de recovery
+     */
+    async switchToDefaultIfNeeded() {
+        if (!this._inRecoveryFrame)
+            return;
+        try {
+            const mod = await import("../../playwright/WebActions.js").catch(() => null);
+            const WebActions = mod ? mod.WebActions : null;
+            if (WebActions && typeof WebActions.switchToDefault === "function") {
+                await WebActions.switchToDefault("Recovery frame switch back", false);
+            }
+        }
+        catch { }
+        this._inRecoveryFrame = false;
+    }
+    /**
+     * 🔄 Força atualização/estabilização do DOM antes de re-tentar localizar elementos.
+     * Essencial para SPAs (ex.: Salesforce Lightning/Vlocity) que recriam Shadow DOM a cada interação.
+     *
+     * 1. waitForLoadState('domcontentloaded')
+     * 2. Force reflow + aguardar Custom Elements pendentes (whenDefined)
+     * 3. requestAnimationFrame + microtask cycle
+     *
+     * @param {number} [stabilityMs=300] Tempo mínimo em ms para considerar o DOM estável.
+     */
+    /** Timestamp do último refreshDOM (debounce) */
+    _lastDOMRefreshTime = 0;
+    async refreshDOM(stabilityMs = 300) {
+        // 🛡️ Feature toggle
+        if (process.env.AUTOCORE_REFRESH_DOM_BEFORE_ACTION === "false")
+            return;
+        // 🛡️ Debounce: pular se chamado dentro do cooldown
+        const now = Date.now();
+        const cooldown = Number(process.env.AUTOCORE_DOM_REFRESH_COOLDOWN_MS || "200");
+        if (now - this._lastDOMRefreshTime < cooldown)
+            return;
+        this._lastDOMRefreshTime = now;
+        try {
+            await this.page
+                .waitForLoadState("domcontentloaded", { timeout: 3000 })
+                .catch(() => { });
+            await this.page
+                .evaluate((waitMs) => {
+                return new Promise((resolve) => {
+                    void document.body?.offsetHeight;
+                    const waitForCustomElements = () => {
+                        return new Promise((res) => {
+                            if (typeof customElements !== "undefined" &&
+                                customElements.whenDefined) {
+                                const customTags = new Set();
+                                document.querySelectorAll("*").forEach((el) => {
+                                    const tag = el.tagName.toLowerCase();
+                                    if (tag.includes("-"))
+                                        customTags.add(tag);
+                                });
+                                const promises = [];
+                                let count = 0;
+                                for (const tag of customTags) {
+                                    if (count++ >= 10)
+                                        break;
+                                    promises.push(customElements
+                                        .whenDefined(tag)
+                                        .catch(() => class {
+                                    }));
+                                }
+                                if (promises.length) {
+                                    Promise.race([
+                                        Promise.all(promises),
+                                        new Promise((r) => setTimeout(r, 500)),
+                                    ]).then(() => res());
+                                }
+                                else {
+                                    res();
+                                }
+                            }
+                            else {
+                                res();
+                            }
+                        });
+                    };
+                    waitForCustomElements().then(() => {
+                        requestAnimationFrame(() => {
+                            void document.body?.offsetHeight;
+                            setTimeout(() => resolve(), Math.max(50, waitMs));
+                        });
+                    });
+                });
+            }, stabilityMs)
+                .catch(() => { });
+            await this.page
+                .waitForTimeout(Math.max(100, stabilityMs - 200))
+                .catch(() => { });
+        }
+        catch {
+            // refreshDOM é best-effort
+        }
+    }
+    /**
+     * Loop genérico de recovery com ordem recomendada (v2.7.43):
+     * 1. Executar actions[] (incluindo switch_frame)
+     * 2. Tentar suggestedXPath
+     * 3. Tentar alternatives[] (todas, até o limite de retries)
+     * 4. Chamar report-result com sucesso/falha (prioriza logId)
+     * 5. Se sucesso com confiança >= 0.7, chamar auto-fix-local
+     * 6. Gerenciar contexto de frame (switchToDefault quando necessário)
+     */
+    async withRecoveryLoop(initialXPath, actionType, executor, options, extraContext) {
+        const maxRetries = options?.retries ?? HUB_MAX_RETRIES;
+        const meta = getRecoveryMetadata();
+        let xpath = initialXPath;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // 🔄 Refresh DOM antes de CADA tentativa (Shadow DOM/LWC pode ter recriado elementos)
+                await this.refreshDOM(attempt === 1 ? 150 : 300);
+                // Garantir contexto de frame limpo a cada tentativa
+                await this.switchToDefaultIfNeeded();
+                await executor(xpath);
+                if (attempt > 1)
+                    await this.recovery.markSuccess(attempt);
+                return;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (attempt >= maxRetries)
+                    break;
+                // 🔄 Refresh DOM imediato após falha — capturar estado mais recente do Shadow DOM
+                await this.refreshDOM(200);
+                const errorType = this.detectErrorType(lastError);
+                const suggestion = await this.recovery.recoverFromFailure(this.page, xpath, errorType, actionType, extraContext);
+                if (!suggestion?.analysis)
+                    continue;
+                const { suggestedXPath, confidence, alternatives } = suggestion.analysis;
+                if (!suggestedXPath || confidence < HUB_MIN_CONFIDENCE) {
+                    // Reportar falha mesmo com baixa confiança
+                    try {
+                        await reportResult({
+                            logId: suggestion.logId,
+                            sessionId: TestContext.getOrCreateSessionId(),
+                            xpath: suggestedXPath,
+                            attemptNumber: attempt,
+                            success: false,
+                            recoverySource: "framework",
+                            executionSource: meta.executionSource,
+                            testCaseName: meta.testCaseName,
+                            testCaseId: meta.testCaseId,
+                            testMethodName: meta.testMethodName,
+                        });
+                    }
+                    catch { }
+                    continue;
+                }
+                // 1) Executar actions[] (incluindo switch_frame se vier)
+                if (suggestion.actions?.length) {
+                    for (const a of suggestion.actions)
+                        await this.executeAction(a);
+                }
+                // 2) Tentar suggestedXPath
+                try {
+                    await this.refreshDOM(200);
+                    await executor(suggestedXPath);
+                    // Sucesso! Reportar e opcionalmente auto-fix
+                    await this.switchToDefaultIfNeeded();
+                    try {
+                        await reportResult({
+                            logId: suggestion.logId,
+                            sessionId: TestContext.getOrCreateSessionId(),
+                            xpath: suggestedXPath,
+                            attemptNumber: attempt + 1,
+                            success: true,
+                            autoFixed: false,
+                            recoverySource: "framework",
+                            executionSource: meta.executionSource,
+                            testCaseName: meta.testCaseName,
+                            testCaseId: meta.testCaseId,
+                            testMethodName: meta.testMethodName,
+                        });
+                    }
+                    catch { }
+                    // Auto-fix local se confiança >= 0.7 e autoFixAvailable
+                    if (suggestion.analysis.autoFixAvailable && confidence >= 0.7) {
+                        await this.triggerAutoFixLocal(initialXPath, suggestedXPath, confidence, suggestion.logId).catch(() => { });
+                    }
+                    await this.recovery.markSuccess(attempt + 1);
+                    return;
+                }
+                catch {
+                    // suggestedXPath falhou, tentar alternatives
+                }
+                // 3) Tentar alternatives[]
+                if (alternatives?.length) {
+                    let found = false;
+                    for (const alt of alternatives) {
+                        attempt++;
+                        if (attempt > maxRetries)
+                            break;
+                        try {
+                            await this.switchToDefaultIfNeeded();
+                            // 🔄 Refresh DOM antes de cada alternativa
+                            await this.refreshDOM(200);
+                            // Re-executar actions de switch_frame antes de cada alternativa
+                            if (suggestion.actions?.length) {
+                                for (const a of suggestion.actions) {
+                                    if (a.type === "switch_frame")
+                                        await this.executeAction(a);
+                                }
+                            }
+                            await executor(alt);
+                            // Sucesso com alternativa!
+                            await this.switchToDefaultIfNeeded();
+                            try {
+                                await reportResult({
+                                    logId: suggestion.logId,
+                                    sessionId: TestContext.getOrCreateSessionId(),
+                                    xpath: alt,
+                                    attemptNumber: attempt,
+                                    success: true,
+                                    autoFixed: false,
+                                    recoverySource: "framework",
+                                    executionSource: meta.executionSource,
+                                    testCaseName: meta.testCaseName,
+                                    testCaseId: meta.testCaseId,
+                                    testMethodName: meta.testMethodName,
+                                });
+                            }
+                            catch { }
+                            if (suggestion.analysis.autoFixAvailable && confidence >= 0.7) {
+                                await this.triggerAutoFixLocal(initialXPath, alt, confidence, suggestion.logId).catch(() => { });
+                            }
+                            await this.recovery.markSuccess(attempt);
+                            found = true;
+                            break;
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    if (found)
+                        return;
+                }
+                // Nenhum candidato funcionou, reportar falha
+                await this.switchToDefaultIfNeeded();
+                try {
+                    await reportResult({
+                        logId: suggestion.logId,
+                        sessionId: TestContext.getOrCreateSessionId(),
+                        xpath: suggestedXPath,
+                        attemptNumber: attempt + 1,
+                        success: false,
+                        recoverySource: "framework",
+                        executionSource: meta.executionSource,
+                        testCaseName: meta.testCaseName,
+                        testCaseId: meta.testCaseId,
+                        testMethodName: meta.testMethodName,
+                    });
+                }
+                catch { }
+                // Atualizar xpath para próxima iteração do loop principal
+                xpath = suggestedXPath;
+            }
+        }
+        await this.switchToDefaultIfNeeded();
+        throw lastError || new Error(`${actionType} failed after all retries`);
+    }
+    /**
+     * Dispara auto-fix-local em background (v2.7.44)
+     * Não bloqueia o fluxo de execução
+     *
+     * Prioriza chamada via MCP local (fix_xpath_in_attributes) quando disponível.
+     * Fallback para HTTP backend se MCP não estiver acessível.
+     */
+    async triggerAutoFixLocal(oldXPath, newXPath, confidence, _logId) {
+        try {
+            const { testRecoveryHelper, getRecoveryMetadata: getMeta } = await import("./TestRecoveryClient.js");
+            const { fixXPathViaLocalMcp } = await import("../McpLocalClient.js");
+            const projectRoot = testRecoveryHelper.getProjectRoot() ||
+                process.env.AUTOCORE_PROJECT_ROOT ||
+                process.cwd();
+            const meta = getMeta();
+            // Enriquecer com contexto de Attributes/Page (item 7/12 v2.7.44)
+            let attrCtx = {};
+            try {
+                const mod = await import("../../playwright/WebActions.js").catch(() => null);
+                const WA = mod ? mod.WebActions : null;
+                if (WA && typeof WA.getCallerAttributesContext === "function") {
+                    attrCtx = WA.getCallerAttributesContext();
+                }
+            }
+            catch { }
+            const resolvedMethodName = attrCtx.methodName || meta.testMethodName;
+            // Tentar MCP local primeiro (executionSource=Local)
+            if (meta.executionSource === "LOCAL") {
+                const result = await fixXPathViaLocalMcp({
+                    projectRoot,
+                    oldXPath,
+                    newXPath,
+                    confidence,
+                    methodName: resolvedMethodName,
+                    className: attrCtx.className,
+                    attributesFile: attrCtx.attributesFile,
+                    executionSource: "Local",
+                });
+                if (result?.success) {
+                    // (item 29.1) Verificação em disco antes de logar sucesso final
+                    if (result.fileUpdated && result.filePath) {
+                        try {
+                            if (fs.existsSync(result.filePath)) {
+                                Logger.success(`[ResilientPlaywright] ✅ Auto-fix aplicado via MCP: ${result.filePath} — verificado em disco`);
+                            }
+                            else {
+                                Logger.warning(`[ResilientPlaywright] ⚠️ Auto-fix reportou sucesso mas arquivo não encontrado: ${result.filePath}`);
+                            }
+                        }
+                        catch {
+                            Logger.success(`[ResilientPlaywright] ✅ Auto-fix aplicado via MCP: ${result.filePath}`);
+                        }
+                    }
+                    else {
+                        Logger.success(`[ResilientPlaywright] ✅ Auto-fix aplicado via MCP: ${result.filePath}`);
+                    }
+                    return;
+                }
+            }
+            // Fallback: chamar backend HTTP (comportamento original)
+            await testRecoveryHelper.autoFixLocal({
+                projectRoot,
+                oldXPath,
+                newXPath,
+                confidence,
+                methodName: resolvedMethodName,
+                className: attrCtx.className,
+                attributesFile: attrCtx.attributesFile,
+                executionSource: "Local",
+            });
+        }
+        catch {
+            // Auto-fix é best-effort, não bloqueia execução
+        }
+    }
+    async click(xpath, options) {
+        await this.withRecoveryLoop(xpath, "click", async (xp) => {
+            await this.page.locator(xp).click({ timeout: options?.timeout });
+        }, options);
+    }
+    async fill(xpath, value, options) {
+        await this.withRecoveryLoop(xpath, "fill", async (xp) => {
+            await this.page.locator(xp).fill(value, { timeout: options?.timeout });
+        }, options, { value });
+    }
+    /**
+     * Select com auto-recovery (dropdown/combobox)
+     */
+    async select(xpath, value, options) {
+        const values = Array.isArray(value) ? value : [value];
+        await this.withRecoveryLoop(xpath, "select", async (xp) => {
+            const locator = this.page.locator(xp);
+            // Ensure the element is visible and interactable
+            await locator.scrollIntoViewIfNeeded();
+            await locator.click(); // Open the dropdown
+            // Select the option
+            await locator.selectOption(values, { timeout: options?.timeout });
+        }, options);
+    }
+    /**
+     * Hover com auto-recovery
+     */
+    async hover(xpath, options) {
+        await this.withRecoveryLoop(xpath, "hover", async (xp) => {
+            await this.page.locator(xp).hover({ timeout: options?.timeout });
+        }, options);
+    }
+    /**
+     * Check com auto-recovery (checkbox/radio)
+     */
+    async check(xpath, options) {
+        await this.withRecoveryLoop(xpath, "check", async (xp) => {
+            await this.page.locator(xp).check({ timeout: options?.timeout });
+        }, options);
+    }
+    /**
+     * Uncheck com auto-recovery (checkbox)
+     */
+    async uncheck(xpath, options) {
+        await this.withRecoveryLoop(xpath, "uncheck", async (xp) => {
+            await this.page.locator(xp).uncheck({ timeout: options?.timeout });
+        }, options);
+    }
+    /**
+     * Press com auto-recovery (teclas como Enter, Tab, Escape)
+     */
+    async press(xpath, key, options) {
+        await this.withRecoveryLoop(xpath, "press", async (xp) => {
+            await this.page.locator(xp).press(key, { timeout: options?.timeout });
+        }, options, { text: key });
+    }
+    /**
+     * Método genérico para qualquer ação com auto-recovery
+     * Útil quando você quer especificar o actionType manualmente
+     */
+    async action(actionType, xpath, executor, options) {
+        let result;
+        await this.withRecoveryLoop(xpath, actionType, async (xp) => {
+            result = await executor(this.page.locator(xp));
+        }, options);
+        return result;
+    }
+    /**
+     * Captura estrutura da página usando extractBasicPageStructure
+     * Útil para obter estrutura manualmente antes de chamar analyzeFailure
+     */
+    async capturePageStructure() {
+        return extractBasicPageStructure(this.page);
+    }
+    /**
+     * Captura HTML completo da página
+     * Fallback quando MCP não está disponível
+     */
+    async capturePageHtml() {
+        return capturePageHtml(this.page);
+    }
+    /**
+     * Captura screenshot em Base64
+     * Útil para auditoria visual
+     */
+    async captureScreenshotBase64() {
+        return captureScreenshotBase64(this.page);
+    }
+}
+export default ResilientPlaywright;