sentienceapi 0.93.0 → 0.94.0

package/dist/asserts/expect.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Expectation builder for assertion DSL.
+ *
+ * This module provides the expect() builder that creates fluent assertions
+ * which compile to existing Predicate objects.
+ *
+ * Key classes:
+ * - ExpectBuilder: Fluent builder for element-based assertions
+ * - EventuallyConfig: Configuration for .eventually() retry logic
+ *
+ * The expect() function is the main entry point. It returns a builder that
+ * can be chained with matchers:
+ *     expect(E({ role: "button" })).toExist()
+ *     expect(E({ textContains: "Error" })).notToExist()
+ *     expect.textPresent("Welcome")
+ *
+ * All builders compile to Predicate functions compatible with AgentRuntime.assert().
+ */
+import { Predicate, AssertOutcome, AssertContext } from '../verification';
+import { ElementQuery, MultiQuery, MultiTextPredicate } from './query';
+/**
+ * Configuration for .eventually() retry logic.
+ */
+export interface EventuallyConfig {
+    /** Max time to wait (milliseconds, default 10000) */
+    timeout?: number;
+    /** Interval between retries (milliseconds, default 200) */
+    poll?: number;
+    /** Max number of retry attempts (default 3) */
+    maxRetries?: number;
+}
+/**
+ * Fluent builder for element-based assertions.
+ *
+ * Created by expect(E(...)) or expect(inDominantList().nth(k)).
+ *
+ * Methods return Predicate functions that can be passed to runtime.assert().
+ *
+ * @example
+ * expect(E({ role: "button" })).toExist()
+ * expect(E({ textContains: "Error" })).notToExist()
+ * expect(E({ role: "link" })).toBeVisible()
+ */
+export declare class ExpectBuilder {
+    private _query;
+    constructor(query: ElementQuery | MultiQuery | MultiTextPredicate);
+    /**
+     * Assert that at least one element matches the query.
+     *
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(E({ role: "button", textContains: "Save" })).toExist(),
+     *   "save_button_exists"
+     * );
+     */
+    toExist(): Predicate;
+    /**
+     * Assert that NO elements match the query.
+     *
+     * Useful for asserting absence of error messages, loading indicators, etc.
+     *
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(E({ textContains: "Error" })).notToExist(),
+     *   "no_error_message"
+     * );
+     */
+    notToExist(): Predicate;
+    /**
+     * Assert that element exists AND is visible (in_viewport=true, is_occluded=false).
+     *
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(E({ textContains: "Checkout" })).toBeVisible(),
+     *   "checkout_button_visible"
+     * );
+     */
+    toBeVisible(): Predicate;
+    /**
+     * Assert that element's text contains the specified substring.
+     *
+     * @param text - Substring to search for (case-insensitive)
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(inDominantList().nth(0)).toHaveTextContains("Show HN"),
+     *   "first_item_is_show_hn"
+     * );
+     */
+    toHaveTextContains(text: string): Predicate;
+}
+/**
+ * Main entry point for the assertion DSL.
+ *
+ * Use as a function to create element-based assertions:
+ *   expect(E({ role: "button" })).toExist()
+ *
+ * Use static methods for global assertions:
+ *   expect.textPresent("Welcome")
+ *   expect.noText("Error")
+ */
+export declare const expect: ((query: ElementQuery | MultiQuery | MultiTextPredicate) => ExpectBuilder) & {
+    textPresent: (text: string) => Predicate;
+    noText: (text: string) => Predicate;
+};
+/**
+ * Wrapper that adds retry logic to a predicate.
+ *
+ * Created by withEventually(). Provides an async evaluate() method
+ * that retries the predicate with fresh snapshots.
+ *
+ * Note: TypeScript uses milliseconds for timeout/poll.
+ */
+export declare class EventuallyWrapper {
+    private _predicate;
+    private _config;
+    constructor(predicate: Predicate, config?: EventuallyConfig);
+    /**
+     * Evaluate predicate with retry logic.
+     *
+     * @param ctx - Initial assertion context
+     * @param snapshotFn - Async function to take fresh snapshots
+     * @returns Promise resolving to AssertOutcome
+     */
+    evaluate(ctx: AssertContext, snapshotFn: () => Promise<AssertContext['snapshot']>): Promise<AssertOutcome>;
+    private sleep;
+    /** Get the configured timeout in milliseconds */
+    get timeout(): number;
+    /** Get the configured poll interval in milliseconds */
+    get poll(): number;
+    /** Get the configured max retries */
+    get maxRetries(): number;
+}
+/**
+ * Wrap a predicate with retry logic.
+ *
+ * This is the TypeScript API for .eventually(). Returns a wrapper
+ * that provides an async evaluate() method for use with the runtime.
+ *
+ * @param predicate - Predicate to wrap
+ * @param config - Retry configuration (timeout/poll in milliseconds)
+ * @returns EventuallyWrapper with async evaluate() method
+ *
+ * @example
+ * const wrapper = withEventually(
+ *   expect(E({ role: "button" })).toExist(),
+ *   { timeout: 5000, maxRetries: 10 }
+ * );
+ * const result = await wrapper.evaluate(ctx, runtime.snapshot);
+ */
+export declare function withEventually(predicate: Predicate, config?: EventuallyConfig): EventuallyWrapper;
+//# sourceMappingURL=expect.d.ts.map

