@probolabs/playwright 1.5.0-rc.3 → 1.5.0-rc.5

package/dist/index.js

@@ -1427,23 +1427,23 @@ function interactionToProboLib(interaction) {
     if (interaction.action === PlaywrightAction.EXTRACT_VALUE) {
         const extractVarName = getReturnValueParameterName(interaction);
         return `${comment}
-      await test.step("${escapedStepName}", async () => {
-        const ${extractVarName} = await probo.runStep(page, '${escapedPrompt}', null, { stepId: ${interaction.stepId} });
-        param['${extractVarName}'] = ${extractVarName};
-      });`;
+        await test.step("${escapedStepName}", async () => {
+          const ${extractVarName} = await probo.runStep(page, '${escapedPrompt}', null, { stepId: ${interaction.stepId} });
+          param['${extractVarName}'] = ${extractVarName};
+        });`;
     }
     else if (interaction.action === PlaywrightAction.ASSERT_CONTAINS_VALUE ||
         interaction.action === PlaywrightAction.ASSERT_EXACT_VALUE) {
         return `${comment}
-      await test.step("${escapedStepName}", async () => {
-        await probo.runStep(page, '${escapedPrompt}', ${argument}, { stepId: ${interaction.stepId} });
-      });`;
+        await test.step("${escapedStepName}", async () => {
+          await probo.runStep(page, '${escapedPrompt}', ${argument}, { stepId: ${interaction.stepId} });
+        });`;
     }
     else if (interaction.action === PlaywrightAction.VISIT_URL) {
         return `${comment}
-      await test.step("${escapedStepName}", async () => {
-        await probo.runStep(page, '${interaction.nativeDescription}', ${argument}, { stepId: ${interaction.stepId} });
-      });`;
+        await test.step("${escapedStepName}", async () => {
+          await probo.runStep(page, '${interaction.nativeDescription}', ${argument}, { stepId: ${interaction.stepId} });
+        });`;
     }
     else if (interaction.action === PlaywrightAction.ASK_AI) {
         const escapedQuestion = interaction.nativeDescription.replace(/'/g, "\\'");
@@ -1461,9 +1461,9 @@ function interactionToProboLib(interaction) {
     }
     else {
         return `${comment}
-      await test.step("${escapedStepName}", async () => {
-        ${argument ? `await probo.runStep(page, '${escapedPrompt}', ${argument}, { stepId: ${interaction.stepId} });` : `await probo.runStep(page, '${escapedPrompt}', null, { stepId: ${interaction.stepId} });`}
-      });`;
+        await test.step("${escapedStepName}", async () => {
+          ${argument ? `await probo.runStep(page, '${escapedPrompt}', ${argument}, { stepId: ${interaction.stepId} });` : `await probo.runStep(page, '${escapedPrompt}', null, { stepId: ${interaction.stepId} });`}
+        });`;
     }
 }
 function generateExecuteScriptCode(interaction, comment, escapedStepName) {
@@ -1490,17 +1490,79 @@ function generateExecuteScriptCode(interaction, comment, escapedStepName) {
           param['${scriptVarName}'] = ${scriptVarName};
         });`;
 }
+/** Base indentation for steps inside the test body (8 spaces) */
+const STEP_BASE_INDENT = 8;
+/** Base indentation for steps nested inside a sequence step (10 spaces) */
+const SEQUENCE_INNER_INDENT = 10;
+/**
+ * Re-indent a block so its minimum leading whitespace becomes targetSpaces.
+ * Normalizes mixed indentation from interactionToNativeCode (8 spaces) and interactionToProboLib (6 spaces).
+ */
+function indentBlockTo(block, targetSpaces) {
+    const lines = block.split('\n');
+    const nonEmpty = lines.filter((l) => l.trim().length > 0);
+    const minIndent = nonEmpty.length > 0
+        ? Math.min(...nonEmpty.map((l) => { var _a, _b; return ((_b = (_a = l.match(/^\s*/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '').length; }))
+        : 0;
+    const toAdd = Math.max(0, targetSpaces - minIndent);
+    return lines
+        .map((l) => (l.trim() ? ' '.repeat(toAdd) + l : l))
+        .join('\n');
+}
+/**
+ * Generates steps string with sequence-aware test.step wrapping.
+ * When SEQUENCE_START is encountered, collects interactions until SEQUENCE_END
+ * and wraps them in test.step(<sequence name>, async () => { ... }).
+ */
+function generateStepsWithSequences(interactions, _hasAiInteractions) {
+    const result = [];
+    let i = 0;
+    const baseIndent = ' '.repeat(STEP_BASE_INDENT);
+    while (i < interactions.length) {
+        const interaction = interactions[i];
+        if (interaction.action === PlaywrightAction.SEQUENCE_START) {
+            const sequenceName = interaction.nativeName ||
+                interaction.nativeDescription ||
+                'Unnamed sequence';
+            const escapedName = sequenceName
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"');
+            i++;
+            const innerSteps = [];
+            while (i < interactions.length &&
+                interactions[i].action !== PlaywrightAction.SEQUENCE_END) {
+                const code = isAI(interactions[i])
+                    ? interactionToProboLib(interactions[i])
+                    : interactionToNativeCode(interactions[i]);
+                innerSteps.push(code);
+                i++;
+            }
+            if (i < interactions.length)
+                i++; // skip SEQUENCE_END
+            const indented = innerSteps
+                .map((block) => indentBlockTo(block, SEQUENCE_INNER_INDENT))
+                .join('\n');
+            result.push(`${baseIndent}await test.step("${escapedName}", async () => {\n${indented}\n${baseIndent}});`);
+        }
+        else if (interaction.action === PlaywrightAction.SEQUENCE_END) {
+            i++; // orphan END, skip
+        }
+        else {
+            result.push(isAI(interaction)
+                ? interactionToProboLib(interaction)
+                : interactionToNativeCode(interaction));
+            i++;
+        }
+    }
+    return result.join('\n');
+}
 function scriptTemplate(options, settings, viewPort) {
     var _a, _b, _c, _d;
     const areActionsParameterized = options.rows.length > 0;
     const hasAiInteractions = options.interactions.some((interaction) => isAI(interaction));
     const hasScriptInteractions = options.interactions.some((interaction) => interaction.action === PlaywrightAction.EXECUTE_SCRIPT);
     // const uniquelyParameterizedInteractions = uniquifyInteractionParameters(options.interactions);
-    const steps = options.interactions.map((interaction) => {
-        if (isAI(interaction))
-            return interactionToProboLib(interaction);
-        return interactionToNativeCode(interaction);
-    }).join('\n');
+    const steps = generateStepsWithSequences(options.interactions);
     // Get list of all extracted value parameter names to filter them out from the parameter table
     const extractedValueNames = new Set();
     options.interactions.forEach((interaction) => {
@@ -4964,8 +5026,11 @@ const gen = (suffix, blockLen, outputLen)=>createHasher(()=>new Keccak(blockLen,
 }
 
 class ProboPlaywright {
-    constructor({ enableSmartSelectors = false, timeoutConfig = {}, debugLevel = ProboLogLevel.INFO, isCanceled }, page = null) {
+    constructor({ enableSmartSelectors = false, timeoutConfig = {}, debugLevel = ProboLogLevel.INFO, isCanceled }, page = null, context) {
         this.page = null;
+        this.context = null;
+        this.pagesByTabIndex = new Map();
+        this.nextTabIndex = 1;
         this.params = {};
         this.isCanceled = null;
         this.enableSmartSelectors = enableSmartSelectors;
@@ -4975,6 +5040,7 @@ class ProboPlaywright {
         };
         this.isCanceled = isCanceled || null;
         this.highlighter = new Highlighter(enableSmartSelectors, false, debugLevel);
+        this.context = context !== null && context !== void 0 ? context : null;
         this.setPage(page);
         proboLogger.setLogLevel(debugLevel);
     }
@@ -4989,8 +5055,36 @@ class ProboPlaywright {
         if (this.page) {
             this.page.setDefaultNavigationTimeout(this.timeoutConfig.playwrightNavigationTimeout);
             this.page.setDefaultTimeout(this.timeoutConfig.playwrightActionTimeout);
+            this.pagesByTabIndex.set(0, this.page);
         }
     }
+    /**
+     * Sets the BrowserContext for multi-tab replay. Required for opensNewTab support.
+     */
+    setContext(context) {
+        this.context = context;
+    }
+    /**
+     * Resets multi-tab state for a new replay. Clears captured tabs (keeps tab 0) and resets nextTabIndex.
+     * Call at the start of replay before running interactions.
+     */
+    resetMultiTabState() {
+        // Clear captured tabs (indices > 0), keep tab 0
+        for (const idx of this.pagesByTabIndex.keys()) {
+            if (idx > 0) {
+                this.pagesByTabIndex.delete(idx);
+            }
+        }
+        this.nextTabIndex = 1;
+    }
+    /**
+     * Gets the page for the given tab index. Tab 0 = initial page; higher indices = new tabs.
+     */
+    getPageForTabIndex(tabIndex) {
+        var _a;
+        const page = (_a = this.pagesByTabIndex.get(tabIndex)) !== null && _a !== void 0 ? _a : this.page;
+        return page !== null && page !== void 0 ? page : null;
+    }
     /**
      * Sets the parameters object for template literal interpolation
      * Stores a reference to the params object so mutations are automatically reflected
@@ -5017,417 +5111,441 @@ class ProboPlaywright {
     * @throws Error if element is not found or validation fails
     */
     async runStep(params) {
-        let { action, argument = '', iframeSelector = '', elementSelector = '', smartSelector = null, smartIFrameSelector = null, annotation = '', } = params;
-        // 0. Check that page is set
-        if (!this.page) {
-            throw new Error('Page is not set');
-        }
-        // Interpolate argument if it's a string with template literals
-        if (typeof argument === 'string' && argument.includes('${')) {
-            argument = this.interpolate(argument);
-        }
-        else if (Array.isArray(argument)) {
-            // Handle array arguments (e.g., for UPLOAD_FILES or SELECT_DROPDOWN)
-            argument = argument.map((arg) => {
-                if (typeof arg === 'string' && arg.includes('${')) {
-                    return this.interpolate(arg);
-                }
-                return arg;
-            });
-        }
-        //trace message to help with debug    
-        proboLogger.info(`runStep(${JSON.stringify({ ...params, argument })})`);
-        // 1. Check if we need to visit a url
-        if (action === PlaywrightAction.VISIT_URL || action === PlaywrightAction.VISIT_BASE_URL) {
-            try {
-                await this.page.goto(argument, { timeout: this.timeoutConfig.playwrightNavigationTimeout });
-                const navTracker = await NavTracker.getInstance(this.page, {
-                    waitForStabilityQuietTimeout: this.timeoutConfig.waitForStabilityQuietTimeout,
-                    waitForStabilityInitialDelay: this.timeoutConfig.waitForStabilityInitialDelay,
-                    waitForStabilityGlobalTimeout: this.timeoutConfig.waitForStabilityGlobalTimeout,
-                    waitForStabilityVerbose: this.timeoutConfig.waitForStabilityVerbose
-                });
-                await navTracker.waitForNavigationToStabilize();
-            }
-            catch (e) {
-                throw new Error(`Failed to navigate to ${argument}`);
-            }
-            return;
-        }
-        // 2. Check if we need to assert the url
-        if (action === PlaywrightAction.ASSERT_URL) {
-            // wait for page to stabilize
-            const navTracker = await NavTracker.getInstance(this.page, { waitForStabilityQuietTimeout: this.timeoutConfig.playwrightNavigationTimeout });
-            await navTracker.waitForNavigationToStabilize();
-            const currentUrl = await this.page.url();
-            if (currentUrl !== argument) {
-                throw new Error(`Assertion failed: Expected URL "${argument}" but got "${currentUrl}".`);
+        var _a;
+        let { action, argument = '', iframeSelector = '', elementSelector = '', smartSelector = null, smartIFrameSelector = null, annotation = '', tabIndex = 0, opensNewTab = false, } = params;
+        // 0. Resolve page for this step (multi-tab: tabIndex selects which page to use)
+        const stepPage = (_a = this.getPageForTabIndex(tabIndex)) !== null && _a !== void 0 ? _a : this.page;
+        if (!stepPage) {
+            throw new Error(`Page is not set for tabIndex ${tabIndex}`);
+        }
+        const originalPage = this.page;
+        this.page = stepPage;
+        // Bring the active tab to front so the user sees the page being interacted with
+        await stepPage.bringToFront();
+        try {
+            // Interpolate argument if it's a string with template literals
+            if (typeof argument === 'string' && argument.includes('${')) {
+                argument = this.interpolate(argument);
             }
-            return;
-        }
-        // 3. Check if we need to type keys
-        if (action === PlaywrightAction.TYPE_KEYS) {
-            await this.robustTypeKeys(argument);
-            return;
-        }
-        // Capture base screenshot before element interaction (if screenshot function is provided)
-        // Only capture base screenshot during apply-ai, skip during replay
-        let baseScreenshotUrl = null;
-        if (params.takeScreenshot && params.isApplyAIContext) {
-            try {
-                proboLogger.debug('Capturing base screenshot before element interaction');
-                baseScreenshotUrl = await params.takeScreenshot(this.page, 'base');
-                proboLogger.debug(`Base screenshot uploaded: ${baseScreenshotUrl}`);
+            else if (Array.isArray(argument)) {
+                // Handle array arguments (e.g., for UPLOAD_FILES or SELECT_DROPDOWN)
+                argument = argument.map((arg) => {
+                    if (typeof arg === 'string' && arg.includes('${')) {
+                        return this.interpolate(arg);
+                    }
+                    return arg;
+                });
             }
-            catch (baseError) {
-                proboLogger.warn(`Failed to capture base screenshot: ${baseError}`);
-                // Continue even if base screenshot fails
+            //trace message to help with debug    
+            proboLogger.info(`runStep(${JSON.stringify({ ...params, argument })})`);
+            // 1. Check if we need to visit a url
+            if (action === PlaywrightAction.VISIT_URL || action === PlaywrightAction.VISIT_BASE_URL) {
+                try {
+                    await this.page.goto(argument, { timeout: this.timeoutConfig.playwrightNavigationTimeout });
+                    const navTracker = await NavTracker.getInstance(this.page, {
+                        waitForStabilityQuietTimeout: this.timeoutConfig.waitForStabilityQuietTimeout,
+                        waitForStabilityInitialDelay: this.timeoutConfig.waitForStabilityInitialDelay,
+                        waitForStabilityGlobalTimeout: this.timeoutConfig.waitForStabilityGlobalTimeout,
+                        waitForStabilityVerbose: this.timeoutConfig.waitForStabilityVerbose
+                    });
+                    await navTracker.waitForNavigationToStabilize();
+                }
+                catch (e) {
+                    throw new Error(`Failed to navigate to ${argument}`);
+                }
+                return;
             }
-        }
-        let locator;
-        if (iframeSelector && iframeSelector.length > 0) {
-            const frameLocator = await this.getLocator(iframeSelector, smartIFrameSelector, true);
-            locator = await this.getLocator(elementSelector, smartSelector, false, frameLocator);
-        }
-        else {
-            locator = await this.getLocator(elementSelector, smartSelector);
-        }
-        // Fail fast: immediately validate that the element exists for non-wait actions
-        // Use Promise.race() for all actions to enable cancellation without sacrificing precision
-        const locator_timeout = (action === PlaywrightAction.WAIT_FOR) ? params.timeout || 10000 : this.timeoutConfig.playwrightLocatorTimeout;
-        // Create a cancellation promise that checks for cancellation every 100ms
-        // This allows precise waits while still enabling cancellation for all actions
-        const cancellationCheckInterval = 100; // Check for cancellation every 100ms
-        // Create a promise that rejects when cancellation is detected
-        const cancellationPromise = new Promise((_, reject) => {
-            const checkCancellation = () => {
-                if (this.isCanceled && this.isCanceled()) {
-                    reject(new Error('Replay execution was cancelled'));
-                    return;
+            // 2. Check if we need to assert the url
+            if (action === PlaywrightAction.ASSERT_URL) {
+                // wait for page to stabilize
+                const navTracker = await NavTracker.getInstance(this.page, { waitForStabilityQuietTimeout: this.timeoutConfig.playwrightNavigationTimeout });
+                await navTracker.waitForNavigationToStabilize();
+                const currentUrl = await this.page.url();
+                if (currentUrl !== argument) {
+                    throw new Error(`Assertion failed: Expected URL "${argument}" but got "${currentUrl}".`);
                 }
-                // Continue checking until the wait completes or times out
-                setTimeout(checkCancellation, cancellationCheckInterval);
-            };
-            checkCancellation();
-        });
-        // Helper function to wait for locator with cancellation support
-        const waitForLocatorWithCancellation = async (targetLocator, timeout) => {
-            return Promise.race([
-                targetLocator.waitFor({ state: 'attached', timeout }),
-                cancellationPromise
-            ]);
-        };
-        try {
-            // Race between the actual wait and cancellation check for all actions
-            // This allows precise waits while still enabling cancellation
-            await waitForLocatorWithCancellation(locator, locator_timeout);
-        }
-        catch (e) {
-            // If it's a cancellation error, re-throw it
-            if (e instanceof Error && e.message === 'Replay execution was cancelled') {
-                throw e;
+                return;
+            }
+            // 3. Check if we need to type keys
+            if (action === PlaywrightAction.TYPE_KEYS) {
+                await this.robustTypeKeys(argument);
+                return;
             }
-            // Timeout reached, try fallback if smart selectors are enabled
-            if (this.enableSmartSelectors) {
+            // Capture base screenshot before element interaction (if screenshot function is provided)
+            // Only capture base screenshot during apply-ai, skip during replay
+            let baseScreenshotUrl = null;
+            if (params.takeScreenshot && params.isApplyAIContext) {
                 try {
-                    proboLogger.warn(`Element not found with smart selector: ${JSON.stringify(smartSelector)} ${smartIFrameSelector ? `with iframe smart selector: ${JSON.stringify(smartIFrameSelector)}` : ''}. Falling back to CSS selector`, e);
-                    if (iframeSelector && iframeSelector.length > 0) {
-                        const frameLocator = await this.getLocatorOrFrame(iframeSelector, true);
-                        locator = await this.getLocatorOrFrame(elementSelector, false, frameLocator);
-                    }
-                    else {
-                        locator = await this.getLocatorOrFrame(elementSelector, false);
-                    }
-                    // Race the fallback wait with cancellation as well
-                    await waitForLocatorWithCancellation(locator, 200);
+                    proboLogger.debug('Capturing base screenshot before element interaction');
+                    baseScreenshotUrl = await params.takeScreenshot(this.page, 'base');
+                    proboLogger.debug(`Base screenshot uploaded: ${baseScreenshotUrl}`);
                 }
-                catch (e) {
-                    // If it's a cancellation error, re-throw it
-                    if (e instanceof Error && e.message === 'Replay execution was cancelled') {
-                        throw e;
-                    }
-                    throw new Error(`Element not found with CSS selector: ${elementSelector} ${iframeSelector ? `in iframe: ${iframeSelector}` : ''} after ${locator_timeout}ms`);
+                catch (baseError) {
+                    proboLogger.warn(`Failed to capture base screenshot: ${baseError}`);
+                    // Continue even if base screenshot fails
                 }
             }
-            else {
-                throw new Error(`Element not found with CSS selector: ${elementSelector} ${iframeSelector ? `in iframe: ${iframeSelector}` : ''} after ${locator_timeout}ms`);
+            // 4. Get the locator (iframe or not)
+            const startTime = Date.now();
+            let locator;
+            if (iframeSelector && iframeSelector.length > 0) {
+                const frameLocator = await this.getLocator(iframeSelector, smartIFrameSelector, true);
+                locator = await this.getLocator(elementSelector, smartSelector, false, frameLocator);
             }
-        }
-        if (action === PlaywrightAction.HOVER) {
-            const visibleLocator = await findClosestVisibleElement(locator);
-            if (visibleLocator) {
-                locator = visibleLocator;
+            else {
+                locator = await this.getLocator(elementSelector, smartSelector);
             }
-        }
-        // 5. Capture screenshots if screenshot function is provided
-        const screenshotUrls = {
-            base_screenshot_url: baseScreenshotUrl
-        };
-        if (params.takeScreenshot) {
+            // Fail fast: immediately validate that the element exists for non-wait actions
+            // Use Promise.race() for all actions to enable cancellation without sacrificing precision
+            const locator_timeout = (action === PlaywrightAction.WAIT_FOR) ? params.timeout || 10000 : this.timeoutConfig.playwrightLocatorTimeout;
+            // Create a cancellation promise that checks for cancellation every 100ms
+            // This allows precise waits while still enabling cancellation for all actions
+            const cancellationCheckInterval = 100; // Check for cancellation every 100ms
+            // Create a promise that rejects when cancellation is detected
+            const cancellationPromise = new Promise((_, reject) => {
+                const checkCancellation = () => {
+                    if (this.isCanceled && this.isCanceled()) {
+                        reject(new Error('Replay execution was cancelled'));
+                        return;
+                    }
+                    // Continue checking until the wait completes or times out
+                    setTimeout(checkCancellation, cancellationCheckInterval);
+                };
+                checkCancellation();
+            });
+            // Helper function to wait for locator with cancellation support
+            const waitForLocatorWithCancellation = async (targetLocator, timeout) => {
+                return Promise.race([
+                    targetLocator.waitFor({ state: 'attached', timeout }),
+                    cancellationPromise
+                ]);
+            };
             try {
-                // Candidate elements screenshot: find and highlight candidates based on action type
-                // Only capture candidate screenshot during apply-ai, skip during replay
-                if (params.isApplyAIContext) {
+                // Race between the actual wait and cancellation check for all actions
+                // This allows precise waits while still enabling cancellation
+                await waitForLocatorWithCancellation(locator, locator_timeout);
+            }
+            catch (e) {
+                // If it's a cancellation error, re-throw it
+                if (e instanceof Error && e.message === 'Replay execution was cancelled') {
+                    throw e;
+                }
+                // Timeout reached, try fallback if smart selectors are enabled
+                if (this.enableSmartSelectors) {
                     try {
-                        const elementTags = resolveElementTag(action);
-                        proboLogger.debug(`Finding candidate elements for action ${action} with tags: ${elementTags}`);
-                        await this.highlighter.findAndCacheCandidateElements(this.page, elementTags);
-                        await this.highlighter.highlightCachedElements(this.page, 'candidates');
-                        // Wait for highlight timeout to ensure highlights are visible
-                        // if (this.timeoutConfig.highlightTimeout > 0) {
-                        //   await this.page.waitForTimeout(this.timeoutConfig.highlightTimeout);
-                        // }
-                        screenshotUrls.candidates_screenshot_url = await params.takeScreenshot(this.page, 'candidates');
-                        proboLogger.debug(`Candidates screenshot uploaded: ${screenshotUrls.candidates_screenshot_url}`);
-                        // Unhighlight candidates
-                        await this.highlighter.unhighlightCached(this.page);
+                        proboLogger.warn(`Element not found with smart selector: ${JSON.stringify(smartSelector)} ${smartIFrameSelector ? `with iframe smart selector: ${JSON.stringify(smartIFrameSelector)}` : ''}. Falling back to CSS selector`, e);
+                        if (iframeSelector && iframeSelector.length > 0) {
+                            const frameLocator = await this.getLocatorOrFrame(iframeSelector, true);
+                            locator = await this.getLocatorOrFrame(elementSelector, false, frameLocator);
+                        }
+                        else {
+                            locator = await this.getLocatorOrFrame(elementSelector, false);
+                        }
+                        // Race the fallback wait with cancellation as well
+                        await waitForLocatorWithCancellation(locator, 200);
                     }
-                    catch (candidateError) {
-                        proboLogger.warn(`Failed to capture candidates screenshot: ${candidateError}`);
-                        // Continue even if candidate screenshot fails
+                    catch (e) {
+                        // If it's a cancellation error, re-throw it
+                        if (e instanceof Error && e.message === 'Replay execution was cancelled') {
+                            throw e;
+                        }
+                        throw new Error(`Element not found with CSS selector: ${elementSelector} ${iframeSelector ? `in iframe: ${iframeSelector}` : ''} after ${locator_timeout}ms`);
                     }
                 }
-                // Actual element screenshot: highlight the actual element
-                // Always capture actual screenshot for both apply-ai and replay
+                else {
+                    throw new Error(`Element not found with CSS selector: ${elementSelector} ${iframeSelector ? `in iframe: ${iframeSelector}` : ''} after ${locator_timeout}ms`);
+                }
+            }
+            if (action === PlaywrightAction.HOVER) {
+                const visibleLocator = await findClosestVisibleElement(locator);
+                if (visibleLocator) {
+                    locator = visibleLocator;
+                }
+            }
+            // 5. Capture screenshots if screenshot function is provided
+            const screenshotUrls = {
+                base_screenshot_url: baseScreenshotUrl
+            };
+            if (params.takeScreenshot) {
                 try {
-                    await this.highlight(locator, annotation);
-                    // Wait for highlight timeout to ensure highlights are visible
-                    if (this.timeoutConfig.highlightTimeout > 0) {
-                        await this.page.waitForTimeout(this.timeoutConfig.highlightTimeout);
+                    // Candidate elements screenshot: find and highlight candidates based on action type
+                    // Only capture candidate screenshot during apply-ai, skip during replay
+                    if (params.isApplyAIContext) {
+                        try {
+                            const elementTags = resolveElementTag(action);
+                            proboLogger.debug(`Finding candidate elements for action ${action} with tags: ${elementTags}`);
+                            await this.highlighter.findAndCacheCandidateElements(this.page, elementTags);
+                            await this.highlighter.highlightCachedElements(this.page, 'candidates');
+                            // Wait for highlight timeout to ensure highlights are visible
+                            // if (this.timeoutConfig.highlightTimeout > 0) {
+                            //   await this.page.waitForTimeout(this.timeoutConfig.highlightTimeout);
+                            // }
+                            screenshotUrls.candidates_screenshot_url = await params.takeScreenshot(this.page, 'candidates');
+                            proboLogger.debug(`Candidates screenshot uploaded: ${screenshotUrls.candidates_screenshot_url}`);
+                            // Unhighlight candidates
+                            await this.highlighter.unhighlightCached(this.page);
+                        }
+                        catch (candidateError) {
+                            proboLogger.warn(`Failed to capture candidates screenshot: ${candidateError}`);
+                            // Continue even if candidate screenshot fails
+                        }
                     }
-                    screenshotUrls.actual_interaction_screenshot_url = await params.takeScreenshot(this.page, 'actual');
-                    proboLogger.debug(`Actual element screenshot uploaded: ${screenshotUrls.actual_interaction_screenshot_url}`);
-                    // Unhighlight before performing action
-                    await this.unhighlight(locator);
-                }
-                catch (actualError) {
-                    proboLogger.warn(`Failed to capture actual element screenshot: ${actualError}`);
-                    // Try to unhighlight even if screenshot failed
+                    // Actual element screenshot: highlight the actual element
+                    // Always capture actual screenshot for both apply-ai and replay
                     try {
+                        await this.highlight(locator, annotation);
+                        // Wait for highlight timeout to ensure highlights are visible
+                        if (this.timeoutConfig.highlightTimeout > 0) {
+                            await this.page.waitForTimeout(this.timeoutConfig.highlightTimeout);
+                        }
+                        screenshotUrls.actual_interaction_screenshot_url = await params.takeScreenshot(this.page, 'actual');
+                        proboLogger.debug(`Actual element screenshot uploaded: ${screenshotUrls.actual_interaction_screenshot_url}`);
+                        // Unhighlight before performing action
                         await this.unhighlight(locator);
                     }
-                    catch (unhighlightError) {
-                        proboLogger.warn(`Failed to unhighlight: ${unhighlightError}`);
+                    catch (actualError) {
+                        proboLogger.warn(`Failed to capture actual element screenshot: ${actualError}`);
+                        // Try to unhighlight even if screenshot failed
+                        try {
+                            await this.unhighlight(locator);
+                        }
+                        catch (unhighlightError) {
+                            proboLogger.warn(`Failed to unhighlight: ${unhighlightError}`);
+                        }
+                    }
+                    // Call the callback with screenshot URLs
+                    if (params.onScreenshots) {
+                        params.onScreenshots(screenshotUrls);
                     }
                 }
-                // Call the callback with screenshot URLs
-                if (params.onScreenshots) {
-                    params.onScreenshots(screenshotUrls);
+                catch (screenshotError) {
+                    proboLogger.warn(`Screenshot capture failed: ${screenshotError}`);
+                    // Continue with action even if screenshots fail
                 }
             }
-            catch (screenshotError) {
-                proboLogger.warn(`Screenshot capture failed: ${screenshotError}`);
-                // Continue with action even if screenshots fail
-            }
-        }
-        else {
-            // 5. Highlight, wait, unhighlight if highlightTimeout > 0 (original behavior when no screenshots)
-            if (this.timeoutConfig.highlightTimeout > 0) {
-                await this.highlight(locator, annotation);
-                await this.page.waitForTimeout(this.timeoutConfig.highlightTimeout);
-                await this.unhighlight(locator);
+            else {
+                // 5. Highlight, wait, unhighlight if highlightTimeout > 0 (original behavior when no screenshots)
+                if (this.timeoutConfig.highlightTimeout > 0) {
+                    await this.highlight(locator, annotation);
+                    await this.page.waitForTimeout(this.timeoutConfig.highlightTimeout);
+                    await this.unhighlight(locator);
+                }
             }
-        }
-        // 6. Action logic
-        switch (action) {
-            case PlaywrightAction.CLICK:
-            case PlaywrightAction.CHECK_CHECKBOX:
-            case PlaywrightAction.SELECT_RADIO:
-                await this.robustMouseAction(locator, 'click');
-                break;
-            case PlaywrightAction.FILL_IN:
-                await this.robustFill(locator, argument);
-                break;
-            case PlaywrightAction.SELECT_DROPDOWN:
-                await locator.selectOption(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                break;
-            case PlaywrightAction.SET_SLIDER:
-                await this.setSliderValue(locator, argument);
-                break;
-            case PlaywrightAction.WAIT_FOR_OTP:
-                {
-                    const waitForOtpArgs = params;
-                    const otpInbox = typeof argument === 'string' && argument.trim() ? argument.trim() : undefined;
-                    const otpTimeout = waitForOtpArgs === null || waitForOtpArgs === void 0 ? void 0 : waitForOtpArgs.timeout;
-                    const otpCheckInterval = waitForOtpArgs === null || waitForOtpArgs === void 0 ? void 0 : waitForOtpArgs.checkInterval;
-                    const otpLookback = waitForOtpArgs === null || waitForOtpArgs === void 0 ? void 0 : waitForOtpArgs.checkRecentMessagesSinceMs;
-                    const otp = await OTP.waitForOTP({
-                        inbox: otpInbox,
-                        timeout: otpTimeout,
-                        checkInterval: otpCheckInterval,
-                        checkRecentMessagesSinceMs: otpLookback !== null && otpLookback !== void 0 ? otpLookback : 600000,
-                    });
-                    if (otp) {
-                        proboLogger.log(`✅ OTP found: ${otp}`);
-                        await locator.fill(otp, { timeout: this.timeoutConfig.playwrightActionTimeout });
+            // 6. Action logic
+            switch (action) {
+                case PlaywrightAction.CLICK:
+                case PlaywrightAction.CHECK_CHECKBOX:
+                case PlaywrightAction.SELECT_RADIO:
+                    if (opensNewTab && this.context) {
+                        const [newPage] = await Promise.all([
+                            this.context.waitForEvent('page'),
+                            this.robustMouseAction(locator, 'click')
+                        ]);
+                        const newTabIndex = this.nextTabIndex++;
+                        this.pagesByTabIndex.set(newTabIndex, newPage);
+                        proboLogger.info(`Multi-tab: captured new page for tabIndex ${newTabIndex}`);
                     }
                     else {
-                        proboLogger.log(`❌ OTP not found`);
+                        await this.robustMouseAction(locator, 'click');
                     }
-                }
-                break;
-            case PlaywrightAction.GEN_TOTP:
-                // Use secret from argument and auxiliary config (digits/algorithm) from totpConfig
-                // If totpConfig is not provided, use defaults (digits: 6, algorithm: 'SHA1')
-                const totpAux = params.totpConfig;
-                const secretArg = params.argument;
-                if (secretArg) {
-                    try {
-                        // Use provided config or defaults
-                        const digits = (totpAux === null || totpAux === void 0 ? void 0 : totpAux.digits) || 6;
-                        const algorithm = (totpAux === null || totpAux === void 0 ? void 0 : totpAux.algorithm) || 'SHA1';
-                        const totpCode = this.generateOTP(secretArg, digits, algorithm);
-                        proboLogger.log(`✅ TOTP generated (digits: ${digits}, algorithm: ${algorithm})`);
-                        await locator.fill(totpCode, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                    }
-                    catch (error) {
-                        proboLogger.error(`❌ TOTP generation failed: ${error}`);
-                        throw new Error(`TOTP generation failed: ${error}`);
-                    }
-                }
-                else {
-                    proboLogger.log(`❌ Missing TOTP argument`);
-                    throw new Error(`Missing TOTP argument`);
-                }
-                break;
-            case PlaywrightAction.ASSERT_CONTAINS_VALUE:
-                const containerText = await this.getTextValue(locator);
-                if (!matchRegex(containerText, argument)) {
-                    throw new Error(`Validation failed. Expected text "${containerText}" to match "${argument}".`);
-                }
-                break;
-            case PlaywrightAction.ASSERT_EXACT_VALUE:
-                const actualText = await this.getTextValue(locator);
-                if (actualText !== argument) {
-                    throw new Error(`Validation failed. Expected text "${argument}", but got "${actualText}".`);
-                }
-                break;
-            case PlaywrightAction.HOVER:
-                if (locator) {
-                    await this.robustMouseAction(locator, 'hover');
-                }
-                else {
-                    throw new Error('not executing HOVER because no visible ancestor found');
-                }
-                break;
-            case PlaywrightAction.SCROLL_TO_ELEMENT:
-                //  Restore exact scroll positions from recording
-                const scrollData = JSON.parse(argument);
-                const desiredScrollTop = scrollData.scrollTop;
-                const desiredScrollLeft = scrollData.scrollLeft;
-                const maxAttempts = 100;
-                try {
-                    proboLogger.log('🔄 Restoring scroll position for container:', locator, 'scrollTop:', desiredScrollTop, 'scrollLeft:', desiredScrollLeft);
-                    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                        // Perform scroll
-                        await locator.evaluate((el, scrollData) => {
-                            el.scrollTo({ left: scrollData.scrollLeft, top: scrollData.scrollTop, behavior: 'smooth' });
-                        }, { scrollTop: desiredScrollTop, scrollLeft: desiredScrollLeft }, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                        // Wait for scroll to complete
-                        await this.page.waitForTimeout(50);
-                        // Get actual scroll positions
-                        const actualScroll = await locator.evaluate((el) => {
-                            return { scrollTop: el.scrollTop, scrollLeft: el.scrollLeft };
-                        }, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                        // Compare actual vs desired
-                        const scrollTopMatch = Math.abs(actualScroll.scrollTop - desiredScrollTop) < 1;
-                        const scrollLeftMatch = Math.abs(actualScroll.scrollLeft - desiredScrollLeft) < 1;
-                        if (scrollTopMatch && scrollLeftMatch) {
-                            proboLogger.log(`🔄 Scroll position restored successfully on attempt ${attempt}`);
-                            break;
-                        }
-                        if (attempt < maxAttempts) {
-                            proboLogger.log(`🔄 Scroll position mismatch on attempt ${attempt}. Desired: (${desiredScrollTop}, ${desiredScrollLeft}), Actual: (${actualScroll.scrollTop}, ${actualScroll.scrollLeft}). Retrying...`);
+                    break;
+                case PlaywrightAction.FILL_IN:
+                    await this.robustFill(locator, argument);
+                    break;
+                case PlaywrightAction.SELECT_DROPDOWN:
+                    await locator.selectOption(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                    break;
+                case PlaywrightAction.SET_SLIDER:
+                    await this.setSliderValue(locator, argument);
+                    break;
+                case PlaywrightAction.WAIT_FOR_OTP:
+                    {
+                        const waitForOtpArgs = params;
+                        const otpInbox = typeof argument === 'string' && argument.trim() ? argument.trim() : undefined;
+                        const otpTimeout = waitForOtpArgs === null || waitForOtpArgs === void 0 ? void 0 : waitForOtpArgs.timeout;
+                        const otpCheckInterval = waitForOtpArgs === null || waitForOtpArgs === void 0 ? void 0 : waitForOtpArgs.checkInterval;
+                        const otpLookback = waitForOtpArgs === null || waitForOtpArgs === void 0 ? void 0 : waitForOtpArgs.checkRecentMessagesSinceMs;
+                        const otp = await OTP.waitForOTP({
+                            inbox: otpInbox,
+                            timeout: otpTimeout,
+                            checkInterval: otpCheckInterval,
+                            checkRecentMessagesSinceMs: otpLookback !== null && otpLookback !== void 0 ? otpLookback : 600000,
+                        });
+                        if (otp) {
+                            proboLogger.log(`✅ OTP found: ${otp}`);
+                            await locator.fill(otp, { timeout: this.timeoutConfig.playwrightActionTimeout });
                         }
                         else {
-                            proboLogger.warn(`🔄 Scroll position mismatch after ${maxAttempts} attempts. Desired: (${desiredScrollTop}, ${desiredScrollLeft}), Final: (${actualScroll.scrollTop}, ${actualScroll.scrollLeft})`);
+                            proboLogger.log(`❌ OTP not found`);
                         }
                     }
-                }
-                catch (e) {
-                    proboLogger.error('🔄 Failed to restore scroll position for container:', locator, 'scrollTop:', desiredScrollTop, 'scrollLeft:', desiredScrollLeft, 'error:', e);
-                }
-                break;
-            case PlaywrightAction.UPLOAD_FILES:
-                await locator.setInputFiles(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                break;
-            case PlaywrightAction.EXTRACT_VALUE:
-                let extractedText = await this.getTextValue(locator);
-                return extractedText;
-            case PlaywrightAction.WAIT_FOR:
-                const expectedText = argument;
-                // Use smaller polling interval for better precision (can detect changes sooner)
-                const pollingInterval = params.pollingInterval || 100; // Default 100ms for better precision
-                const timeout = params.timeout || 10000; // Default 10 seconds
-                // Create a cancellation promise that rejects when cancellation is detected
-                // This allows us to cancel the text polling loop at any time
-                const createCancellationPromise = () => {
-                    const cancellationCheckInterval = 50; // Check for cancellation every 50ms
-                    return new Promise((_, reject) => {
-                        const checkCancellation = () => {
-                            if (this.isCanceled && this.isCanceled()) {
-                                reject(new Error('Replay execution was cancelled'));
-                                return;
-                            }
-                            setTimeout(checkCancellation, cancellationCheckInterval);
-                        };
-                        checkCancellation();
-                    });
-                };
-                let textMatches = false;
-                let currentText = '';
-                const waitStartTime = Date.now();
-                const cancellationPromise = createCancellationPromise();
-                while (!textMatches && (Date.now() - waitStartTime) < timeout) {
+                    break;
+                case PlaywrightAction.GEN_TOTP:
+                    // Use secret from argument (interpolated above) and auxiliary config (digits/algorithm) from totpConfig
+                    // If totpConfig is not provided, use defaults (digits: 6, algorithm: 'SHA1')
+                    const totpAux = params.totpConfig;
+                    const secretArg = argument;
+                    if (secretArg) {
+                        try {
+                            // Use provided config or defaults
+                            const digits = (totpAux === null || totpAux === void 0 ? void 0 : totpAux.digits) || 6;
+                            const algorithm = (totpAux === null || totpAux === void 0 ? void 0 : totpAux.algorithm) || 'SHA1';
+                            const totpCode = this.generateOTP(secretArg, digits, algorithm);
+                            proboLogger.log(`✅ TOTP generated (digits: ${digits}, algorithm: ${algorithm})`);
+                            await locator.fill(totpCode, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                        }
+                        catch (error) {
+                            proboLogger.error(`❌ TOTP generation failed: ${error}`);
+                            throw new Error(`TOTP generation failed: ${error}`);
+                        }
+                    }
+                    else {
+                        proboLogger.log(`❌ Missing TOTP argument`);
+                        throw new Error(`Missing TOTP argument`);
+                    }
+                    break;
+                case PlaywrightAction.ASSERT_CONTAINS_VALUE:
+                    const containerText = await this.getTextValue(locator);
+                    if (!matchRegex(containerText, argument)) {
+                        throw new Error(`Validation failed. Expected text "${containerText}" to match "${argument}".`);
+                    }
+                    break;
+                case PlaywrightAction.ASSERT_EXACT_VALUE:
+                    const actualText = await this.getTextValue(locator);
+                    if (actualText !== argument) {
+                        throw new Error(`Validation failed. Expected text "${argument}", but got "${actualText}".`);
+                    }
+                    break;
+                case PlaywrightAction.HOVER:
+                    if (locator) {
+                        await this.robustMouseAction(locator, 'hover');
+                    }
+                    else {
+                        throw new Error('not executing HOVER because no visible ancestor found');
+                    }
+                    break;
+                case PlaywrightAction.SCROLL_TO_ELEMENT:
+                    //  Restore exact scroll positions from recording
+                    const scrollData = JSON.parse(argument);
+                    const desiredScrollTop = scrollData.scrollTop;
+                    const desiredScrollLeft = scrollData.scrollLeft;
+                    const maxAttempts = 100;
                     try {
-                        // Check if element is visible first
-                        const isVisible = await locator.isVisible();
-                        if (isVisible) {
-                            // Get the current text content only if element is visible
-                            currentText = await this.getTextValue(locator);
-                            // Check if the text matches (using the same logic as ASSERT_CONTAINS_VALUE)
-                            if (matchRegex(currentText, expectedText)) {
-                                textMatches = true;
-                                proboLogger.log(`✅ Wait for text completed successfully. Found: "${currentText}"`);
+                        proboLogger.log('🔄 Restoring scroll position for container:', locator, 'scrollTop:', desiredScrollTop, 'scrollLeft:', desiredScrollLeft);
+                        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                            // Perform scroll
+                            await locator.evaluate((el, scrollData) => {
+                                el.scrollTo({ left: scrollData.scrollLeft, top: scrollData.scrollTop, behavior: 'smooth' });
+                            }, { scrollTop: desiredScrollTop, scrollLeft: desiredScrollLeft }, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                            // Wait for scroll to complete
+                            await this.page.waitForTimeout(50);
+                            // Get actual scroll positions
+                            const actualScroll = await locator.evaluate((el) => {
+                                return { scrollTop: el.scrollTop, scrollLeft: el.scrollLeft };
+                            }, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                            // Compare actual vs desired
+                            const scrollTopMatch = Math.abs(actualScroll.scrollTop - desiredScrollTop) < 1;
+                            const scrollLeftMatch = Math.abs(actualScroll.scrollLeft - desiredScrollLeft) < 1;
+                            if (scrollTopMatch && scrollLeftMatch) {
+                                proboLogger.log(`🔄 Scroll position restored successfully on attempt ${attempt}`);
                                 break;
                             }
-                        }
-                        // Text doesn't match yet or element not visible, wait for the polling interval
-                        // Use Promise.race() to allow cancellation during the wait (consistent with element attachment logic)
-                        if ((Date.now() - waitStartTime) < timeout) {
-                            const remainingTime = timeout - (Date.now() - waitStartTime);
-                            const actualPollInterval = Math.min(pollingInterval, remainingTime);
-                            if (actualPollInterval > 0) {
-                                if (!this.page) {
-                                    throw new Error('Page is not set');
-                                }
-                                // Race between the timeout and cancellation check
-                                await Promise.race([
-                                    this.page.waitForTimeout(actualPollInterval),
-                                    cancellationPromise
-                                ]);
+                            if (attempt < maxAttempts) {
+                                proboLogger.log(`🔄 Scroll position mismatch on attempt ${attempt}. Desired: (${desiredScrollTop}, ${desiredScrollLeft}), Actual: (${actualScroll.scrollTop}, ${actualScroll.scrollLeft}). Retrying...`);
+                            }
+                            else {
+                                proboLogger.warn(`🔄 Scroll position mismatch after ${maxAttempts} attempts. Desired: (${desiredScrollTop}, ${desiredScrollLeft}), Final: (${actualScroll.scrollTop}, ${actualScroll.scrollLeft})`);
                             }
                         }
                     }
                     catch (e) {
-                        // If it's a cancellation error, re-throw it
-                        if (e instanceof Error && e.message === 'Replay execution was cancelled') {
-                            throw e;
+                        proboLogger.error('🔄 Failed to restore scroll position for container:', locator, 'scrollTop:', desiredScrollTop, 'scrollLeft:', desiredScrollLeft, 'error:', e);
+                    }
+                    break;
+                case PlaywrightAction.UPLOAD_FILES:
+                    await locator.setInputFiles(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                    break;
+                case PlaywrightAction.EXTRACT_VALUE:
+                    let extractedText = await this.getTextValue(locator);
+                    return extractedText;
+                case PlaywrightAction.WAIT_FOR:
+                    const expectedText = argument;
+                    // Use smaller polling interval for better precision (can detect changes sooner)
+                    const pollingInterval = params.pollingInterval || 100; // Default 100ms for better precision
+                    const timeout = params.timeout || 10000; // Default 10 seconds
+                    // Create a cancellation promise that rejects when cancellation is detected
+                    // This allows us to cancel the text polling loop at any time
+                    const createCancellationPromise = () => {
+                        const cancellationCheckInterval = 50; // Check for cancellation every 50ms
+                        return new Promise((_, reject) => {
+                            const checkCancellation = () => {
+                                if (this.isCanceled && this.isCanceled()) {
+                                    reject(new Error('Replay execution was cancelled'));
+                                    return;
+                                }
+                                setTimeout(checkCancellation, cancellationCheckInterval);
+                            };
+                            checkCancellation();
+                        });
+                    };
+                    let textMatches = false;
+                    let currentText = '';
+                    const waitStartTime = Date.now();
+                    const cancellationPromise = createCancellationPromise();
+                    while (!textMatches && (Date.now() - waitStartTime) < timeout) {
+                        try {
+                            // Check if element is visible first
+                            const isVisible = await locator.isVisible();
+                            if (isVisible) {
+                                // Get the current text content only if element is visible
+                                currentText = await this.getTextValue(locator);
+                                // Check if the text matches (using the same logic as ASSERT_CONTAINS_VALUE)
+                                if (matchRegex(currentText, expectedText)) {
+                                    textMatches = true;
+                                    proboLogger.log(`✅ Wait for text completed successfully. Found: "${currentText}"`);
+                                    break;
+                                }
+                            }
+                            // Text doesn't match yet or element not visible, wait for the polling interval
+                            // Use Promise.race() to allow cancellation during the wait (consistent with element attachment logic)
+                            if ((Date.now() - waitStartTime) < timeout) {
+                                const remainingTime = timeout - (Date.now() - waitStartTime);
+                                const actualPollInterval = Math.min(pollingInterval, remainingTime);
+                                if (actualPollInterval > 0) {
+                                    if (!this.page) {
+                                        throw new Error('Page is not set');
+                                    }
+                                    // Race between the timeout and cancellation check
+                                    await Promise.race([
+                                        this.page.waitForTimeout(actualPollInterval),
+                                        cancellationPromise
+                                    ]);
+                                }
+                            }
+                        }
+                        catch (e) {
+                            // If it's a cancellation error, re-throw it
+                            if (e instanceof Error && e.message === 'Replay execution was cancelled') {
+                                throw e;
+                            }
+                            throw new Error(`Wait for text failed while trying to extract text from selector: ${elementSelector}${iframeSelector ? ` in iframe: ${iframeSelector}` : ''}`);
                         }
-                        throw new Error(`Wait for text failed while trying to extract text from selector: ${elementSelector}${iframeSelector ? ` in iframe: ${iframeSelector}` : ''}`);
                     }
-                }
-                // Final cancellation check
-                if (this.isCanceled && this.isCanceled()) {
-                    throw new Error('Replay execution was cancelled');
-                }
-                // Timeout reached without a match
-                if (!textMatches) {
-                    throw new Error(`Wait for text failed. Expected "${expectedText}" to match "${currentText}" after ${timeout}ms of polling every ${pollingInterval}ms`);
-                }
-                break;
-            default:
-                throw new Error(`Unhandled action: ${action}`);
+                    // Final cancellation check
+                    if (this.isCanceled && this.isCanceled()) {
+                        throw new Error('Replay execution was cancelled');
+                    }
+                    // Timeout reached without a match
+                    if (!textMatches) {
+                        throw new Error(`Wait for text failed. Expected "${expectedText}" to match "${currentText}" after ${timeout}ms of polling every ${pollingInterval}ms`);
+                    }
+                    break;
+                default:
+                    throw new Error(`Unhandled action: ${action}`);
+            }
+        }
+        finally {
+            this.page = originalPage;
         }
     }
     /**