middlewright 0.1.0

package/dist/plugins/llm-recover.d.ts

@@ -0,0 +1,40 @@
+import { expect as playwrightExpect } from "@playwright/test";
+import type { Plugin } from "../plugin-system.ts";
+export type LlmRecoverOptions = {
+    /** Max recovery attempts per failing action. Default: 3 */
+    maxAttempts?: number;
+    /** Anthropic model to use. Default: "claude-opus-4-8" */
+    model?: string;
+    /** Max tokens for LLM response. Default: 4096 */
+    maxTokens?: number;
+    /** Max HTML length to send. Default: 50_000 */
+    maxHtmlLength?: number;
+    /** Anthropic API key. Default: process.env.ANTHROPIC_API_KEY */
+    apiKey?: string;
+    /** Override the LLM call for testing. Return JS function body string, or null to rethrow. */
+    requestRecoveryCode?: RequestRecoveryCodeFn;
+    expect?: typeof playwrightExpect;
+};
+export type AttemptRecord = {
+    code: string;
+    error: string;
+    durationMs: number;
+};
+export type RecoveryContext = {
+    testTitle: string;
+    testFile: string;
+    failingLine: string;
+    locatorString: string;
+    method: string;
+    args: string;
+    errorMessage: string;
+    errorStack: string;
+    screenshotBase64: string | null;
+    html: string | null;
+    accessibilitySnapshotYaml: string | null;
+};
+export type RequestRecoveryCodeFn = (context: RecoveryContext, attemptHistory: AttemptRecord[]) => Promise<{
+    code: string | null;
+    description: string;
+} | null>;
+export declare const llmRecover: (options?: LlmRecoverOptions) => Plugin;

package/dist/plugins/llm-recover.js

