@stablyai/playwright-base 0.1.0 → 0.1.2

package/dist/ai/extract.d.ts

@@ -1,5 +1,5 @@
-import type { Locator, Page } from 'playwright';
-import * as z4 from 'zod/v4/core';
+import type { Locator, Page } from "@stablyai/internal-playwright-test";
+import * as z4 from "zod/v4/core";
 export type ExtractSchema = z4.$ZodType;
 export type SchemaOutput<T extends ExtractSchema> = z4.output<T>;
 type ExtractSubject = Page | Locator;

package/dist/ai/extract.js

@@ -37,20 +37,21 @@ exports.extract = extract;
 const z4 = __importStar(require("zod/v4/core"));
 const zod_1 = require("zod");
 const runtime_1 = require("../runtime");
-const EXTRACT_ENDPOINT = 'https://api.stably.ai/internal/v1/extract';
+const EXTRACT_ENDPOINT = "https://api.stably.ai/internal/v1/extract";
 const zSuccess = zod_1.z.object({ value: zod_1.z.unknown() });
 const zError = zod_1.z.object({ error: zod_1.z.string() });
 class ExtractValidationError extends Error {
+    issues;
     constructor(message, issues) {
         super(message);
         this.issues = issues;
-        this.name = 'ExtractValidationError';
+        this.name = "ExtractValidationError";
     }
 }
 async function validateWithSchema(schema, value) {
     const result = await z4.safeParseAsync(schema, value);
     if (!result.success) {
-        throw new ExtractValidationError('Validation failed', result.error.issues);
+        throw new ExtractValidationError("Validation failed", result.error.issues);
     }
     return result.data;
 }
