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

package/dist/index.cjs

@@ -1446,23 +1446,23 @@ const highlighterCode = "(function (global, factory) {\n    typeof exports === '
         if (interaction.action === exports.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 === exports.PlaywrightAction.ASSERT_CONTAINS_VALUE ||
             interaction.action === exports.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 === exports.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 === exports.PlaywrightAction.ASK_AI) {
             const escapedQuestion = interaction.nativeDescription.replace(/'/g, "\\'");
@@ -1480,9 +1480,9 @@ const highlighterCode = "(function (global, factory) {\n    typeof exports === '
         }
         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) {
@@ -1509,17 +1509,79 @@ const highlighterCode = "(function (global, factory) {\n    typeof exports === '
           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 === exports.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 !== exports.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 === exports.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 === exports.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) => {
@@ -4983,8 +5045,11 @@ export default class ProboReporter implements Reporter {
     }
 
     class ProboPlaywright {
-        constructor({ enableSmartSelectors = false, timeoutConfig = {}, debugLevel = exports.ProboLogLevel.INFO, isCanceled }, page = null) {
+        constructor({ enableSmartSelectors = false, timeoutConfig = {}, debugLevel = exports.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;
@@ -4994,6 +5059,7 @@ export default class ProboReporter implements Reporter {
             };
             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);
         }
@@ -5008,8 +5074,36 @@ export default class ProboReporter implements Reporter {
             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
@@ -5036,417 +5130,441 @@ export default class ProboReporter implements Reporter {
         * @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 === exports.PlaywrightAction.VISIT_URL || action === exports.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 === exports.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 === exports.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 === exports.PlaywrightAction.VISIT_URL || action === exports.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 === exports.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 === exports.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 === exports.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 === exports.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 === exports.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 === exports.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 exports.PlaywrightAction.CLICK:
-                case exports.PlaywrightAction.CHECK_CHECKBOX:
-                case exports.PlaywrightAction.SELECT_RADIO:
-                    await this.robustMouseAction(locator, 'click');
-                    break;
-                case exports.PlaywrightAction.FILL_IN:
-                    await this.robustFill(locator, argument);
-                    break;
-                case exports.PlaywrightAction.SELECT_DROPDOWN:
-                    await locator.selectOption(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                    break;
-                case exports.PlaywrightAction.SET_SLIDER:
-                    await this.setSliderValue(locator, argument);
-                    break;
-                case exports.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 exports.PlaywrightAction.CLICK:
+                    case exports.PlaywrightAction.CHECK_CHECKBOX:
+                    case exports.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 exports.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 exports.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 exports.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 exports.PlaywrightAction.HOVER:
-                    if (locator) {
-                        await this.robustMouseAction(locator, 'hover');
-                    }
-                    else {
-                        throw new Error('not executing HOVER because no visible ancestor found');
-                    }
-                    break;
-                case exports.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 exports.PlaywrightAction.FILL_IN:
+                        await this.robustFill(locator, argument);
+                        break;
+                    case exports.PlaywrightAction.SELECT_DROPDOWN:
+                        await locator.selectOption(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                        break;
+                    case exports.PlaywrightAction.SET_SLIDER:
+                        await this.setSliderValue(locator, argument);
+                        break;
+                    case exports.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 exports.PlaywrightAction.UPLOAD_FILES:
-                    await locator.setInputFiles(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
-                    break;
-                case exports.PlaywrightAction.EXTRACT_VALUE:
-                    let extractedText = await this.getTextValue(locator);
-                    return extractedText;
-                case exports.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 exports.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 exports.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 exports.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 exports.PlaywrightAction.HOVER:
+                        if (locator) {
+                            await this.robustMouseAction(locator, 'hover');
+                        }
+                        else {
+                            throw new Error('not executing HOVER because no visible ancestor found');
+                        }
+                        break;
+                    case exports.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 exports.PlaywrightAction.UPLOAD_FILES:
+                        await locator.setInputFiles(argument, { timeout: this.timeoutConfig.playwrightActionTimeout });
+                        break;
+                    case exports.PlaywrightAction.EXTRACT_VALUE:
+                        let extractedText = await this.getTextValue(locator);
+                        return extractedText;
+                    case exports.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;
             }
         }
         /**