@@ -0,0 +1,345 @@
+/**
+ * llm-recover: when a locator action fails, ask an LLM to write recovery code.
+ *
+ * Extracted from the iterate monorepo's internal Playwright test
+ * infrastructure (github.com/iterate/iterate, private). Modifications from the
+ * original: the Doppler secrets fallback for the API key was removed (pass
+ * `apiKey` or set ANTHROPIC_API_KEY), and the default model was bumped to
+ * claude-opus-4-8.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import dedent from "dedent";
+import { expect as playwrightExpect } from "@playwright/test";
+import { adjustError } from "../plugin-system.js";
+/**
+ * LLM-powered recovery plugin. When a locator action fails, captures context
+ * (screenshot, error, test info) and asks an LLM to generate a JS recovery
+ * function. The function is eval'd with { page, locator, error } in scope.
+ *
+ * This runs arbitrary LLM-generated code in your test process. Gate it behind
+ * an explicit opt-in env var (e.g. only add the plugin when LLM_RECOVER is
+ * set) rather than enabling it unconditionally.
+ */
+// Re-entrancy guard: don't try to recover failures that happen inside recovery code.
+// Uses a WeakSet of pages currently being recovered.
+const pagesInRecovery = new WeakSet();
+export const llmRecover = (options = {}) => {
+    const expect = options.expect || playwrightExpect;
+    const maxAttempts = options.maxAttempts || 3;
+    const requestRecovery = options.requestRecoveryCode || createAnthropicProvider(options);
+    return {
+        name: "llm-recover",
+        middleware: async (ctx, next) => {
+            // Skip if we're already inside a recovery attempt for this page
+            if (pagesInRecovery.has(ctx.page))
+                return next();
+            try {
+                return await next();
+            }
+            catch (originalError) {
+                if (!(originalError instanceof Error))
+                    throw originalError;
+                const { page, locator, method, testInfo } = ctx;
+                const attemptHistory = [];
+                // Gather context once (screenshot + HTML don't change between LLM retries
+                // unless recovery code navigates, but that's fine — we capture at failure time)
+                const context = await gatherContext(ctx, originalError, options);
+                for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                    let recoveryResult;
+                    try {
+                        recoveryResult = await requestRecovery(context, attemptHistory);
+                    }
+                    catch (llmError) {
+                        // LLM call itself failed — don't retry, just throw original
+                        adjustError(originalError, [`[llm-recover] LLM call failed: ${String(llmError)}`], import.meta.filename);
+                        throw originalError;
+                    }
+                    const code = recoveryResult?.code;
+                    // null/empty = rethrow as-is
+                    if (!code?.trim()) {
+                        adjustError(originalError, [`[llm-recover] LLM call returned no code: ${recoveryResult?.description}`], import.meta.filename);
+                        throw originalError;
+                    }
+                    const start = Date.now();
+                    try {
+                        let recoveryFn;
+                        // eval is intentional: the LLM writes a recovery function, we run it
+                        // eslint-disable-next-line no-eval
+                        eval(`recoveryFn = ${code.trim()}`);
+                        if (typeof recoveryFn !== "function") {
+                            adjustError(originalError, [`[llm-recover] Recovery function is not a function: ${code}`], import.meta.filename);
+                            throw originalError;
+                        }
+                        // Mark page as in-recovery so nested locator failures don't re-trigger LLM
+                        pagesInRecovery.add(page);
+                        try {
+                            await recoveryFn({ page, locator, error: originalError });
+                        }
+                        finally {
+                            pagesInRecovery.delete(page);
+                        }
+                        // Write artifact
+                        const artifact = writeArtifact(testInfo, {
+                            test: context.testTitle,
+                            file: context.testFile,
+                            failingLine: context.failingLine,
+                            locator: context.locatorString,
+                            method,
+                            originalError: originalError.message,
+                            attempts: [
+                                ...attemptHistory,
+                                { code, error: "(success)", durationMs: Date.now() - start },
+                            ],
+                            recovered: true,
+                        });
+                        // Recovery succeeded — record a soft error so the test is marked
+                        // failed but continues executing. We push directly to testInfo.errors
+                        // because the global `expect.soft` only works inside a test context.
+                        const description = code.split("\n").slice(1, -1).join("\n");
+                        const message = [
+                            `[llm-recover] ${method} failed and was recovered by LLM.`,
+                            `Original error:\n  ${originalError.message.split("\n")[0]}`,
+                            `Original locator:\n  await page.${locator}.${method}()`,
+                            `Recovery code:\n${description}`,
+                            `Explanation::\n  ${recoveryResult?.description}`,
+                            `Artifact: ${artifact}`,
+                        ].join("\n");
+                        expect.soft("passed–after-llm-recovery", message).toBe("passed-in-the-first-place");
+                        return; // recovery complete
+                    }
+                    catch (recoveryError) {
+                        const errorMsg = recoveryError instanceof Error ? recoveryError.message : String(recoveryError);
+                        attemptHistory.push({
+                            code,
+                            error: errorMsg,
+                            durationMs: Date.now() - start,
+                        });
+                        // loop continues
+                    }
+                }
+                // Exhausted all attempts — write artifact and rethrow
+                writeArtifact(ctx.testInfo, {
+                    test: context.testTitle,
+                    file: context.testFile,
+                    failingLine: context.failingLine,
+                    locator: context.locatorString,
+                    method,
+                    originalError: originalError.message,
+                    attempts: attemptHistory,
+                    recovered: false,
+                });
+                const summary = attemptHistory.map((a, i) => `  Attempt ${i + 1}: ${a.error}`).join("\n");
+                adjustError(originalError, [`[llm-recover] ${attemptHistory.length} recovery attempt(s) failed:`, summary], import.meta.filename);
+                throw originalError;
+            }
+        },
+    };
+};
+async function gatherContext(ctx, error, options) {
+    const { page, locator, method, args, testInfo } = ctx;
+    const maxHtmlLength = options.maxHtmlLength || 50_000;
+    // Screenshot
+    const screenshotBase64 = await page
+        .screenshot({ type: "png" })
+        .then((buffer) => buffer.toString("base64"))
+        .catch(() => null);
+    // HTML
+    const html = await page
+        .content()
+        .then((content) => {
+        if (content.length < maxHtmlLength)
+            return content;
+        return content.slice(0, maxHtmlLength) + "\n<!-- truncated -->";
+    })
+        .catch(() => "<!-- HTML unavailable -->");
+    // Accessibility snapshot (YAML)
+    const accessibilitySnapshotYaml = await page
+        .locator("body")
+        .ariaSnapshot()
+        .catch((e) => `<!-- accessibility snapshot unavailable (${e}) -->`);
+    // Parse failing line from stack
+    const failingLine = parseFailingLine(error.stack || "");
+    return {
+        testTitle: testInfo?.titlePath.join(" > ") || "(unknown test)",
+        testFile: testInfo?.file || "(unknown file)",
+        failingLine,
+        locatorString: locator.toString(),
+        method,
+        args: JSON.stringify(args),
+        errorMessage: error.message,
+        errorStack: error.stack || "",
+        screenshotBase64,
+        html,
+        accessibilitySnapshotYaml,
+    };
+}
+function parseFailingLine(stack) {
+    const lines = stack.split("\n");
+    for (const line of lines) {
+        // Look for spec file frames, skip node_modules and plugin files
+        if (line.includes(".spec.ts") && !line.includes("node_modules") && !line.includes("plugins/")) {
+            return line.trim();
+        }
+    }
+    // Fallback: first frame that's not node_modules
+    for (const line of lines) {
+        if (line.trim().startsWith("at ") && !line.includes("node_modules")) {
+            return line.trim();
+        }
+    }
+    return "(unknown)";
+}
+function writeArtifact(testInfo, data) {
+    if (!testInfo)
+        return "(no-test-info)";
+    const dir = path.join(testInfo.outputDir, "llm-recover");
+    fs.mkdirSync(dir, { recursive: true });
+    const filename = `attempt-${Date.now()}.json`;
+    const filepath = path.join(dir, filename);
+    fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
+    return filepath;
+}
+// --- Anthropic provider ---
+const SYSTEM_PROMPT = dedent `
+  You are a Playwright test recovery assistant. A locator action failed during a test. You will be given:
+
+  - The test name and file
+  - The failing line of code
+  - The locator and method that failed
+  - The error message and stack trace
+  - A screenshot of the page at the time of failure
+  - An accessibility snapshot in YAML format (preferred source for element names/roles/states)
+  - Optionally, the page HTML
+
+  Your job: respond with a JavaScript function body, wrapped by \`<code>...\<\/code>\` tags. It must be an async function named \`recover\` that takes a single context argument:
+
+  After the function definition, write a brief description of why the given recovery code was chosen. Sacrifice grammar for concision. Example:
+
+  ---
+
+  <code>
+  async function recover({ page, locator, error }){
+    await page.getByText("Create an account").click();
+  }
+  </code>
+
+  The original locator looked for the text "Create account", but the DOM shows "Create an account" instead.
+
+  ---
+
+  Where the context passed in has the following type:
+
+  \`\`\`ts
+  type RecoveryContext = {
+    /** The Playwright Page object, used by the test */
+    page: import("@playwright/test").Page;
+    /** The Locator that failed had a failing action */
+    locator: import("@playwright/test").Locator;
+    /** The original error thrown by the failing action */
+    error: Error;
+  };
+  \`\`\`
+
+  If the failure is UNRECOVERABLE (e.g. the test logic is fundamentally wrong, not a locator/timing issue), simply omit the <code>...</code> tags and return an explanation of why it's unrecoverable:
+
+  ---
+
+  Not recoverable: account creation is explicitly disabled in this UI.
+
+  ---
+
+  If the failure is RECOVERABLE, write code that:
+  1. Performs any necessary setup (dismiss modals, wait for elements, scroll, etc.)
+  2. Completes the action that the original locator was trying to do
+
+  Common recovery patterns:
+  - Wrong/stale locator: find the correct element and interact with it
+  - Timing issue: wait for the right condition then retry
+  - Modal/overlay blocking: dismiss it, then retry
+  - Element not in viewport: scroll to it, then interact
+
+  Keep the code minimal. Do not add unnecessary waits or retries.
+`;
+function createAnthropicProvider(options) {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        throw new Error("[llm-recover] An Anthropic API key is required: pass `apiKey` or set the ANTHROPIC_API_KEY environment variable");
+    }
+    const model = options.model || "claude-opus-4-8";
+    const maxTokens = options.maxTokens || 4096;
+    return async (context, attemptHistory) => {
+        const userContent = [];
+        // Text context
+        const textParts = [
+            `**Test:** ${context.testTitle}`,
+            `**File:** ${context.testFile}`,
+            `**Failing line:** ${context.failingLine}`,
+            `**Locator:** ${context.locatorString}`,
+            `**Method:** ${context.method}(${context.args})`,
+            `**Error:** ${context.errorMessage}`,
+            `**Stack:**\n\`\`\`\n${context.errorStack.slice(0, 2000)}\n\`\`\``,
+            `**Accessibility snapshot (YAML):**\n\`\`\`yaml\n${context.accessibilitySnapshotYaml}\n\`\`\``,
+        ];
+        if (context.html) {
+            const suffix = context.html.endsWith("<!-- truncated -->") ? " (truncated)" : "";
+            textParts.push(`**Page HTML${suffix}:**\n\`\`\`html\n${context.html}\n\`\`\``);
+        }
+        if (attemptHistory.length > 0) {
+            textParts.push(`**Previous recovery attempts (all failed):**`);
+            for (const [i, attempt] of attemptHistory.entries()) {
+                textParts.push(`Attempt ${i + 1} (${attempt.durationMs}ms):\nCode:\n\`\`\`js\n${attempt.code}\n\`\`\`\nError: ${attempt.error}`);
+            }
+            textParts.push(`Try a DIFFERENT approach than what was already attempted.`);
+        }
+        userContent.push({ type: "text", text: textParts.join("\n\n") });
+        // Screenshot
+        if (context.screenshotBase64) {
+            userContent.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: "image/png",
+                    data: context.screenshotBase64,
+                },
+            });
+        }
+        const response = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: maxTokens,
+                system: SYSTEM_PROMPT,
+                messages: [{ role: "user", content: userContent }],
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "(unreadable)");
+            throw new Error(`Anthropic API error ${response.status}: ${body}`);
+        }
+        const data = (await response.json());
+        const textBlock = data.content?.find((b) => b.type === "text");
+        if (!textBlock?.text)
+            return null;
+        return extractCode(textBlock.text);
+    };
+}
+/** Extract code from LLM response. Handles <code>...</code> tags and markdown fences. */
+function extractCode(text) {
+    text = text.trim();
+    const codeStart = text.indexOf("<code>");
+    const codeEnd = text.indexOf("</code>");
+    if (codeStart === -1 || codeEnd === -1) {
+        return { code: null, description: text };
+    }
+    const code = text.slice(codeStart + 6, codeEnd).trim() || null;
+    const description = [text.slice(0, codeStart).trim(), text.slice(codeEnd + 7).trim()]
+        .filter(Boolean)
+        .join("\n\n");
+    return { code, description };
+}