package/dist/asserts/expect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/asserts/expect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAOvE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAoCD;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAiD;gBAEnD,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,kBAAkB;IAIjE;;;;;;;;;;OAUG;IACH,OAAO,IAAI,SAAS;IA+BpB;;;;;;;;;;;;OAYG;IACH,UAAU,IAAI,SAAS;IAiCvB;;;;;;;;;;OAUG;IACH,WAAW,IAAI,SAAS;IAgDxB;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;CA8C5C;AAqID;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,WACT,YAAY,GAAG,UAAU,GAAG,kBAAkB;wBAEhC,MAAM;mBACX,MAAM;CAExB,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,OAAO,CAA6B;gBAEhC,SAAS,EAAE,SAAS,EAAE,MAAM,GAAE,gBAAqB;IAS/D;;;;;;OAMG;IACG,QAAQ,CACZ,GAAG,EAAE,aAAa,EAClB,UAAU,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,GACnD,OAAO,CAAC,aAAa,CAAC;IA8EzB,OAAO,CAAC,KAAK;IAIb,iDAAiD;IACjD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,uDAAuD;IACvD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,qCAAqC;IACrC,IAAI,UAAU,IAAI,MAAM,CAEvB;CACF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAEjG"}

package/dist/asserts/expect.js

@@ -0,0 +1,547 @@
+"use strict";
+/**
+ * Expectation builder for assertion DSL.
+ *
+ * This module provides the expect() builder that creates fluent assertions
+ * which compile to existing Predicate objects.
+ *
+ * Key classes:
+ * - ExpectBuilder: Fluent builder for element-based assertions
+ * - EventuallyConfig: Configuration for .eventually() retry logic
+ *
+ * The expect() function is the main entry point. It returns a builder that
+ * can be chained with matchers:
+ *     expect(E({ role: "button" })).toExist()
+ *     expect(E({ textContains: "Error" })).notToExist()
+ *     expect.textPresent("Welcome")
+ *
+ * All builders compile to Predicate functions compatible with AgentRuntime.assert().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventuallyWrapper = exports.expect = exports.ExpectBuilder = void 0;
+exports.withEventually = withEventually;
+const query_1 = require("./query");
+// Default values for .eventually()
+const DEFAULT_TIMEOUT = 10000; // milliseconds
+const DEFAULT_POLL = 200; // milliseconds
+const DEFAULT_MAX_RETRIES = 3;
+/**
+ * Convert query to a serializable object for debugging.
+ */
+function queryToDict(query) {
+    if (query instanceof query_1.ElementQuery) {
+        const result = {};
+        if (query.role)
+            result.role = query.role;
+        if (query.name)
+            result.name = query.name;
+        if (query.text)
+            result.text = query.text;
+        if (query.textContains)
+            result.textContains = query.textContains;
+        if (query.hrefContains)
+            result.hrefContains = query.hrefContains;
+        if (query.inViewport !== undefined)
+            result.inViewport = query.inViewport;
+        if (query.occluded !== undefined)
+            result.occluded = query.occluded;
+        if (query.group)
+            result.group = query.group;
+        if (query.inDominantGroup !== undefined)
+            result.inDominantGroup = query.inDominantGroup;
+        if (query._groupIndex !== undefined)
+            result.groupIndex = query._groupIndex;
+        if (query._fromDominantList)
+            result.fromDominantList = true;
+        return result;
+    }
+    else if (query instanceof query_1.MultiQuery) {
+        return { type: 'multi', limit: query.limit };
+    }
+    else if (typeof query === 'object' &&
+        query !== null &&
+        'checkType' in query &&
+        'text' in query &&
+        'multiQuery' in query) {
+        return { type: 'multi_text', text: query.text, checkType: query.checkType };
+    }
+    return { type: String(typeof query) };
+}
+/**
+ * Fluent builder for element-based assertions.
+ *
+ * Created by expect(E(...)) or expect(inDominantList().nth(k)).
+ *
+ * Methods return Predicate functions that can be passed to runtime.assert().
+ *
+ * @example
+ * expect(E({ role: "button" })).toExist()
+ * expect(E({ textContains: "Error" })).notToExist()
+ * expect(E({ role: "link" })).toBeVisible()
+ */
+class ExpectBuilder {
+    constructor(query) {
+        this._query = query;
+    }
+    /**
+     * Assert that at least one element matches the query.
+     *
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(E({ role: "button", textContains: "Save" })).toExist(),
+     *   "save_button_exists"
+     * );
+     */
+    toExist() {
+        const query = this._query;
+        return (ctx) => {
+            const snap = ctx.snapshot;
+            if (!snap) {
+                return {
+                    passed: false,
+                    reason: 'no snapshot available',
+                    details: { query: queryToDict(query) },
+                };
+            }
+            if (query instanceof query_1.ElementQuery) {
+                const matches = query.findAll(snap);
+                const ok = matches.length > 0;
+                return {
+                    passed: ok,
+                    reason: ok ? '' : `no elements matched query: ${JSON.stringify(queryToDict(query))}`,
+                    details: { query: queryToDict(query), matched: matches.length },
+                };
+            }
+            return {
+                passed: false,
+                reason: 'toExist() requires ElementQuery',
+                details: {},
+            };
+        };
+    }
+    /**
+     * Assert that NO elements match the query.
+     *
+     * Useful for asserting absence of error messages, loading indicators, etc.
+     *
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(E({ textContains: "Error" })).notToExist(),
+     *   "no_error_message"
+     * );
+     */
+    notToExist() {
+        const query = this._query;
+        return (ctx) => {
+            const snap = ctx.snapshot;
+            if (!snap) {
+                return {
+                    passed: false,
+                    reason: 'no snapshot available',
+                    details: { query: queryToDict(query) },
+                };
+            }
+            if (query instanceof query_1.ElementQuery) {
+                const matches = query.findAll(snap);
+                const ok = matches.length === 0;
+                return {
+                    passed: ok,
+                    reason: ok
+                        ? ''
+                        : `found ${matches.length} elements matching: ${JSON.stringify(queryToDict(query))}`,
+                    details: { query: queryToDict(query), matched: matches.length },
+                };
+            }
+            return {
+                passed: false,
+                reason: 'notToExist() requires ElementQuery',
+                details: {},
+            };
+        };
+    }
+    /**
+     * Assert that element exists AND is visible (in_viewport=true, is_occluded=false).
+     *
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(E({ textContains: "Checkout" })).toBeVisible(),
+     *   "checkout_button_visible"
+     * );
+     */
+    toBeVisible() {
+        const query = this._query;
+        return (ctx) => {
+            const snap = ctx.snapshot;
+            if (!snap) {
+                return {
+                    passed: false,
+                    reason: 'no snapshot available',
+                    details: { query: queryToDict(query) },
+                };
+            }
+            if (query instanceof query_1.ElementQuery) {
+                const matches = query.findAll(snap);
+                if (matches.length === 0) {
+                    return {
+                        passed: false,
+                        reason: `no elements matched query: ${JSON.stringify(queryToDict(query))}`,
+                        details: { query: queryToDict(query), matched: 0 },
+                    };
+                }
+                // Check visibility of first match
+                const el = matches[0];
+                const isVisible = el.in_viewport && !el.is_occluded;
+                return {
+                    passed: isVisible,
+                    reason: isVisible
+                        ? ''
+                        : `element found but not visible (in_viewport=${el.in_viewport}, is_occluded=${el.is_occluded})`,
+                    details: {
+                        query: queryToDict(query),
+                        elementId: el.id,
+                        inViewport: el.in_viewport,
+                        isOccluded: el.is_occluded,
+                    },
+                };
+            }
+            return {
+                passed: false,
+                reason: 'toBeVisible() requires ElementQuery',
+                details: {},
+            };
+        };
+    }
+    /**
+     * Assert that element's text contains the specified substring.
+     *
+     * @param text - Substring to search for (case-insensitive)
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect(inDominantList().nth(0)).toHaveTextContains("Show HN"),
+     *   "first_item_is_show_hn"
+     * );
+     */
+    toHaveTextContains(text) {
+        const query = this._query;
+        return (ctx) => {
+            const snap = ctx.snapshot;
+            if (!snap) {
+                return {
+                    passed: false,
+                    reason: 'no snapshot available',
+                    details: { query: queryToDict(query), expectedText: text },
+                };
+            }
+            if (query instanceof query_1.ElementQuery) {
+                const matches = query.findAll(snap);
+                if (matches.length === 0) {
+                    return {
+                        passed: false,
+                        reason: `no elements matched query: ${JSON.stringify(queryToDict(query))}`,
+                        details: { query: queryToDict(query), matched: 0, expectedText: text },
+                    };
+                }
+                // Check text of first match
+                const el = matches[0];
+                const elText = el.text || '';
+                const ok = elText.toLowerCase().includes(text.toLowerCase());
+                return {
+                    passed: ok,
+                    reason: ok ? '' : `element text '${elText.substring(0, 100)}' does not contain '${text}'`,
+                    details: {
+                        query: queryToDict(query),
+                        elementId: el.id,
+                        elementText: elText.substring(0, 200),
+                        expectedText: text,
+                    },
+                };
+            }
+            return {
+                passed: false,
+                reason: 'toHaveTextContains() requires ElementQuery',
+                details: {},
+            };
+        };
+    }
+}
+exports.ExpectBuilder = ExpectBuilder;
+/**
+ * Factory for creating ExpectBuilder instances and global assertions.
+ *
+ * This is the main entry point for the assertion DSL.
+ *
+ * @example
+ * import { expect, E } from './asserts';
+ *
+ * // Element-based assertions
+ * expect(E({ role: "button" })).toExist()
+ * expect(E({ textContains: "Error" })).notToExist()
+ *
+ * // Global text assertions
+ * expect.textPresent("Welcome back")
+ * expect.noText("Error")
+ */
+class ExpectFactory {
+    /**
+     * Create an expectation builder for the given query.
+     *
+     * @param query - ElementQuery, MultiQuery, or MultiTextPredicate
+     * @returns ExpectBuilder for chaining matchers
+     *
+     * @example
+     * expect(E({ role: "button" })).toExist()
+     * expect(inDominantList().nth(0)).toHaveTextContains("Show HN")
+     */
+    call(query) {
+        return new ExpectBuilder(query);
+    }
+    /**
+     * Global assertion: check if text is present anywhere on the page.
+     *
+     * Searches across all element text fields.
+     *
+     * @param text - Text to search for (case-insensitive substring)
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect.textPresent("Welcome back"),
+     *   "user_logged_in"
+     * );
+     */
+    textPresent(text) {
+        return (ctx) => {
+            const snap = ctx.snapshot;
+            if (!snap) {
+                return {
+                    passed: false,
+                    reason: 'no snapshot available',
+                    details: { searchText: text },
+                };
+            }
+            // Search all element texts
+            const textLower = text.toLowerCase();
+            for (const el of snap.elements) {
+                const elText = el.text || '';
+                if (elText.toLowerCase().includes(textLower)) {
+                    return {
+                        passed: true,
+                        reason: '',
+                        details: { searchText: text, foundInElement: el.id },
+                    };
+                }
+            }
+            return {
+                passed: false,
+                reason: `text '${text}' not found on page`,
+                details: { searchText: text, elementsSearched: snap.elements.length },
+            };
+        };
+    }
+    /**
+     * Global assertion: check that text is NOT present anywhere on the page.
+     *
+     * Searches across all element text fields.
+     *
+     * @param text - Text that should not be present (case-insensitive substring)
+     * @returns Predicate function for use with runtime.assert()
+     *
+     * @example
+     * await runtime.assert(
+     *   expect.noText("Error"),
+     *   "no_error_message"
+     * );
+     */
+    noText(text) {
+        return (ctx) => {
+            const snap = ctx.snapshot;
+            if (!snap) {
+                return {
+                    passed: false,
+                    reason: 'no snapshot available',
+                    details: { searchText: text },
+                };
+            }
+            // Search all element texts
+            const textLower = text.toLowerCase();
+            for (const el of snap.elements) {
+                const elText = el.text || '';
+                if (elText.toLowerCase().includes(textLower)) {
+                    return {
+                        passed: false,
+                        reason: `text '${text}' found in element id=${el.id}`,
+                        details: {
+                            searchText: text,
+                            foundInElement: el.id,
+                            elementText: elText.substring(0, 200),
+                        },
+                    };
+                }
+            }
+            return {
+                passed: true,
+                reason: '',
+                details: { searchText: text, elementsSearched: snap.elements.length },
+            };
+        };
+    }
+}
+// Create the singleton factory
+const factoryInstance = new ExpectFactory();
+/**
+ * Main entry point for the assertion DSL.
+ *
+ * Use as a function to create element-based assertions:
+ *   expect(E({ role: "button" })).toExist()
+ *
+ * Use static methods for global assertions:
+ *   expect.textPresent("Welcome")
+ *   expect.noText("Error")
+ */
+exports.expect = Object.assign((query) => factoryInstance.call(query), {
+    textPresent: (text) => factoryInstance.textPresent(text),
+    noText: (text) => factoryInstance.noText(text),
+});
+/**
+ * Wrapper that adds retry logic to a predicate.
+ *
+ * Created by withEventually(). Provides an async evaluate() method
+ * that retries the predicate with fresh snapshots.
+ *
+ * Note: TypeScript uses milliseconds for timeout/poll.
+ */
+class EventuallyWrapper {
+    constructor(predicate, config = {}) {
+        this._predicate = predicate;
+        this._config = {
+            timeout: config.timeout ?? DEFAULT_TIMEOUT,
+            poll: config.poll ?? DEFAULT_POLL,
+            maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+        };
+    }
+    /**
+     * Evaluate predicate with retry logic.
+     *
+     * @param ctx - Initial assertion context
+     * @param snapshotFn - Async function to take fresh snapshots
+     * @returns Promise resolving to AssertOutcome
+     */
+    async evaluate(ctx, snapshotFn) {
+        const startTime = Date.now();
+        let lastOutcome = null;
+        let attempts = 0;
+        while (true) {
+            // Check timeout (higher precedence than maxRetries)
+            const elapsed = Date.now() - startTime;
+            if (elapsed >= this._config.timeout) {
+                if (lastOutcome) {
+                    lastOutcome.reason = `timeout after ${elapsed}ms: ${lastOutcome.reason}`;
+                    return lastOutcome;
+                }
+                return {
+                    passed: false,
+                    reason: `timeout after ${elapsed}ms`,
+                    details: { attempts },
+                };
+            }
+            // Check max retries
+            if (attempts >= this._config.maxRetries) {
+                if (lastOutcome) {
+                    lastOutcome.reason = `max retries (${this._config.maxRetries}) exceeded: ${lastOutcome.reason}`;
+                    return lastOutcome;
+                }
+                return {
+                    passed: false,
+                    reason: `max retries (${this._config.maxRetries}) exceeded`,
+                    details: { attempts },
+                };
+            }
+            // Take fresh snapshot if not first attempt
+            if (attempts > 0) {
+                try {
+                    const freshSnapshot = await snapshotFn();
+                    ctx = {
+                        snapshot: freshSnapshot,
+                        url: freshSnapshot?.url ?? ctx.url,
+                        stepId: ctx.stepId,
+                    };
+                }
+                catch (e) {
+                    lastOutcome = {
+                        passed: false,
+                        reason: `failed to take snapshot: ${e}`,
+                        details: { attempts, error: String(e) },
+                    };
+                    attempts++;
+                    await this.sleep(this._config.poll);
+                    continue;
+                }
+            }
+            // Evaluate predicate
+            const outcome = this._predicate(ctx);
+            if (outcome.passed) {
+                outcome.details.attempts = attempts + 1;
+                return outcome;
+            }
+            lastOutcome = outcome;
+            attempts++;
+            // Wait before next retry
+            if (attempts < this._config.maxRetries) {
+                // Check if we'd exceed timeout with the poll delay
+                if (Date.now() - startTime + this._config.poll < this._config.timeout) {
+                    await this.sleep(this._config.poll);
+                }
+                else {
+                    // No point waiting, we'll timeout anyway
+                    lastOutcome.reason = `timeout after ${Date.now() - startTime}ms: ${lastOutcome.reason}`;
+                    return lastOutcome;
+                }
+            }
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /** Get the configured timeout in milliseconds */
+    get timeout() {
+        return this._config.timeout;
+    }
+    /** Get the configured poll interval in milliseconds */
+    get poll() {
+        return this._config.poll;
+    }
+    /** Get the configured max retries */
+    get maxRetries() {
+        return this._config.maxRetries;
+    }
+}
+exports.EventuallyWrapper = EventuallyWrapper;
+/**
+ * Wrap a predicate with retry logic.
+ *
+ * This is the TypeScript API for .eventually(). Returns a wrapper
+ * that provides an async evaluate() method for use with the runtime.
+ *
+ * @param predicate - Predicate to wrap
+ * @param config - Retry configuration (timeout/poll in milliseconds)
+ * @returns EventuallyWrapper with async evaluate() method
+ *
+ * @example
+ * const wrapper = withEventually(
+ *   expect(E({ role: "button" })).toExist(),
+ *   { timeout: 5000, maxRetries: 10 }
+ * );
+ * const result = await wrapper.evaluate(ctx, runtime.snapshot);
+ */
+function withEventually(predicate, config) {
+    return new EventuallyWrapper(predicate, config);
+}
+//# sourceMappingURL=expect.js.map