@@ -58,16 +59,16 @@ async function extract({ prompt, pageOrLocator, schema, }) {
     const jsonSchema = schema ? z4.toJSONSchema(schema) : undefined;
     const apiKey = (0, runtime_1.requireApiKey)();
     const form = new FormData();
-    form.append('prompt', prompt);
+    form.append("prompt", prompt);
     if (jsonSchema) {
-        form.append('jsonSchema', JSON.stringify(jsonSchema));
+        form.append("jsonSchema", JSON.stringify(jsonSchema));
     }
-    const pngBuffer = await pageOrLocator.screenshot({ type: 'png' }); // Buffer
+    const pngBuffer = await pageOrLocator.screenshot({ type: "png" }); // Buffer
     const u8 = Uint8Array.from(pngBuffer); // strips Buffer type → plain Uint8Array
-    const blob = new Blob([u8], { type: 'image/png' });
-    form.append('image', blob, 'screenshot.png');
+    const blob = new Blob([u8], { type: "image/png" });
+    form.append("image", blob, "screenshot.png");
     const response = await fetch(EXTRACT_ENDPOINT, {
-        method: 'POST',
+        method: "POST",
         headers: {
             Authorization: `Bearer ${apiKey}`,
         },
@@ -76,10 +77,12 @@ async function extract({ prompt, pageOrLocator, schema, }) {
     const parsed = await response.json().catch(() => undefined);
     if (response.ok) {
         const { value } = zSuccess.parse(parsed);
-        return (schema ? await validateWithSchema(schema, value)
-            : typeof value === 'string' ? value
-                : JSON.stringify(value));
+        return schema
+            ? await validateWithSchema(schema, value)
+            : typeof value === "string"
+                ? value
+                : JSON.stringify(value);
     }
     const err = zError.safeParse(parsed);
-    throw new Error(`Extract failed (${response.status})${err.success ? `: ${err.data.error}` : ''}`);
+    throw new Error(`Extract failed (${response.status})${err.success ? `: ${err.data.error}` : ""}`);
 }

package/dist/ai/verify-prompt.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyPrompt = verifyPrompt;
-const PROMPT_ASSERTION_ENDPOINT = 'https://api.stably.ai/internal/v1/assert';
+const PROMPT_ASSERTION_ENDPOINT = "https://api.stably.ai/internal/v1/assert";
 const zod_1 = require("zod");
 const runtime_1 = require("../runtime");
 const zSuccess = zod_1.z.object({
@@ -14,12 +14,12 @@ const zError = zod_1.z.object({
 async function verifyPrompt({ prompt, screenshot, }) {
     const apiKey = (0, runtime_1.requireApiKey)();
     const form = new FormData();
-    form.append('prompt', prompt);
+    form.append("prompt", prompt);
     const u8 = Uint8Array.from(screenshot);
-    const blob = new Blob([u8], { type: 'image/png' });
-    form.append('image', blob, 'screenshot.png');
+    const blob = new Blob([u8], { type: "image/png" });
+    form.append("image", blob, "screenshot.png");
     const response = await fetch(PROMPT_ASSERTION_ENDPOINT, {
-        method: 'POST',
+        method: "POST",
         headers: {
             Authorization: `Bearer ${apiKey}`,
         },
@@ -34,5 +34,5 @@ async function verifyPrompt({ prompt, screenshot, }) {
         };
     }
     const err = zError.safeParse(parsed);
-    throw new Error(`Verify prompt failed (${response.status})${err.success ? `: ${err.data.error}` : ''}`);
+    throw new Error(`Verify prompt failed (${response.status})${err.success ? `: ${err.data.error}` : ""}`);
 }

package/dist/expect.d.ts

@@ -1,5 +1,5 @@
-import type { Locator, Page } from 'playwright';
-import type { ScreenshotPromptOptions } from './index';
+import type { Locator, Page } from "@stablyai/internal-playwright-test";
+import type { ScreenshotPromptOptions } from "./index";
 type MatcherContext = {
     isNot: boolean;
     message?: () => string;

package/dist/expect.js

@@ -3,72 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stablyPlaywrightMatchers = void 0;
 const playwright_type_predicates_1 = require("./playwright-type-predicates");
 const verify_prompt_1 = require("./ai/verify-prompt");
+const screenshot_1 = require("./screenshot");
 function createFailureMessage({ targetType, condition, didPass, isNot, reason, }) {
-    const expectation = isNot ? 'not to satisfy' : 'to satisfy';
-    const result = didPass ? 'it did' : 'it did not';
+    const expectation = isNot ? "not to satisfy" : "to satisfy";
+    const result = didPass ? "it did" : "it did not";
     let message = `Expected ${targetType} ${expectation} ${JSON.stringify(condition)}, but ${result}.`;
     if (reason) {
         message += `\n\nReason: ${reason}`;
     }
     return message;
 }
-function areScreenshotsEqual(a, b) {
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    for (let index = 0; index < a.byteLength; index += 1) {
-        if (a[index] !== b[index]) {
-            return false;
-        }
-    }
-    return true;
-}
-async function takeStableScreenshot(target, options) {
-    var _a;
-    const page = (0, playwright_type_predicates_1.isPage)(target) ? target : target.page();
-    // Use a small budget for stabilization within the overall assertion timeout.
-    // We allocate up to 25% of the total timeout (bounded between 300ms and 2000ms).
-    const totalTimeout = (_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : 5000;
-    // Budget is 25% of the total timeout
-    const stabilizationBudgetMs = Math.floor(totalTimeout * 0.25);
-    const stabilityBudgetMs = Math.min(2000, Math.max(300, stabilizationBudgetMs));
-    const deadline = Date.now() + stabilityBudgetMs;
-    let actual;
-    let previous;
-    const pollIntervals = [0, 100, 250, 500];
-    let isFirstIteration = true;
-    while (true) {
-        if (Date.now() >= deadline)
-            break;
-        const delay = pollIntervals.length ? pollIntervals.shift() : 1000;
-        if (delay) {
-            await page.waitForTimeout(delay);
-        }
-        previous = actual;
-        const rawScreenshot = await target.screenshot(options);
-        actual = Uint8Array.from(rawScreenshot);
-        if (!isFirstIteration &&
-            actual &&
-            previous &&
-            areScreenshotsEqual(actual, previous)) {
-            return actual;
-        }
-        isFirstIteration = false;
-    }
-    return actual !== null && actual !== void 0 ? actual : Uint8Array.from(await target.screenshot(options));
-}
 exports.stablyPlaywrightMatchers = {
     async toMatchScreenshotPrompt(received, condition, options) {
-        const target = (0, playwright_type_predicates_1.isPage)(received) ? received
-            : (0, playwright_type_predicates_1.isLocator)(received) ? received
+        const target = (0, playwright_type_predicates_1.isPage)(received)
+            ? received
+            : (0, playwright_type_predicates_1.isLocator)(received)
+                ? received
                 : undefined;
         if (!target) {
             // Should never happen
-            throw new Error('toMatchScreenshotPrompt only supports Playwright Page and Locator instances.');
+            throw new Error("toMatchScreenshotPrompt only supports Playwright Page and Locator instances.");
         }
-        const targetType = (0, playwright_type_predicates_1.isPage)(target) ? 'page' : 'locator';
+        const targetType = (0, playwright_type_predicates_1.isPage)(target) ? "page" : "locator";
         // Wait for two consecutive identical screenshots before sending to AI
-        const screenshot = await takeStableScreenshot(target, options);
+        const screenshot = await (0, screenshot_1.takeStableScreenshot)(target, options);
         const verifyResult = await (0, verify_prompt_1.verifyPrompt)({ prompt: condition, screenshot });
         return {
             pass: verifyResult.pass,

package/dist/image-compare.d.ts

@@ -0,0 +1,5 @@
+export declare const imagesAreSimilar: ({ image1, image2, threshold, }: {
+    image1: Buffer;
+    image2: Buffer;
+    threshold: number;
+}) => boolean;

package/dist/image-compare.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imagesAreSimilar = void 0;
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const pngjs_1 = require("pngjs");
+const jpeg = __importStar(require("jpeg-js"));
+const isPng = (buffer) => {
+    return (buffer.length >= 8 &&
+        buffer[0] === 0x89 &&
+        buffer[1] === 0x50 &&
+        buffer[2] === 0x4e &&
+        buffer[3] === 0x47 &&
+        buffer[4] === 0x0d &&
+        buffer[5] === 0x0a &&
+        buffer[6] === 0x1a &&
+        buffer[7] === 0x0a);
+};
+const isJpeg = (buffer) => {
+    return buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xd8;
+};
+const decodeImage = (buffer) => {
+    if (isPng(buffer)) {
+        const png = pngjs_1.PNG.sync.read(buffer);
+        return { data: png.data, width: png.width, height: png.height };
+    }
+    if (isJpeg(buffer)) {
+        const img = jpeg.decode(buffer, { maxMemoryUsageInMB: 1024 });
+        return { data: img.data, width: img.width, height: img.height };
+    }
+    // Default to PNG decode; if it fails upstream, treat as different sizes
+    const png = pngjs_1.PNG.sync.read(buffer);
+    return { data: png.data, width: png.width, height: png.height };
+};
+const imagesAreSimilar = ({ image1, image2, threshold, }) => {
+    const decodedImage1 = decodeImage(image1);
+    const decodedImage2 = decodeImage(image2);
+    if (decodedImage1.width !== decodedImage2.width ||
+        decodedImage1.height !== decodedImage2.height) {
+        return false;
+    }
+    const diffRgbaData = new Uint8Array(decodedImage1.width * decodedImage1.height * 4);
+    const numDiffPixels = (0, pixelmatch_1.default)(decodedImage1.data, decodedImage2.data, diffRgbaData, decodedImage1.width, decodedImage1.height, { threshold });
+    return numDiffPixels === 0;
+};
+exports.imagesAreSimilar = imagesAreSimilar;

package/dist/index.d.ts

@@ -1,27 +1,69 @@
-import type { Page } from 'playwright';
-import type { LocatorDescribeOptions } from './playwright-augment/augment';
-import type { ExtractSchema, SchemaOutput } from './ai/extract';
-import { augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage } from './playwright-augment/augment';
-import { stablyPlaywrightMatchers } from './expect';
-import { requireApiKey } from './runtime';
-export { setApiKey } from './runtime';
-export type { LocatorDescribeOptions } from './playwright-augment/augment';
-export type { ExtractSchema, SchemaOutput } from './ai/extract';
-export type ScreenshotPromptOptions = import('@playwright/test').PageAssertionsToHaveScreenshotOptions;
+import type { Page } from "@stablyai/internal-playwright-test";
+import type { LocatorDescribeOptions } from "./playwright-augment/augment";
+import type { ExtractSchema, SchemaOutput } from "./ai/extract";
+import { augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage } from "./playwright-augment/augment";
+import { stablyPlaywrightMatchers } from "./expect";
+import { requireApiKey } from "./runtime";
+export { setApiKey } from "./runtime";
+export type { LocatorDescribeOptions } from "./playwright-augment/augment";
+export type { ExtractSchema, SchemaOutput } from "./ai/extract";
+export type ScreenshotPromptOptions = import("@stablyai/internal-playwright-test").PageAssertionsToHaveScreenshotOptions;
 export { augmentBrowser, augmentBrowserContext, augmentBrowserType, augmentLocator, augmentPage, stablyPlaywrightMatchers, requireApiKey, };
 export interface Expect<T = Page> {
     toMatchScreenshotPrompt(condition: string, options?: ScreenshotPromptOptions): Promise<void>;
 }
-declare module 'playwright' {
+declare module "@stablyai/internal-playwright-test" {
     interface Locator {
+        /**
+         * Extracts information from this locator using Stably AI.
+         *
+         * Takes a screenshot of the locator and uses AI to extract information based on the
+         * provided prompt. When a schema is provided, the extracted data is validated and
+         * typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @returns A string containing the extracted information
+         */
         extract(prompt: string): Promise<string>;
+        /**
+         * Extracts information from this locator using Stably AI.
+         *
+         * Takes a screenshot of the locator and uses AI to extract information based on the
+         * provided prompt. The extracted data is validated and typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @param options - Configuration object containing the Zod schema for validation
+         * @param options.schema - Zod schema to validate and type the extracted data
+         * @returns Typed data matching the provided schema
+         */
         extract<T extends ExtractSchema>(prompt: string, options: {
             schema: T;
         }): Promise<SchemaOutput<T>>;
         describe(description: string, options?: LocatorDescribeOptions): Locator;
     }
     interface Page {
+        /**
+         * Extracts information from this page using Stably AI.
+         *
+         * Takes a screenshot of the page and uses AI to extract information based on the
+         * provided prompt. When a schema is provided, the extracted data is validated and
+         * typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @returns A string containing the extracted information
+         */
         extract(prompt: string): Promise<string>;
+        /**
+         * Extracts information from this page using Stably AI.
+         *
+         * Takes a screenshot of the page and uses AI to extract information based on the
+         * provided prompt. The extracted data is validated and typed according to the schema.
+         *
+         * @param prompt - A natural language description of what information to extract
+         * @param options - Configuration object containing the Zod schema for validation
+         * @param options.schema - Zod schema to validate and type the extracted data
+         * @returns Typed data matching the provided schema
+         */
         extract<T extends ExtractSchema>(prompt: string, options: {
             schema: T;
         }): Promise<SchemaOutput<T>>;

package/dist/playwright-augment/augment.d.ts

@@ -1,4 +1,4 @@
-import type { Browser, BrowserContext, BrowserType, Locator, Page } from 'playwright';
+import type { Browser, BrowserContext, BrowserType, Locator, Page } from "@stablyai/internal-playwright-test";
 export interface LocatorDescribeOptions {
     autoHeal?: boolean;
 }

package/dist/playwright-augment/augment.js

@@ -7,12 +7,12 @@ exports.augmentBrowser = augmentBrowser;
 exports.augmentBrowserType = augmentBrowserType;
 const extract_1 = require("./methods/extract");
 const agent_1 = require("./methods/agent");
-const LOCATOR_PATCHED = Symbol.for('stably.playwright.locatorPatched');
-const LOCATOR_DESCRIBE_WRAPPED = Symbol.for('stably.playwright.locatorDescribeWrapped');
-const PAGE_PATCHED = Symbol.for('stably.playwright.pagePatched');
-const CONTEXT_PATCHED = Symbol.for('stably.playwright.contextPatched');
-const BROWSER_PATCHED = Symbol.for('stably.playwright.browserPatched');
-const BROWSER_TYPE_PATCHED = Symbol.for('stably.playwright.browserTypePatched');
+const LOCATOR_PATCHED = Symbol.for("stably.playwright.locatorPatched");
+const LOCATOR_DESCRIBE_WRAPPED = Symbol.for("stably.playwright.locatorDescribeWrapped");
+const PAGE_PATCHED = Symbol.for("stably.playwright.pagePatched");
+const CONTEXT_PATCHED = Symbol.for("stably.playwright.contextPatched");
+const BROWSER_PATCHED = Symbol.for("stably.playwright.browserPatched");
+const BROWSER_TYPE_PATCHED = Symbol.for("stably.playwright.browserTypePatched");
 function defineHiddenProperty(target, key, value) {
     Object.defineProperty(target, key, {
         value,
@@ -25,9 +25,9 @@ function augmentLocator(locator) {
     if (locator[LOCATOR_PATCHED]) {
         return locator;
     }
-    defineHiddenProperty(locator, 'extract', (0, extract_1.createLocatorExtract)(locator));
+    defineHiddenProperty(locator, "extract", (0, extract_1.createLocatorExtract)(locator));
     const markerTarget = locator;
-    if (typeof locator.describe === 'function' &&
+    if (typeof locator.describe === "function" &&
         !markerTarget[LOCATOR_DESCRIBE_WRAPPED]) {
         const originalDescribe = locator.describe.bind(locator);
         locator.describe = ((description, options) => {
@@ -49,12 +49,11 @@ function augmentPage(page) {
         const locator = originalLocator(...args);
         return augmentLocator(locator);
     });
-    defineHiddenProperty(page, 'extract', (0, extract_1.createPageExtract)(page));
+    defineHiddenProperty(page, "extract", (0, extract_1.createPageExtract)(page));
     defineHiddenProperty(page, PAGE_PATCHED, true);
     return page;
 }
 function augmentBrowserContext(context) {
-    var _a;
     if (context[CONTEXT_PATCHED]) {
         return context;
     }
@@ -63,12 +62,12 @@ function augmentBrowserContext(context) {
         const page = await originalNewPage(...args);
         return augmentPage(page);
     });
-    const originalPages = (_a = context.pages) === null || _a === void 0 ? void 0 : _a.bind(context);
+    const originalPages = context.pages?.bind(context);
     if (originalPages) {
         context.pages = (() => originalPages().map((page) => augmentPage(page)));
     }
     if (!context.agent) {
-        defineHiddenProperty(context, 'agent', (0, agent_1.createAgentStub)());
+        defineHiddenProperty(context, "agent", (0, agent_1.createAgentStub)());
     }
     defineHiddenProperty(context, CONTEXT_PATCHED, true);
     return context;
@@ -90,13 +89,12 @@ function augmentBrowser(browser) {
     const originalContexts = browser.contexts.bind(browser);
     browser.contexts = (() => originalContexts().map((context) => augmentBrowserContext(context)));
     if (!browser.agent) {
-        defineHiddenProperty(browser, 'agent', (0, agent_1.createAgentStub)());
+        defineHiddenProperty(browser, "agent", (0, agent_1.createAgentStub)());
     }
     defineHiddenProperty(browser, BROWSER_PATCHED, true);
     return browser;
 }
 function augmentBrowserType(browserType) {
-    var _a, _b, _c;
     if (browserType[BROWSER_TYPE_PATCHED]) {
         return browserType;
     }
@@ -105,21 +103,21 @@ function augmentBrowserType(browserType) {
         const browser = await originalLaunch(...args);
         return augmentBrowser(browser);
     });
-    const originalConnect = (_a = browserType.connect) === null || _a === void 0 ? void 0 : _a.bind(browserType);
+    const originalConnect = browserType.connect?.bind(browserType);
     if (originalConnect) {
         browserType.connect = (async (...args) => {
             const browser = await originalConnect(...args);
             return augmentBrowser(browser);
         });
     }
-    const originalConnectOverCDP = (_b = browserType.connectOverCDP) === null || _b === void 0 ? void 0 : _b.bind(browserType);
+    const originalConnectOverCDP = browserType.connectOverCDP?.bind(browserType);
     if (originalConnectOverCDP) {
         browserType.connectOverCDP = (async (...args) => {
             const browser = await originalConnectOverCDP(...args);
             return augmentBrowser(browser);
         });
     }
-    const originalLaunchPersistentContext = (_c = browserType.launchPersistentContext) === null || _c === void 0 ? void 0 : _c.bind(browserType);
+    const originalLaunchPersistentContext = browserType.launchPersistentContext?.bind(browserType);
     if (originalLaunchPersistentContext) {
         browserType.launchPersistentContext = (async (...args) => {
             const context = await originalLaunchPersistentContext(...args);

package/dist/playwright-augment/methods/agent.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from 'playwright';
+import type { Page } from "@stablyai/internal-playwright-test";
 type AgentOptions = {
     page: Page;
     maxCycles?: number;

package/dist/playwright-augment/methods/auto-heal.d.ts

@@ -0,0 +1,16 @@
+import type { Locator, Page } from "playwright";
+export type LocatorAutoHealContext = {
+    description: string;
+    error: unknown;
+    locator: Locator;
+    method: string;
+    args: unknown[];
+    page: Page;
+};
+export type LocatorAutoHealResult = {
+    locator?: Locator;
+    retry?: boolean;
+} | void;
+export type LocatorAutoHealHandler = (context: LocatorAutoHealContext) => LocatorAutoHealResult | Promise<LocatorAutoHealResult>;
+export declare function setLocatorAutoHealHandler(handler: LocatorAutoHealHandler | undefined): void;
+export declare function getLocatorAutoHealHandler(): LocatorAutoHealHandler | undefined;

package/dist/playwright-augment/methods/auto-heal.js

@@ -0,0 +1,7 @@
+let locatorAutoHealHandler;
+export function setLocatorAutoHealHandler(handler) {
+    locatorAutoHealHandler = handler;
+}
+export function getLocatorAutoHealHandler() {
+    return locatorAutoHealHandler;
+}

package/dist/playwright-augment/methods/extract.d.ts

@@ -1,5 +1,5 @@
-import type { Locator, Page } from 'playwright';
-import { type ExtractSchema, type SchemaOutput } from '../../ai/extract';
+import type { Locator, Page } from "@stablyai/internal-playwright-test";
+import { type ExtractSchema, type SchemaOutput } from "../../ai/extract";
 type ExtractOptions<T extends ExtractSchema> = {
     schema: T;
 };

package/dist/playwright-augment/methods/extract.js

@@ -4,7 +4,7 @@ exports.createPageExtract = exports.createLocatorExtract = void 0;
 const extract_1 = require("../../ai/extract");
 function createExtract(pageOrLocator) {
     const impl = (async (prompt, options) => {
-        if (options === null || options === void 0 ? void 0 : options.schema) {
+        if (options?.schema) {
             return (0, extract_1.extract)({
                 prompt,
                 schema: options.schema,

package/dist/playwright-augment/methods/test-info.d.ts

@@ -0,0 +1,16 @@
+import type { BrowserContext, Page } from "playwright";
+import type { TestInfo } from "@playwright/test";
+export declare function setContextTestInfo(context: BrowserContext, testInfo: TestInfo | undefined): void;
+export declare function getContextTestInfo(context: BrowserContext): TestInfo | undefined;
+export declare function setPageTestInfo(page: Page, testInfo: TestInfo | undefined): void;
+export declare function getPageTestInfo(page: Page): TestInfo | undefined;
+export declare function inheritTestInfoFromContext(page: Page): void;
+export type AutoHealEventOutcome = "fallback" | "retry" | "failed" | "handler-error";
+export interface AutoHealEvent {
+    description: string;
+    method: string;
+    outcome: AutoHealEventOutcome;
+    details?: string;
+    error?: unknown;
+}
+export declare function recordAutoHealEvent(page: Page, event: AutoHealEvent): void;

package/dist/playwright-augment/methods/test-info.js

@@ -0,0 +1,96 @@
+const TEST_INFO_SYMBOL = Symbol.for("stably.playwright.testInfo");
+function defineHiddenProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: false,
+        configurable: true,
+        writable: true,
+    });
+}
+function getHiddenProperty(target, key) {
+    return target[key];
+}
+export function setContextTestInfo(context, testInfo) {
+    defineHiddenProperty(context, TEST_INFO_SYMBOL, testInfo);
+}
+export function getContextTestInfo(context) {
+    return getHiddenProperty(context, TEST_INFO_SYMBOL);
+}
+export function setPageTestInfo(page, testInfo) {
+    defineHiddenProperty(page, TEST_INFO_SYMBOL, testInfo);
+}
+export function getPageTestInfo(page) {
+    return getHiddenProperty(page, TEST_INFO_SYMBOL);
+}
+function safeGetContext(page) {
+    try {
+        return page.context();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function inheritTestInfoFromContext(page) {
+    if (getPageTestInfo(page)) {
+        return;
+    }
+    const context = safeGetContext(page);
+    if (!context) {
+        return;
+    }
+    const testInfo = getContextTestInfo(context);
+    if (testInfo) {
+        setPageTestInfo(page, testInfo);
+    }
+}
+function resolveTestInfo(page) {
+    const pageInfo = getPageTestInfo(page);
+    if (pageInfo) {
+        return pageInfo;
+    }
+    const context = safeGetContext(page);
+    if (!context) {
+        return undefined;
+    }
+    return getContextTestInfo(context);
+}
+function toErrorMessage(error) {
+    if (!error)
+        return undefined;
+    if (error instanceof Error) {
+        return error.stack ?? error.message ?? error.name;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+export function recordAutoHealEvent(page, event) {
+    const testInfo = resolveTestInfo(page);
+    if (!testInfo || !Array.isArray(testInfo.attachments)) {
+        return;
+    }
+    const lines = [
+        `Auto-heal description: ${event.description}`,
+        `Locator method: ${event.method}`,
+        `Outcome: ${event.outcome}`,
+    ];
+    if (event.details) {
+        lines.push(`Details: ${event.details}`);
+    }
+    const errorMessage = toErrorMessage(event.error);
+    if (errorMessage) {
+        lines.push(`Error: ${errorMessage}`);
+    }
+    const body = Buffer.from(lines.join("\n"), "utf-8");
+    testInfo.attachments.push({
+        name: `Stably Auto-heal (${event.method})`,
+        contentType: "text/plain",
+        body,
+    });
+}

package/dist/playwright-type-predicates.d.ts

@@ -1,3 +1,3 @@
-import { Page, Locator } from 'playwright';
+import { Page, Locator } from "@stablyai/internal-playwright-test";
 export declare function isPage(candidate: unknown): candidate is Page;
 export declare function isLocator(candidate: unknown): candidate is Locator;