package/dist/plugins/spinner-waiter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * spinner-waiter: the plugin Playwright wouldn't build.
+ *
+ * Extracted from the iterate monorepo's internal Playwright test
+ * infrastructure (github.com/iterate/iterate, private). This implements the
+ * feature requested in https://github.com/microsoft/playwright/issues/16007 -
+ * a different effective action timeout while the app is visibly loading.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { Plugin } from "../plugin-system.ts";
+export type SpinnerWaiterOptions = {
+    /** Selectors that indicate loading state */
+    spinnerSelectors?: string[];
+    /** Max time to wait for spinners (ms). Default: 30_000 */
+    spinnerTimeout?: number;
+    /** Whether to skip spinner checking. Default: false */
+    disabled?: boolean;
+    /** Debug logging function */
+    log?: (message: string) => void;
+};
+declare const defaultSelectors: string[];
+/**
+ * Creates a spinner-waiter plugin.
+ *
+ * Runtime settings can be overridden per-test via
+ * `spinnerWaiter.settings.enterWith({...})`, or for a single call via
+ * `spinnerWaiter.settings.run({...}, () => locator.click())`.
+ */
+export declare const spinnerWaiter: ((options?: SpinnerWaiterOptions) => Plugin) & {
+    /** Runtime settings override via AsyncLocalStorage */
+    settings: AsyncLocalStorage<Partial<SpinnerWaiterOptions>>;
+    /** Default settings values */
+    defaults: Required<SpinnerWaiterOptions>;
+};
+export { defaultSelectors };

