@healflow/playwright 0.1.0

package/dist/index.js

@@ -0,0 +1,706 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.healflowReporter = exports.configToPluginOptions = exports.withHealFlow = exports.registerHealFlow = void 0;
+exports.wrapPage = wrapPage;
+exports.healflowFixture = healflowFixture;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const classification_1 = require("@healflow/classification");
+const shared_1 = require("@healflow/shared");
+const config_1 = require("@healflow/shared/config");
+const api_client_js_1 = require("./api-client.js");
+const heal_store_js_1 = require("./heal-store.js");
+const terminal_js_1 = require("./terminal.js");
+function resolveOptions(options = {}) {
+    const fileConfig = options.config ?? (0, config_1.loadHealFlowConfig)();
+    return {
+        autoHeal: options.autoHeal ?? true,
+        maxAttempts: options.maxAttempts ?? 2,
+        apiUrl: options.apiUrl ??
+            fileConfig.backend?.url ??
+            process.env.HEALFLOW_API_URL ??
+            'http://localhost:3001',
+        organizationId: options.organizationId ??
+            fileConfig.backend?.organizationId ??
+            process.env.HEALFLOW_ORG_ID ??
+            '',
+        repositoryId: options.repositoryId ??
+            fileConfig.backend?.repositoryId ??
+            process.env.HEALFLOW_REPO_ID ??
+            '',
+        config: fileConfig,
+    };
+}
+const PAGE_LOCATOR_FACTORIES = new Set([
+    'locator',
+    'getByRole',
+    'getByText',
+    'getByLabel',
+    'getByPlaceholder',
+    'getByAltText',
+    'getByTitle',
+    'getByTestId',
+    'frameLocator',
+]);
+const LOCATOR_CHAIN_METHODS = new Set([
+    'locator',
+    'getByRole',
+    'getByText',
+    'getByLabel',
+    'getByPlaceholder',
+    'getByAltText',
+    'getByTitle',
+    'getByTestId',
+    'frameLocator',
+    'first',
+    'last',
+    'nth',
+    'filter',
+    'and',
+    'or',
+]);
+const HEALABLE_LOCATOR_ACTIONS = new Set([
+    'click',
+    'dblclick',
+    'fill',
+    'press',
+    'check',
+    'uncheck',
+    'selectOption',
+    'tap',
+    'hover',
+    'setInputFiles',
+    'clear',
+]);
+const HEALABLE_PAGE_ACTIONS = new Set([
+    'goto',
+    'reload',
+    'goBack',
+    'goForward',
+    'click',
+    'dblclick',
+    'fill',
+]);
+const HEAL_FIRST_ATTEMPT_TIMEOUT_MS = 3_000;
+const HEAL_RETRY_TIMEOUT_MS = 15_000;
+function withPolicy(base) {
+    const { outcome, recommendedAction } = (0, shared_1.resolveFailureOutcome)(base);
+    return { ...base, healOutcome: outcome, recommendedAction };
+}
+function classifyRuntimeError(error, action) {
+    const message = error.message;
+    if (/intercepts pointer events|element is obscured|subtree intercepts/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.OVERLAY,
+            subcategory: 'blocking_overlay',
+            confidence: 0.9,
+            signals: [
+                { name: 'OVERLAY:pointer_intercept', weight: 0.9, evidence: message.slice(0, 120) },
+            ],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    if (/getByTestId\(['"][^'"]+['"]\)/i.test(message) && /timeout|waiting for/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.SELECTOR,
+            subcategory: 'locator_timeout',
+            confidence: 0.8,
+            signals: [{ name: 'SELECTOR:locator_timeout', weight: 0.8, evidence: message.slice(0, 120) }],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    if (/timeout \d+ms exceeded/i.test(message) &&
+        /waiting for.*to be visible|waiting for.*to be enabled/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.TIMING,
+            subcategory: 'wait_timeout',
+            confidence: 0.8,
+            signals: [{ name: 'TIMING:wait_timeout', weight: 0.8, evidence: message.slice(0, 120) }],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    if (/frame|iframe|content frame|frameLocator/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.IFRAME,
+            subcategory: 'frame_context',
+            confidence: 0.85,
+            signals: [{ name: 'IFRAME:frame_context', weight: 0.85, evidence: message.slice(0, 120) }],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    if (/shadow root|pierce|closed shadow/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.SHADOW_DOM,
+            subcategory: 'shadow_access',
+            confidence: 0.8,
+            signals: [{ name: 'SHADOW_DOM:shadow_access', weight: 0.8, evidence: message.slice(0, 120) }],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    if (/unauthorized|401|403|login required|authentication|redirect.*login/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.AUTH,
+            subcategory: 'auth_failure',
+            confidence: 0.85,
+            signals: [{ name: 'AUTH:auth_failure', weight: 0.85, evidence: message.slice(0, 120) }],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    if (/net::ERR|ECONNREFUSED|network error|failed to fetch/i.test(message)) {
+        return withPolicy({
+            failureId: 'runtime',
+            category: shared_1.FailureCategory.NETWORK,
+            subcategory: 'network_error',
+            confidence: 0.75,
+            signals: [{ name: 'NETWORK:network_error', weight: 0.75, evidence: message.slice(0, 120) }],
+            isAutomationFixable: true,
+            isProductBug: false,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+    const failure = {
+        id: (0, node_crypto_1.randomUUID)(),
+        organizationId: '',
+        repositoryId: '',
+        source: shared_1.FailureSource.RUNTIME,
+        testFile: 'runtime',
+        testTitle: action,
+        errorMessage: message,
+        errorStack: error.stack,
+        artifacts: [],
+        metadata: { action },
+        occurredAt: new Date().toISOString(),
+        fingerprint: '',
+    };
+    return (0, classification_1.classifyFailure)(failure);
+}
+function categoryKey(category) {
+    switch (category) {
+        case shared_1.FailureCategory.SELECTOR:
+            return 'selector';
+        case shared_1.FailureCategory.TIMING:
+            return 'timing';
+        case shared_1.FailureCategory.OVERLAY:
+            return 'overlay';
+        case shared_1.FailureCategory.IFRAME:
+            return 'iframe';
+        case shared_1.FailureCategory.SHADOW_DOM:
+            return 'shadowDom';
+        case shared_1.FailureCategory.AUTH:
+        case shared_1.FailureCategory.SESSION:
+            return 'auth';
+        case shared_1.FailureCategory.NETWORK:
+            return 'network';
+        default:
+            return null;
+    }
+}
+function canRuntimeHeal(classification) {
+    if (classification.healOutcome === shared_1.HealOutcome.BLOCKED)
+        return false;
+    if ((0, shared_1.isCategoryAutomationFixable)(classification.category))
+        return true;
+    if (classification.category === shared_1.FailureCategory.NETWORK && classification.confidence >= 0.75) {
+        return true;
+    }
+    return false;
+}
+function emitHeal(opts, result, healContext) {
+    const testFile = healContext.testFile;
+    const testTitle = healContext.testTitle;
+    const record = (0, heal_store_js_1.recordRuntimeHeal)({
+        testFile,
+        testTitle,
+        rootCause: result.rootCause,
+        category: result.category,
+        oldValue: result.oldValue,
+        newValue: result.newValue,
+        confidence: result.confidence,
+    });
+    const fixProposal = (0, heal_store_js_1.recordFixProposal)({
+        testFile: testFile ?? 'runtime',
+        testTitle: testTitle ?? 'runtime',
+        rootCause: result.rootCause,
+        category: result.category,
+        oldValue: result.oldValue,
+        newValue: result.newValue,
+        confidence: result.confidence,
+        strategy: result.category,
+        dryRun: true,
+    });
+    (0, terminal_js_1.logHeal)(record, opts.config);
+    if (opts.organizationId && opts.apiUrl) {
+        (0, api_client_js_1.reportRuntimeHeal)({
+            apiUrl: opts.apiUrl,
+            organizationId: opts.organizationId,
+            repositoryId: opts.repositoryId,
+            token: opts.config.backend?.token ?? process.env.HEALFLOW_TOKEN,
+        }, record, fixProposal);
+    }
+}
+async function dismissOverlays(rawPage) {
+    const candidates = [
+        rawPage.getByRole('button', { name: /accept|agree|close|dismiss|got it|ok/i }),
+        rawPage.locator('#accept-cookies, #cookie-banner button, .overlay button'),
+        rawPage.locator('[data-testid*="accept"], [aria-label*="close" i]'),
+    ];
+    for (const locator of candidates) {
+        await locator
+            .first()
+            .click({ timeout: 2000 })
+            .catch(() => { });
+    }
+}
+async function waitForLocator(locator) {
+    await locator.waitFor({ state: 'attached', timeout: HEAL_RETRY_TIMEOUT_MS });
+    await locator.waitFor({ state: 'visible', timeout: HEAL_RETRY_TIMEOUT_MS });
+}
+async function runLocatorAction(locator, action, args) {
+    const fn = locator[action];
+    if (typeof fn !== 'function') {
+        throw new Error(`Unsupported locator action: ${action}`);
+    }
+    return fn.apply(locator, args);
+}
+function resolveActionArgs(args, attempt, method) {
+    if (method !== 'click' && method !== 'tap' && method !== 'fill')
+        return args;
+    if (attempt > 0) {
+        return withActionTimeout(args, HEAL_RETRY_TIMEOUT_MS, true);
+    }
+    const hasUserTimeout = args.length > 0 &&
+        typeof args[0] === 'object' &&
+        args[0] !== null &&
+        'timeout' in args[0];
+    if (hasUserTimeout)
+        return args;
+    return withActionTimeout(args, HEAL_FIRST_ATTEMPT_TIMEOUT_MS, true);
+}
+async function healGetByTestIdFailure(rawPage, locator, action, args, error) {
+    try {
+        await locator.waitFor({ state: 'attached', timeout: 5_000 });
+        await locator.waitFor({ state: 'visible', timeout: 5_000 });
+        await runLocatorAction(locator, action, withActionTimeout(args, HEAL_RETRY_TIMEOUT_MS, true));
+        return {
+            type: 'done',
+            result: undefined,
+            heal: {
+                category: shared_1.FailureCategory.TIMING,
+                rootCause: 'Timing',
+                confidence: 0.85,
+            },
+        };
+    }
+    catch {
+        // not a timing issue — try fallback locators for stale test ids
+    }
+    const healed = await healSelector(rawPage, action, args, error);
+    if (healed)
+        return { type: 'done', result: undefined, heal: healed };
+    return { type: 'abort' };
+}
+function withActionTimeout(args, timeout, force = false) {
+    if (args.length === 0)
+        return [{ timeout }];
+    if (typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0])) {
+        const options = args[0];
+        if (!force && options.timeout !== undefined)
+            return args;
+        return [{ ...options, timeout: options.timeout ?? timeout }, ...args.slice(1)];
+    }
+    return [{ timeout }, ...args];
+}
+async function assertUniqueVisibleCandidate(candidate) {
+    const count = await candidate.count();
+    if (count !== 1)
+        return false;
+    return candidate
+        .first()
+        .isVisible()
+        .catch(() => false);
+}
+async function healSelector(rawPage, action, args, error) {
+    const staleIdMatch = error.message.match(/getByTestId\(['"]([^'"]+)['"]\)/i);
+    const staleId = staleIdMatch?.[1];
+    const candidates = [];
+    if (staleId) {
+        const interactive = 'button, input, select, textarea, a[href]';
+        candidates.push({
+            locator: rawPage.locator(`${interactive}[data-testid*="${staleId}"]`),
+            label: `interactive[data-testid*="${staleId}"]`,
+        });
+        candidates.push({
+            locator: rawPage.locator(`[data-testid*="${staleId}"]`),
+            label: `[data-testid*="${staleId}"]`,
+        });
+        if (staleId.length > 4) {
+            const partial = staleId.slice(0, Math.ceil(staleId.length / 2));
+            candidates.push({
+                locator: rawPage.locator(`${interactive}[data-testid*="${partial}"]`),
+                label: `interactive[data-testid*="${partial}"]`,
+            });
+            candidates.push({
+                locator: rawPage.locator(`[data-testid*="${partial}"]`),
+                label: `[data-testid*="${partial}"]`,
+            });
+        }
+        const roleMatch = error.message.match(/getByRole\(['"]([^'"]+)['"],\s*\{\s*name:\s*['"]([^'"]+)['"]/i);
+        if (roleMatch) {
+            candidates.push({
+                locator: rawPage.getByRole(roleMatch[1], {
+                    name: new RegExp(roleMatch[2], 'i'),
+                }),
+                label: `role:${roleMatch[1]}:${roleMatch[2]}`,
+            });
+        }
+    }
+    for (const candidate of candidates) {
+        const confident = await assertUniqueVisibleCandidate(candidate.locator);
+        if (!confident)
+            continue;
+        try {
+            const resolvedLocator = candidate.locator.first();
+            await runLocatorAction(resolvedLocator, action, [{ timeout: HEAL_RETRY_TIMEOUT_MS }]);
+            const resolvedTestId = await resolvedLocator.getAttribute('data-testid').catch(() => null);
+            return {
+                oldValue: staleId,
+                newValue: resolvedTestId ?? candidate.label,
+                category: shared_1.FailureCategory.SELECTOR,
+                rootCause: 'Selector Rename',
+                confidence: 0.98,
+            };
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+function extractIframeSelector(message) {
+    const frameMatch = message.match(/frame(?:Locator)?\(['"]([^'"]+)['"]\)/i);
+    if (frameMatch?.[1])
+        return frameMatch[1];
+    const nameMatch = message.match(/iframe[^'"]*['"]([^'"]+)['"]/i);
+    return nameMatch?.[1] ?? null;
+}
+function extractShadowSelector(message) {
+    const selectorMatch = message.match(/locator\(['"]([^'"]+)['"]\)/i);
+    return selectorMatch?.[1] ?? null;
+}
+async function healIframe(rawPage, locator, action, args, error) {
+    const frameSelector = extractIframeSelector(error.message);
+    if (!frameSelector)
+        return null;
+    const frameLocator = rawPage.frameLocator(frameSelector);
+    const innerCandidates = [
+        frameLocator.locator('[data-testid]'),
+        frameLocator.getByRole('button'),
+        frameLocator.locator('body'),
+    ];
+    for (const candidate of innerCandidates) {
+        const confident = await assertUniqueVisibleCandidate(candidate);
+        if (!confident)
+            continue;
+        try {
+            await runLocatorAction(candidate.first(), action, [{ timeout: HEAL_RETRY_TIMEOUT_MS }]);
+            return {
+                oldValue: error.message.slice(0, 80),
+                newValue: `frameLocator('${frameSelector}')`,
+                category: shared_1.FailureCategory.IFRAME,
+                rootCause: 'Iframe Context',
+                confidence: 0.85,
+            };
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    try {
+        for (const frame of rawPage.frames()) {
+            await frame.waitForLoadState('domcontentloaded').catch(() => { });
+        }
+        await waitForLocator(locator);
+        return {
+            category: shared_1.FailureCategory.IFRAME,
+            rootCause: 'Iframe Context',
+            confidence: 0.8,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function healShadowDom(rawPage, action, args, error) {
+    const baseSelector = extractShadowSelector(error.message);
+    if (!baseSelector)
+        return null;
+    const pierced = rawPage.locator(`${baseSelector} >>> *`);
+    const confident = await assertUniqueVisibleCandidate(pierced);
+    if (!confident)
+        return null;
+    try {
+        await runLocatorAction(pierced.first(), action, [{ timeout: HEAL_RETRY_TIMEOUT_MS }]);
+        return {
+            oldValue: baseSelector,
+            newValue: `${baseSelector} >>> *`,
+            category: shared_1.FailureCategory.SHADOW_DOM,
+            rootCause: 'Shadow DOM',
+            confidence: 0.8,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function healAuth(rawPage, opts) {
+    const authConfig = opts.config.auth;
+    const storageStatePath = authConfig?.storageStatePath;
+    if (storageStatePath) {
+        try {
+            const state = JSON.parse((0, node_fs_1.readFileSync)(storageStatePath, 'utf-8'));
+            if (state.cookies?.length) {
+                await rawPage.context().addCookies(state.cookies);
+                return {
+                    category: shared_1.FailureCategory.AUTH,
+                    rootCause: 'Auth Session Restore',
+                    newValue: storageStatePath,
+                    confidence: 0.85,
+                };
+            }
+        }
+        catch {
+            // fall through to login URL
+        }
+    }
+    const loginUrl = authConfig?.loginUrl;
+    if (loginUrl) {
+        await rawPage.goto(loginUrl, { waitUntil: 'domcontentloaded', timeout: HEAL_RETRY_TIMEOUT_MS });
+        return {
+            category: shared_1.FailureCategory.AUTH,
+            rootCause: 'Auth Redirect',
+            newValue: loginUrl,
+            confidence: 0.8,
+        };
+    }
+    return null;
+}
+async function healNetwork(rawPage) {
+    await rawPage.waitForLoadState('networkidle', { timeout: HEAL_RETRY_TIMEOUT_MS }).catch(() => { });
+    return {
+        category: shared_1.FailureCategory.NETWORK,
+        rootCause: 'Network Retry',
+        confidence: 0.75,
+    };
+}
+async function prepareHeal(rawPage, locator, action, args, error, opts) {
+    const classification = classifyRuntimeError(error, action);
+    if (!canRuntimeHeal(classification)) {
+        return { type: 'abort' };
+    }
+    const key = categoryKey(classification.category);
+    if (key && !(0, config_1.isHealingCategoryEnabled)(opts.config, key)) {
+        return { type: 'abort' };
+    }
+    switch (classification.category) {
+        case shared_1.FailureCategory.OVERLAY:
+            await dismissOverlays(rawPage);
+            return {
+                type: 'retry',
+                heal: {
+                    category: shared_1.FailureCategory.OVERLAY,
+                    rootCause: 'Overlay Blocked',
+                    confidence: classification.confidence,
+                },
+            };
+        case shared_1.FailureCategory.TIMING:
+            await waitForLocator(locator);
+            return {
+                type: 'retry',
+                heal: {
+                    category: shared_1.FailureCategory.TIMING,
+                    rootCause: 'Timing',
+                    confidence: classification.confidence,
+                },
+            };
+        case shared_1.FailureCategory.SELECTOR:
+            return healGetByTestIdFailure(rawPage, locator, action, args, error);
+        case shared_1.FailureCategory.IFRAME: {
+            const healed = await healIframe(rawPage, locator, action, args, error);
+            if (healed)
+                return { type: 'done', result: undefined, heal: healed };
+            return {
+                type: 'retry',
+                heal: {
+                    category: shared_1.FailureCategory.IFRAME,
+                    rootCause: 'Iframe Context',
+                    confidence: classification.confidence,
+                },
+            };
+        }
+        case shared_1.FailureCategory.SHADOW_DOM: {
+            const healed = await healShadowDom(rawPage, action, args, error);
+            if (healed)
+                return { type: 'done', result: undefined, heal: healed };
+            return { type: 'abort' };
+        }
+        case shared_1.FailureCategory.AUTH:
+        case shared_1.FailureCategory.SESSION: {
+            const healed = await healAuth(rawPage, opts);
+            if (healed)
+                return { type: 'retry', heal: healed };
+            return { type: 'abort' };
+        }
+        case shared_1.FailureCategory.NETWORK:
+            return {
+                type: 'retry',
+                heal: await healNetwork(rawPage),
+            };
+        default:
+            return { type: 'abort' };
+    }
+}
+function wrapLocator(locator, rawPage, options, healContext) {
+    const handler = {
+        get(target, prop, receiver) {
+            if (prop === 'constructor')
+                return target.constructor;
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value !== 'function')
+                return value;
+            const method = prop;
+            if (LOCATOR_CHAIN_METHODS.has(method)) {
+                return (...args) => {
+                    const next = value.apply(target, args);
+                    return wrapLocator(next, rawPage, options, healContext);
+                };
+            }
+            if (!HEALABLE_LOCATOR_ACTIONS.has(method)) {
+                return value.bind(target);
+            }
+            const bound = value.bind(target);
+            return async (...args) => {
+                let lastError;
+                for (let attempt = 0; attempt <= options.maxAttempts; attempt++) {
+                    healContext.attempts = attempt + 1;
+                    try {
+                        return await bound(...resolveActionArgs(args, attempt, method));
+                    }
+                    catch (error) {
+                        lastError = error;
+                        if (!options.autoHeal || attempt >= options.maxAttempts)
+                            break;
+                        const outcome = await prepareHeal(rawPage, target, method, args, error, options);
+                        if (outcome.type !== 'abort' && outcome.heal) {
+                            healContext.healedActions.push(method);
+                            emitHeal(options, outcome.heal, healContext);
+                        }
+                        if (outcome.type === 'done')
+                            return outcome.result;
+                        if (outcome.type === 'retry')
+                            continue;
+                        break;
+                    }
+                }
+                throw lastError;
+            };
+        },
+    };
+    return new Proxy(locator, handler);
+}
+function wrapPage(page, options = {}, healContext) {
+    const opts = resolveOptions(options);
+    const context = healContext ?? { attempts: 0, healedActions: [] };
+    const handler = {
+        get(target, prop, receiver) {
+            if (prop === 'constructor')
+                return target.constructor;
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value !== 'function')
+                return value;
+            const method = prop;
+            if (PAGE_LOCATOR_FACTORIES.has(method)) {
+                return (...args) => {
+                    const nextLocator = value.apply(target, args);
+                    return wrapLocator(nextLocator, target, opts, context);
+                };
+            }
+            if (!HEALABLE_PAGE_ACTIONS.has(method)) {
+                return value.bind(target);
+            }
+            const bound = value.bind(target);
+            return async (...args) => {
+                let lastError;
+                for (let attempt = 0; attempt <= opts.maxAttempts; attempt++) {
+                    context.attempts = attempt + 1;
+                    try {
+                        return await bound(...args);
+                    }
+                    catch (error) {
+                        lastError = error;
+                        if (!opts.autoHeal || attempt >= opts.maxAttempts)
+                            break;
+                        const classification = classifyRuntimeError(error, method);
+                        if (classification.category === shared_1.FailureCategory.TIMING &&
+                            (0, config_1.isHealingCategoryEnabled)(opts.config, 'timing')) {
+                            await target.waitForLoadState('networkidle').catch(() => { });
+                            emitHeal(opts, {
+                                category: shared_1.FailureCategory.TIMING,
+                                rootCause: 'Timing',
+                                confidence: classification.confidence,
+                            }, context);
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                throw lastError;
+            };
+        },
+    };
+    return new Proxy(page, handler);
+}
+function healflowFixture(options = {}) {
+    const opts = resolveOptions(options);
+    return {
+        page: async ({ page }, use, testInfo) => {
+            const healContext = {
+                attempts: 0,
+                healedActions: [],
+                testFile: testInfo.file,
+                testTitle: testInfo.title,
+            };
+            await use(wrapPage(page, opts, healContext));
+        },
+    };
+}
+var register_js_1 = require("./register.js");
+Object.defineProperty(exports, "registerHealFlow", { enumerable: true, get: function () { return register_js_1.registerHealFlow; } });
+var auto_js_1 = require("./auto.js");
+Object.defineProperty(exports, "withHealFlow", { enumerable: true, get: function () { return auto_js_1.withHealFlow; } });
+Object.defineProperty(exports, "configToPluginOptions", { enumerable: true, get: function () { return auto_js_1.configToPluginOptions; } });
+var reporter_js_1 = require("./reporter.js");
+Object.defineProperty(exports, "healflowReporter", { enumerable: true, get: function () { return reporter_js_1.healflowReporter; } });
+var reporter_js_2 = require("./reporter.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(reporter_js_2).default; } });
+//# sourceMappingURL=index.js.map