package/dist/plugins/spinner-waiter.js

@@ -0,0 +1,138 @@
+/**
+ * spinner-waiter: the plugin Playwright wouldn't build.
+ *
+ * Extracted from the iterate monorepo's internal Playwright test
+ * infrastructure (github.com/iterate/iterate, private). This implements the
+ * feature requested in https://github.com/microsoft/playwright/issues/16007 -
+ * a different effective action timeout while the app is visibly loading.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { adjustError } from "../plugin-system.js";
+const defaultSelectors = [
+    `[aria-label="Loading"]`,
+    `[data-spinner='true']`,
+    `:text-matches("(loading|pending|creating|verifying|starting|processing|syncing)\\.\\.\\.$", "i")`,
+];
+const defaults = {
+    spinnerSelectors: defaultSelectors,
+    spinnerTimeout: 30_000,
+    disabled: false,
+    log: () => { },
+};
+/** AsyncLocalStorage for runtime settings override */
+const settingsStorage = new AsyncLocalStorage();
+const getSettings = (baseOptions = {}) => {
+    const runtimeOverrides = settingsStorage.getStore() || {};
+    const result = { ...defaults, ...baseOptions, ...runtimeOverrides };
+    if (result.spinnerTimeout <= 3000) {
+        throw new Error("spinnerTimeout must be greater than 3000ms");
+    }
+    return result;
+};
+const suggestSpinnerMessage = (spinnerLocator) => [
+    `If this is a slow operation, update the product code to add a spinner while it's running.`,
+    `This will improve the user experience and buy you more time for this assertion.`,
+    `To add a spinner, show any UI element matching this locator:`,
+    `  ${spinnerLocator}`,
+];
+/**
+ * Creates a spinner-waiter plugin.
+ *
+ * Runtime settings can be overridden per-test via
+ * `spinnerWaiter.settings.enterWith({...})`, or for a single call via
+ * `spinnerWaiter.settings.run({...}, () => locator.click())`.
+ */
+export const spinnerWaiter = Object.assign((options = {}) => {
+    return {
+        name: "spinner-waiter",
+        middleware: async ({ locator, method, page }, next) => {
+            const settings = getSettings(options);
+            if (settings.disabled)
+                return next();
+            const start = Date.now();
+            settings.log(`${locator}.${method}(...) starting`);
+            // Quick check if element is already visible
+            const elementVisible = await waitForVisible(locator, { timeout: 1000 });
+            if (elementVisible) {
+                settings.log(`${locator} already visible, proceeding`);
+                return next();
+            }
+            // Check for spinner
+            const spinnerSelector = settings.spinnerSelectors.join(",");
+            const spinnerLocator = page.locator(spinnerSelector);
+            const spinnerVisible = await spinnerLocator.isVisible();
+            if (!spinnerVisible) {
+                // No spinner - call action, suggest adding one if it fails
+                settings.log(`${locator} not visible, no spinner, proceeding anyway`);
+                try {
+                    return await next();
+                }
+                catch (error) {
+                    adjustError(error, suggestSpinnerMessage(spinnerLocator), "spinner-waiter.ts");
+                    throw error;
+                }
+            }
+            settings.log(`Spinner visible, waiting up to ${settings.spinnerTimeout - 2000}ms for ${locator}`);
+            // Spinner is visible — wait for the element, but bail early if the spinner
+            // disappears (the loading operation finished without producing the expected element).
+            const waitResult = await waitForVisibleWhileSpinning(locator, spinnerLocator, {
+                timeout: settings.spinnerTimeout - 2000,
+            });
+            if (waitResult === "appeared") {
+                settings.log(`${locator} appeared after waiting`);
+                return next();
+            }
+            if (waitResult === "spinner-gone") {
+                settings.log(`Spinner disappeared but element not visible — loading finished without expected result`);
+            }
+            else {
+                settings.log(`Spinner still visible after ${settings.spinnerTimeout}ms, UI likely stuck`);
+            }
+            // Call action anyway (will likely fail), adjust error message
+            try {
+                return await next();
+            }
+            catch (error) {
+                const message = waitResult === "spinner-gone"
+                    ? `Loading finished (spinner disappeared after ${Date.now() - start}ms) but the expected element never appeared.`
+                    : `Spinner was still visible after ${settings.spinnerTimeout}ms, the UI is likely stuck.`;
+                adjustError(error, [message], "spinner-waiter.ts");
+                throw error;
+            }
+        },
+    };
+}, {
+    /** Runtime settings override via AsyncLocalStorage */
+    settings: settingsStorage,
+    /** Default settings values */
+    defaults,
+});
+async function waitForVisible(locator, { timeout = 1000 } = {}) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        if (await locator.isVisible())
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+}
+/**
+ * Wait for `target` to become visible, but bail early if `spinner` disappears.
+ * Returns "appeared" if target showed up, "spinner-gone" if loading finished
+ * without the target, or "timeout" if spinner was still visible at deadline.
+ */
+async function waitForVisibleWhileSpinning(target, spinner, { timeout = 1000 } = {}) {
+    const start = Date.now();
+    // Give the spinner a grace period before checking — it may flicker during transitions
+    const spinnerGracePeriodMs = 3000;
+    while (Date.now() - start < timeout) {
+        if (await target.isVisible())
+            return "appeared";
+        const elapsed = Date.now() - start;
+        if (elapsed > spinnerGracePeriodMs && !(await spinner.isVisible()))
+            return "spinner-gone";
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return "timeout";
+}
+export { defaultSelectors };

package/dist/plugins/ui-error-reporter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ui-error-reporter: when an action fails, tell me what the app was screaming about.
+ *
+ * Extracted from the iterate monorepo's internal Playwright test
+ * infrastructure (github.com/iterate/iterate, private).
+ */
+import type { Plugin } from "../plugin-system.ts";
+export type UIErrorReporterOptions = {
+    /**
+     * Selector for error UI. Default: '[data-type="error"]' (which matches
+     * sonner error toasts, among others).
+     */
+    selector?: string;
+};
+/**
+ * When a locator action fails, checks for visible error toasts/other UI and appends
+ * their text to the error message for easier debugging.
+ */
+export declare const uiErrorReporter: (options?: UIErrorReporterOptions) => Plugin;

package/dist/plugins/ui-error-reporter.js

@@ -0,0 +1,25 @@
+import { adjustError } from "../plugin-system.js";
+/**
+ * When a locator action fails, checks for visible error toasts/other UI and appends
+ * their text to the error message for easier debugging.
+ */
+export const uiErrorReporter = (options = {}) => {
+    const selector = options.selector || '[data-type="error"]';
+    return {
+        name: "ui-error-reporter",
+        middleware: async ({ page }, next) => {
+            try {
+                return await next();
+            }
+            catch (error) {
+                const getToastErrors = () => page.locator(selector).allTextContents();
+                const messages = await getToastErrors().catch(() => []);
+                if (messages.length > 0 && error instanceof Error) {
+                    const info = [`Error UI visible:`, ...messages.map((m) => JSON.stringify(m.trim()))];
+                    adjustError(error, info, import.meta.filename, { color: 31 });
+                }
+                throw error;
+            }
+        },
+    };
+};

package/dist/plugins/video-mode.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin, OverrideableMethod } from "../plugin-system.ts";
+export type VideoModeOptions = {
+    /** Pause duration before action (ms). Default: 1000 */
+    pauseBefore?: number;
+    /** Pause duration after test (ms). Default: 3000 */
+    pauseAfterTest?: number;
+    /** Highlight style. Default: '3px solid gold' */
+    highlightStyle?: string;
+    /** Methods to skip highlighting. Default: ['waitFor'] */
+    skipMethods?: OverrideableMethod[];
+    /**
+     * Skip highlighting for actions triggered from these files (matched as
+     * substrings of stack frames). Useful for internal helpers like login
+     * flows that shouldn't be slowed down. Default: []
+     */
+    skipStackFrames?: string[];
+};
+/**
+ * Highlights elements before actions and pauses for video recording.
+ * Also pauses after tests complete for better video endings.
+ */
+export declare const videoMode: (options?: VideoModeOptions) => Plugin;