diff --git a/Drivers/Built_In_Driver.py b/Drivers/Built_In_Driver.py
index dd2e894c5..dde1b15f6 100755
--- a/Drivers/Built_In_Driver.py
+++ b/Drivers/Built_In_Driver.py
@@ -9,14 +9,14 @@
 from Framework.Built_In_Automation.Sequential_Actions import sequential_actions as sa
 
 
-def sequential_actions(
+async def sequential_actions(
     step_data,
     test_action_info,
     temp_q,
     debug_actions=None,
 ):
     try:
-        sTestStepReturnStatus = sa.Sequential_Actions(
+        sTestStepReturnStatus = await sa.Sequential_Actions(
             step_data,
             test_action_info,
             debug_actions,
diff --git a/Framework/Built_In_Automation/Sequential_Actions/action_declarations/playwright.py b/Framework/Built_In_Automation/Sequential_Actions/action_declarations/playwright.py
index d0aca46ac..3964a2711 100644
--- a/Framework/Built_In_Automation/Sequential_Actions/action_declarations/playwright.py
+++ b/Framework/Built_In_Automation/Sequential_Actions/action_declarations/playwright.py
@@ -11,7 +11,9 @@
 declarations = (
     # Browser Management
     { "name": "open browser",                  "function": "Open_Browser",               "screenshot": "web" },
+    { "name": "open electron app",             "function": "Open_Electron_App",          "screenshot": "web" },
     { "name": "go to link",                    "function": "Go_To_Link",                 "screenshot": "web" },
+    { "name": "go to link v2",                 "function": "Go_To_Link_V2",              "screenshot": "web" },
     { "name": "tear down browser",             "function": "Tear_Down_Playwright",       "screenshot": "none" },
     { "name": "teardown",                      "function": "Tear_Down_Playwright",       "screenshot": "none" },
     { "name": "switch browser",                "function": "Switch_Browser",             "screenshot": "none" },
@@ -21,6 +23,7 @@
     { "name": "double click",                  "function": "Double_Click_Element",       "screenshot": "web" },
     { "name": "right click",                   "function": "Right_Click_Element",        "screenshot": "web" },
     { "name": "hover",                         "function": "Hover_Over_Element",         "screenshot": "web" },
+    { "name": "click and download",            "function": "Click_and_Download",         "screenshot": "web" },
 
     # Text Input
     { "name": "text",                          "function": "Enter_Text_In_Text_Box",     "screenshot": "web" },
@@ -34,6 +37,8 @@
 
     # Element Information
     { "name": "save attribute",                "function": "Save_Attribute",             "screenshot": "web" },
+    { "name": "change attribute value",        "function": "Change_Attribute_Value",       "screenshot": "web" },
+    { "name": "capture network log",           "function": "capture_network_log",        "screenshot": "web" },
     { "name": "get element info",              "function": "get_element_info",           "screenshot": "web" },
     { "name": "extract table data",            "function": "Extract_Table_Data",         "screenshot": "web" },
 
@@ -45,6 +50,11 @@
     { "name": "scroll",                        "function": "Scroll",                     "screenshot": "web" },
     { "name": "scroll to element",             "function": "scroll_to_element",          "screenshot": "web" },
     { "name": "scroll element to top",         "function": "scroll_to_element",          "screenshot": "web" },
+    { "name": "scroll to top",                 "function": "scroll_to_top",              "screenshot": "web" },
+
+    # Lists / attributes
+    { "name": "save attribute values in list", "function": "save_attribute_values_in_list", "screenshot": "web" },
+    { "name": "save web elements in list",     "function": "save_web_elements_in_list",     "screenshot": "web" },
 
     # Selection (Dropdowns/Checkboxes)
     { "name": "select by visible text",        "function": "Select_Deselect",            "screenshot": "web" },
@@ -55,6 +65,9 @@
     { "name": "deselect by index",             "function": "Select_Deselect",            "screenshot": "web" },
     { "name": "deselect all",                  "function": "Select_Deselect",            "screenshot": "web" },
     { "name": "check uncheck",                 "function": "check_uncheck",              "screenshot": "web" },
+    { "name": "check uncheck all",             "function": "check_uncheck_all",          "screenshot": "web" },
+    { "name": "multiple check uncheck",        "function": "multiple_check_uncheck",        "screenshot": "web" },
+    { "name": "slider bar",                    "function": "slider_bar",                 "screenshot": "web" },
 
     # Window/Tab Management
     { "name": "switch window",                 "function": "switch_window_or_tab",       "screenshot": "web" },
@@ -80,6 +93,7 @@
 
     # File Upload
     { "name": "upload file",                   "function": "upload_file",                "screenshot": "web" },
+    { "name": "copy image into browser",       "function": "copy_image_into_browser",    "screenshot": "web" },
 
     # Window Management
     { "name": "resize window",                 "function": "resize_window",              "screenshot": "web" },
diff --git a/Framework/Built_In_Automation/Sequential_Actions/common_functions.py b/Framework/Built_In_Automation/Sequential_Actions/common_functions.py
index c2b361a63..4fb23b5c9 100755
--- a/Framework/Built_In_Automation/Sequential_Actions/common_functions.py
+++ b/Framework/Built_In_Automation/Sequential_Actions/common_functions.py
@@ -3723,7 +3723,7 @@ def _print(*args, sep=' ', end='\n', file=None, dont_send=False):
 
 
 @logger
-def execute_python_code(data_set):
+async def execute_python_code(data_set):
     try:
         sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
         inp, out_var, main_function, Code, filepath_code = "", "", "", "", ""
@@ -3749,10 +3749,31 @@ def execute_python_code(data_set):
 
         Code = filepath_code if filepath_code else Code
         sr.shared_variables["print"] = _print
+        try:
+            from Framework.Built_In_Automation.Web import utils as WebUtils
+
+            await WebUtils.hydrate_browser_compatibility_globals(data_set)
+        except Exception:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                "Could not hydrate browser compatibility globals before executing python code",
+                2,
+            )
+            CommonUtil.Exception_Handler(sys.exc_info())
         previous_vars = set(sr.shared_variables)
 
-        try: exec(Code, sr.shared_variables)
-        except: return CommonUtil.Exception_Handler(sys.exc_info())
+        try:
+            compiled_code = compile(
+                Code,
+                "<execute_python_code>",
+                "exec",
+                flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT,
+            )
+            exec_result = eval(compiled_code, sr.shared_variables)
+            if inspect.isawaitable(exec_result):
+                await exec_result
+        except:
+            return CommonUtil.Exception_Handler(sys.exc_info())
 
         try:
             current_vars = set(sr.shared_variables)
diff --git a/Framework/Built_In_Automation/Sequential_Actions/performance_action.py b/Framework/Built_In_Automation/Sequential_Actions/performance_action.py
index 840aed330..05eacc241 100644
--- a/Framework/Built_In_Automation/Sequential_Actions/performance_action.py
+++ b/Framework/Built_In_Automation/Sequential_Actions/performance_action.py
@@ -1,8 +1,9 @@
+import asyncio
 import time
 import threading
 import inspect
 from concurrent import futures
-from typing import Callable, List, Tuple, Union, Any
+from typing import Awaitable, Callable, List, Tuple, Union, Any
 from Framework.Built_In_Automation.Shared_Resources import BuiltInFunctionSharedResources as sr
 
 from Framework.Utilities import CommonUtil
@@ -76,7 +77,7 @@ def tick(self, cycle: int, launch_count: int):
 
 def performance_action_handler(
     data_set: List[List[str]],
-    run_sequential_actions: Callable[[List[int]], Tuple[str, List[int]]],
+    run_sequential_actions: Callable[[List[int]], Awaitable[Tuple[str, List[int]]]],
     timestamp_func: Callable[[], str],
 ) -> Tuple[str, List[int], List[Any]]:
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
@@ -156,7 +157,7 @@ def task(cycle):
 
             timestamp = timestamp_func()
             start_time = time.perf_counter_ns()
-            result = run_sequential_actions(actions_to_execute)
+            result = asyncio.run(run_sequential_actions(actions_to_execute))
             end_time = time.perf_counter_ns()
 
             max_parallel_thread_count = max(max_parallel_thread_count, threading.active_count())
diff --git a/Framework/Built_In_Automation/Sequential_Actions/sequential_actions.py b/Framework/Built_In_Automation/Sequential_Actions/sequential_actions.py
index 4ff0044c8..3b39d68cd 100755
--- a/Framework/Built_In_Automation/Sequential_Actions/sequential_actions.py
+++ b/Framework/Built_In_Automation/Sequential_Actions/sequential_actions.py
@@ -29,6 +29,7 @@
 
 # Import modules
 import inspect
+import asyncio
 import os
 import sys
 import time
@@ -177,8 +178,22 @@ def write_browser_logs():
     try:
         if str(sr.Get_Shared_Variables("zeuz_collect_browser_log")).strip().lower() in ("false", "no", "off", "disable"):
             return
+        drivers = []
+        if sr.Test_Shared_Variables("browser_sessions"):
+            browser_sessions = sr.Get_Shared_Variables("browser_sessions", log=False)
+            if isinstance(browser_sessions, dict):
+                drivers.extend(
+                    session.get("selenium_driver")
+                    for session in browser_sessions.values()
+                    if isinstance(session, dict) and session.get("selenium_driver")
+                )
         if sr.Test_Shared_Variables("selenium_driver"):
-            driver = sr.Get_Shared_Variables("selenium_driver")
+            drivers.append(sr.Get_Shared_Variables("selenium_driver"))
+        seen = set()
+        for driver in drivers:
+            if id(driver) in seen:
+                continue
+            seen.add(id(driver))
             for browser_log in driver.get_log("browser"):
                 CommonUtil.ExecLog(sModuleInfo, browser_log["message"], 6,print_Execlog=CommonUtil.show_browser_log)
     except Exception as e:
@@ -279,7 +294,7 @@ def if_else_log_for_actions(left, next_level_step_data, statement="if"):
     return left + ".... condition matched\n" + "Running actions: " + log_actions
 
 
-def If_else_action(step_data, data_set_no):
+async def If_else_action(step_data, data_set_no):
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     try:
         data_set = step_data[data_set_no]
@@ -526,7 +541,7 @@ def check_operators():
                 )
                 return "zeuz_failed"
             if data_set_index not in inner_skip:
-                result, skip = Run_Sequential_Actions(
+                result, skip = await Run_Sequential_Actions(
                     [data_set_index]
                 ) # Running
                 inner_skip = list(set(inner_skip+skip))
@@ -559,7 +574,7 @@ def sanitize_deprecated_dataset(value):
     return value
 
 
-def for_loop_action(step_data, data_set_no):
+async def for_loop_action(step_data, data_set_no):
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     try:
         data_set = step_data[data_set_no]
@@ -748,7 +763,7 @@ def for_loop_action(step_data, data_set_no):
                         sr.Set_Shared_Variables(CommonUtil.dont_prettify_on_server[0], step_data, protected=True, pretty=False)
                         sr.test_action_info = CommonUtil.all_action_info[step_index]
                         return "zeuz_failed", outer_skip
-                    result, skip = Run_Sequential_Actions([data_set_index])
+                    result, skip = await Run_Sequential_Actions([data_set_index])
                     inner_skip = list(set(inner_skip + skip))
                     outer_skip = list(set(outer_skip + inner_skip))
 
@@ -848,7 +863,7 @@ def for_loop_action(step_data, data_set_no):
         return CommonUtil.Exception_Handler(sys.exc_info()), []
 
 
-def While_Loop_Action(step_data, data_set_no):
+async def While_Loop_Action(step_data, data_set_no):
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     try:
         data_set = step_data[data_set_no]
@@ -947,7 +962,7 @@ def While_Loop_Action(step_data, data_set_no):
                             3
                         )
                         return "zeuz_failed", outer_skip
-                    result, skip = Run_Sequential_Actions(
+                    result, skip = await Run_Sequential_Actions(
                         [data_set_index]
                     )  # new edit: full step data is passed. [step_data[data_set_index]])
                     # Recursively call this function until all called data sets are complete
@@ -1049,7 +1064,7 @@ def ticker_linear_shape(seconds, callable, *args, **kwargs):
         seconds -= 1
 
 
-def Sequential_Actions(
+async def Sequential_Actions(
     step_data,
     test_action_info,
     debug_actions=None,
@@ -1068,13 +1083,13 @@ def Sequential_Actions(
     # sr.Set_Shared_Variables("test_action_info", test_action_info, protected=True, print_variable=False)
     sr.test_action_info = test_action_info
 
-    result, skip_for_loop = Run_Sequential_Actions([], debug_actions)
+    result, skip_for_loop = await Run_Sequential_Actions([], debug_actions)
     # empty list means run all, instead of step data we want to send the dataset no's of the step data to run
     write_browser_logs()
     return result
 
 
-def Run_Sequential_Actions(
+async def Run_Sequential_Actions(
     data_set_list=None, debug_actions=None
 ):  # data_set_no will used in recursive conditional action call
     if data_set_list is None:
@@ -1100,7 +1115,7 @@ def Run_Sequential_Actions(
                     data_set_list.append(i)
 
         if len(data_set_list) == 0 and CommonUtil.debug_status and not sr.Test_Shared_Variables("selenium_driver") and ConfigModule.get_config_value("Inspector", "ai_plugin").strip().lower() in CommonUtil.affirmative_words:
-            return Action_Handler([["browser", "selenium action", "browser"]], ["browser", "selenium action", "browser"]), []
+            return await Action_Handler([["browser", "selenium action", "browser"]], ["browser", "selenium action", "browser"]), []
 
         for dataset_cnt in data_set_list:  # For each data set within step data
             data_set = step_data[dataset_cnt]  # Save data set to variable
@@ -1196,7 +1211,7 @@ def Run_Sequential_Actions(
 
                 # If middle column = action, call action handler, but always return a pass
                 elif "optional action" in action_name:
-                    result = Action_Handler(data_set, row)  # Pass data set, and action_name to action handler
+                    result = await Action_Handler(data_set, row)  # Pass data set, and action_name to action handler
                     if result == "zeuz_failed":
                         CommonUtil.ExecLog(sModuleInfo, "Optional action failed. Returning pass anyway", 2)
                     result = "passed"
@@ -1204,7 +1219,7 @@ def Run_Sequential_Actions(
                 # If middle column = conditional action, evaluate data set
                 elif "conditional action" in action_name or "if else" in action_name:
                     if action_name.lower().strip() == "windows conditional action":
-                        result, to_skip = Conditional_Action_Handler(step_data, dataset_cnt)
+                        result, to_skip = await Conditional_Action_Handler(step_data, dataset_cnt)
                         skip += to_skip
                         skip_for_loop += to_skip
                         if result in failed_tag_list:
@@ -1215,7 +1230,7 @@ def Run_Sequential_Actions(
 
                     elif action_name.lower().strip() != "conditional action" and action_name.lower().strip() != "if else":
                         # old style conditional action
-                        result, to_skip = Conditional_Action_Handler(step_data, dataset_cnt)
+                        result, to_skip = await Conditional_Action_Handler(step_data, dataset_cnt)
                         skip += to_skip
                         skip_for_loop += to_skip
                         if result in failed_tag_list:
@@ -1224,7 +1239,7 @@ def Run_Sequential_Actions(
                         break
 
                     else:
-                        result, to_skip = If_else_action(step_data, dataset_cnt)
+                        result, to_skip = await If_else_action(step_data, dataset_cnt)
                         skip += to_skip
                         skip_for_loop += to_skip
                         if result in failed_tag_list:
@@ -1235,7 +1250,7 @@ def Run_Sequential_Actions(
                 # Simulate a while/for loop with the specified data sets
                 elif "loop action" in action_name:
                     if action_name.lower().strip() == "for loop action":
-                        result, skip_for_loop = for_loop_action(step_data, dataset_cnt)
+                        result, skip_for_loop = await for_loop_action(step_data, dataset_cnt)
                         skip = list(set(skip + skip_for_loop))
                         if result in failed_tag_list:
                             return "zeuz_failed", skip_for_loop
@@ -1243,7 +1258,7 @@ def Run_Sequential_Actions(
                     elif action_name.lower().strip() not in ("while loop action", "for loop action"):
                         # old style loop action
                         # CommonUtil.ExecLog(sModuleInfo,"Old style loop action found. This will not be supported in 2020, please replace them with new loop actions",2)
-                        result, skip_for_loop = Loop_Action_Handler(data_set, row, dataset_cnt)
+                        result, skip_for_loop = await Loop_Action_Handler(data_set, row, dataset_cnt)
                         skip = skip_for_loop
 
                         position_of_loop_action = dataset_cnt
@@ -1273,7 +1288,7 @@ def Run_Sequential_Actions(
                             return "zeuz_failed", skip_for_loop
                 elif "loop" in action_name:
                     if "while" in action_name.lower():
-                        result, skip_for_loop = While_Loop_Action(step_data, dataset_cnt)
+                        result, skip_for_loop = await While_Loop_Action(step_data, dataset_cnt)
                     skip = list(set(skip + skip_for_loop))
                     if result in failed_tag_list:
                         return "zeuz_failed", skip_for_loop
@@ -1343,7 +1358,7 @@ def Run_Sequential_Actions(
 
                 # If middle column = action, call action handler
                 elif "action" in action_name:  # Must be last, since it's a single word that also exists in other action types
-                    result = Action_Handler(data_set, row)  # Pass data set, and action_name to action handler
+                    result = await Action_Handler(data_set, row)  # Pass data set, and action_name to action handler
                     if row[0].lower().strip() in ("step exit", "testcase exit"):
                         global step_exit_fail_called, step_exit_pass_called
                         CommonUtil.ExecLog(sModuleInfo, f"{row[0].lower().strip()} Exit called. Stopping Test Step.", 1)
@@ -1373,12 +1388,12 @@ def Run_Sequential_Actions(
                                     continue
 
                                 CommonUtil.ExecLog(sModuleInfo, "Action failed. Trying bypass #%d" % (i + 1), 1)
-                                result = Action_Handler(bypass_data_set[i], bypass_row[i])
+                                result = await Action_Handler(bypass_data_set[i], bypass_row[i])
                                 if result in failed_tag_list:  # This also failed, so chances are first failure was real
                                     continue  # Try the next bypass, if any
                                 else:  # Bypass passed, which indicates there was something blocking the element in the first place
                                     CommonUtil.ExecLog(sModuleInfo, "Bypass passed. Retrying original action", 1)
-                                    result = Action_Handler(data_set, row)  # Retry failed original data set
+                                    result = await Action_Handler(data_set, row)  # Retry failed original data set
                                     if result in failed_tag_list:  # Still a failure, give up
                                         return "zeuz_failed", skip_for_loop
                                     break  # No need to process more bypasses
@@ -1404,7 +1419,7 @@ def Run_Sequential_Actions(
         return CommonUtil.Exception_Handler(sys.exc_info())
 
 
-def Loop_Action_Handler(data, row, dataset_cnt):
+async def Loop_Action_Handler(data, row, dataset_cnt):
     """ Performs a sub-set of the data set in a loop, similar to a for or while loop """
 
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
@@ -1563,8 +1578,8 @@ def Loop_Action_Handler(data, row, dataset_cnt):
                             3,
                         )
 
-        def build_subset(new_step_data):
-            result = Run_Sequential_Actions(new_step_data)
+        async def build_subset(new_step_data):
+            result = await Run_Sequential_Actions(new_step_data)
             if result in passed_tag_list or (
                 type(result) == tuple and result[0] in passed_tag_list
             ):
@@ -1722,7 +1737,7 @@ def build_subset(new_step_data):
             if loop_method == "exit_on_dataset":
                 for ndc in range(len(new_step_data)):
                     # Build the sub-set and execute
-                    result = build_subset([new_step_data[ndc]])
+                    result = await build_subset([new_step_data[ndc]])
                     if result in failed_tag_list:
                         return result, skip
 
@@ -1739,12 +1754,12 @@ def build_subset(new_step_data):
                 for ndc in range(len(new_step_data)):  # For each data set in the sub-set
                     # Build the sub-set and execute
                     if load_testing:
-                        thread_pool.submit(build_subset, [new_step_data[ndc]])
+                        thread_pool.submit(lambda step_data: asyncio.run(build_subset(step_data)), [new_step_data[ndc]])
                         if not loop_result_for_load_testing:
                             CommonUtil.load_testing = False
                             return result, skip
                     else:
-                        result = build_subset([new_step_data[ndc]])
+                        result = await build_subset([new_step_data[ndc]])
                         if result in failed_tag_list:
                             CommonUtil.load_testing = False
                             return result, skip
@@ -1770,7 +1785,7 @@ def build_subset(new_step_data):
                     len(new_step_data)
                 ):  # For each data set in the sub-set
                     # Build the sub-set and execute
-                    result = build_subset(
+                    result = await build_subset(
                         [new_step_data[ndc]]
                     )  # the dataset was conditional then break
                     if result in failed_tag_list:
@@ -1798,7 +1813,7 @@ def build_subset(new_step_data):
                     len(new_step_data)
                 ):  # For each data set in the sub-set
                     # Build the sub-set and execute
-                    result = build_subset([new_step_data[ndc]])
+                    result = await build_subset([new_step_data[ndc]])
                     if result in failed_tag_list:
                         return result, skip
                     if nested_double:
@@ -1814,7 +1829,7 @@ def build_subset(new_step_data):
                 for ndc in range(len(new_step_data)):
                     # For each data set in the sub-set
                     # Build the sub-set and execute
-                    result = build_subset([new_step_data[ndc]])
+                    result = await build_subset([new_step_data[ndc]])
 
                     if result in passed_tag_list:
                         combined_result = combined_result and True
@@ -1903,7 +1918,7 @@ def build_subset(new_step_data):
         return CommonUtil.Exception_Handler(sys.exc_info())
 
 
-def Conditional_Action_Handler(step_data, dataset_cnt):
+async def Conditional_Action_Handler(step_data, dataset_cnt):
     """ Process conditional actions, called only by Sequential_Actions() """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
 
@@ -1984,6 +1999,37 @@ def Conditional_Action_Handler(step_data, dataset_cnt):
             logic_decision = False
             log_msg += "Element is not found\n"
 
+    elif module == "playwright":
+        try:
+            from Framework.Built_In_Automation.Web.Playwright import locator as PlaywrightLocator
+            from Framework.Built_In_Automation.Web.Playwright.BuiltInFunctions import current_page
+            
+            wait = 10
+            for left, mid, right in data_set:
+                mid = mid.lower()
+                left = left.lower()
+                if "optional parameter" in mid and "wait" in left:
+                    wait = float(right.strip())
+
+            if current_page is None:
+                CommonUtil.ExecLog(sModuleInfo, "No browser open for Playwright conditional action", 3)
+                logic_decision = False
+                log_msg += "Browser not open\n"
+            else:
+                Element = await PlaywrightLocator.Get_Element(data_set, current_page, element_wait=wait)
+                if Element == "zeuz_failed":
+                    CommonUtil.ExecLog(sModuleInfo, "Conditional Actions could not find the element", 3)
+                    logic_decision = False
+                    log_msg += "Element is not found\n"
+                else:
+                    logic_decision = True
+                    log_msg += "Element is found\n"
+
+        except:  # Element doesn't exist, proceed with the step data following the fail/false path
+            CommonUtil.ExecLog(sModuleInfo, "Conditional Actions could not find the element", 3)
+            logic_decision = False
+            log_msg += "Element is not found\n"
+
     elif module == "windows":
         try:
             from Framework.Built_In_Automation.Desktop.Windows import BuiltInFunctions
@@ -2186,7 +2232,7 @@ def Conditional_Action_Handler(step_data, dataset_cnt):
                 2
             )
         if data_set_index not in inner_skip:
-            result, skip = Run_Sequential_Actions(
+            result, skip = await Run_Sequential_Actions(
                 [data_set_index]
             )  # Running
             inner_skip = list(set(inner_skip + skip))
@@ -2199,7 +2245,7 @@ def Conditional_Action_Handler(step_data, dataset_cnt):
     return "passed", outer_skip
 
 
-def bypass_bug(*args,):
+async def bypass_bug(*args,):
     """ Suppose, there is a bug in the test product which is a pop-up that appears randomly and you need to close that pop-up
     So instead of putting that inside you testcase use this function.
     This function will read the action dataset from "Zeuz_Python_Node/bypass.json" file and run that action after every particular type action
@@ -2274,7 +2320,7 @@ def bypass_bug(*args,):
             if action_row is None:
                 continue
             CommonUtil.ExecLog("", "\n********** Starting Bypass action: %s **********\n%s" % (action_name, json.dumps(action, indent=2)), 4)
-            if Action_Handler(dataset, action_row, False) == "zeuz_failed":
+            if await Action_Handler(dataset, action_row, False) == "zeuz_failed":
                 CommonUtil.ExecLog(sModuleInfo, "Bypass action failed, however continuing", 2)
     except:
         return CommonUtil.Exception_Handler(sys.exc_info(), None, "Bypass action failed, however continuing")
@@ -2296,7 +2342,76 @@ def compare_variable_names(set, dataset):
         CommonUtil.compare_action_varnames = {"left": "Left", "right": "Right"}
 
 
-def Action_Handler(_data_set, action_row, _bypass_bug=True):
+def get_browser_driver_routing(action_subfield, data_set):
+    """
+    Check if browser driver optional parameter is present and route to appropriate driver.
+    
+    Args:
+        action_subfield (str): The original action subfield (e.g., "selenium action", "playwright action")
+        data_set (list): The data set containing optional parameters
+        
+    Returns:
+        str: Updated action_subfield based on browser driver parameter
+        
+    This function checks if there is a "browser driver" optional parameter in the data set or a BROWSER_DRIVER in runtime parameters.
+    If any of them are present, it updates the action_subfield to the value specified.
+    If both are present, it uses the action-level optional parameter.
+    If neither are present, it returns the original action_subfield.
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+
+    # If the action subfield is not for playwright or selenium, return as is
+    if action_subfield not in ("playwright action", "selenium action"):
+        return action_subfield
+    
+    # Initialize the updated action subfield with the original action subfield
+    updated_action_subfield = action_subfield
+
+    # Get the runtime parameter for browser driver preference
+    browser_driver_runtime_parameter = sr.shared_variables.get("BROWSER_DRIVER")
+
+    # If runtime parameter is present and valid, update the action subfield
+    if browser_driver_runtime_parameter and browser_driver_runtime_parameter.strip().lower() in ("playwright", "selenium"):
+        CommonUtil.ExecLog(sModuleInfo, "Runtime parameter for browser driver preference detected", 5)
+        updated_action_subfield = browser_driver_runtime_parameter.strip().lower() + " action"
+
+    # Check if there is an optional parameter for browser driver in the data set
+    for left, mid, right in data_set:
+        # If optional parameter is present and valid, update the action subfield
+        if (mid.strip().lower().startswith("optional") 
+            and left.strip().lower() == "browser driver" 
+            and right.strip().lower() in ("playwright", "selenium")):
+
+            # If runtime parameter is also present, action-level optional parameter will take precedence
+            if browser_driver_runtime_parameter:
+                # log a warning for browser driver preference in two places
+                CommonUtil.ExecLog(sModuleInfo, "Both runtime parameter and optional parameter for browser driver detected, using optional parameter", 2)
+            else:
+                CommonUtil.ExecLog(sModuleInfo, "Optional parameter for browser driver preference detected in action", 5)
+            updated_action_subfield = right.strip().lower() + " action"
+            break
+    
+    # If the action subfield has changed, log the change
+    if action_subfield != updated_action_subfield:
+        CommonUtil.ExecLog(sModuleInfo, "Browser action changed from %s to %s" % (action_subfield, updated_action_subfield), 1)
+
+    return updated_action_subfield
+
+
+def normalize_legacy_playwright_action_name(action_name, action_subfield):
+    """
+    Route legacy Selenium wait aliases to the Playwright wait declaration only
+    after browser-driver routing has selected Playwright.
+    """
+    if (
+        str(action_subfield).strip().lower() == "playwright action"
+        and str(action_name).strip().lower() in ("wait", "wait disable")
+    ):
+        return "wait for element"
+    return action_name
+
+
+async def Action_Handler(_data_set, action_row, _bypass_bug=True):
     """ Finds the appropriate function for the requested action in the step data and executes it """
 
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
@@ -2306,6 +2421,10 @@ def Action_Handler(_data_set, action_row, _bypass_bug=True):
     action_name = action_row[0]
     action_subfield = action_row[1]
 
+    # Apply browser driver routing if applicable
+    action_subfield = get_browser_driver_routing(action_subfield, _data_set)
+    action_name = normalize_legacy_playwright_action_name(action_name, action_subfield)
+    
     if str(action_name).startswith("%|"):  # if shared variable
         action_name = sr.get_previous_response_variables_in_strings(action_name)
 
@@ -2410,6 +2529,13 @@ def Action_Handler(_data_set, action_row, _bypass_bug=True):
         if result == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Can't find module for %s" % module, 3)
             return "zeuz_failed"
+        session_activator = getattr(eval(module), "_activate_browser_session_for_action", None)
+        if session_activator:
+            result = session_activator(data_set, function)
+            if inspect.iscoroutine(result):
+                result = await result
+            if result in failed_tag_list:
+                return result
         run_function = getattr(eval(module), function)  # create a reference to the function
         start_time = time.perf_counter()
         if pre_sleep:
@@ -2417,6 +2543,8 @@ def Action_Handler(_data_set, action_row, _bypass_bug=True):
         elif module in CommonUtil.global_sleep and "_all_" in CommonUtil.global_sleep[module]:
             time.sleep(CommonUtil.global_sleep[module]["_all_"]["pre"])
         result = run_function(data_set)  # Execute function, providing all rows in the data set
+        if inspect.iscoroutine(result): 
+            result = await result
         if post_sleep:
             time.sleep(post_sleep)
         elif module in CommonUtil.global_sleep and "_all_" in CommonUtil.global_sleep[module]:
@@ -2436,11 +2564,11 @@ def Action_Handler(_data_set, action_row, _bypass_bug=True):
         compare_variable_names(False, [])
         if performance_action.zeuz_cycle != -1:
             CommonUtil.action_perf[-1]['cycle'] = performance_action.zeuz_cycle
-        CommonUtil.TakeScreenShot(function)
+        await CommonUtil.TakeScreenShot(function)
         CommonUtil.previous_action_name = CommonUtil.current_action_name
         if _bypass_bug:
             CommonUtil.print_execlog = False
-            bypass_bug(action_name, action_subfield)
+            await bypass_bug(action_name, action_subfield)
             CommonUtil.print_execlog = True
         return result  # Return result to sequential_actions()
 
@@ -2459,4 +2587,4 @@ def Action_Handler(_data_set, action_row, _bypass_bug=True):
 if any any passes
 if ay passes
 this-1199athis+-1,this+1
-'''
\ No newline at end of file
+'''
diff --git a/Framework/Built_In_Automation/Sequential_Actions/time_base_performance_action.py b/Framework/Built_In_Automation/Sequential_Actions/time_base_performance_action.py
index 62472eae5..58d1fe93e 100644
--- a/Framework/Built_In_Automation/Sequential_Actions/time_base_performance_action.py
+++ b/Framework/Built_In_Automation/Sequential_Actions/time_base_performance_action.py
@@ -1,8 +1,9 @@
+import asyncio
 import time
 import threading
 import inspect
 from concurrent import futures
-from typing import Callable, List, Tuple, Union, Any
+from typing import Awaitable, Callable, List, Tuple, Union, Any
 from Framework.Built_In_Automation.Shared_Resources import BuiltInFunctionSharedResources as sr
 
 from Framework.Utilities import CommonUtil
@@ -51,7 +52,7 @@ def _cycle_ramp(self, cycle: int):
 
 def time_base_performance_action_handler(
     data_set: List[List[str]],
-    run_sequential_actions: Callable[[List[int]], None],
+    run_sequential_actions: Callable[[List[int]], Awaitable[Tuple[str, List[int]]]],
     timestamp_func: Callable[[], str],
 ) -> Tuple[str, List[int]]:
     spawn_rate = 1
@@ -126,7 +127,7 @@ def task():
 
         timestamp = timestamp_func()
         start_time = time.perf_counter_ns()
-        result = run_sequential_actions(actions_to_execute)
+        result = asyncio.run(run_sequential_actions(actions_to_execute))
         end_time = time.perf_counter_ns()
         alive_task_count -= 1
 
diff --git a/Framework/Built_In_Automation/Web/Playwright/BuiltInFunctions.py b/Framework/Built_In_Automation/Web/Playwright/BuiltInFunctions.py
index b13120e32..a3fe53ded 100644
--- a/Framework/Built_In_Automation/Web/Playwright/BuiltInFunctions.py
+++ b/Framework/Built_In_Automation/Web/Playwright/BuiltInFunctions.py
@@ -20,30 +20,256 @@
 Author: Zeuz/AutomationSolutionz
 """
 
+import asyncio
 import sys
 import os
 import inspect
+import platform
 import time
-import re
+import base64
 from pathlib import Path
+from urllib.parse import urlparse
+import requests
 
-from playwright.sync_api import (
-    sync_playwright,
+from playwright.async_api import (
+    async_playwright,
     Page,
     Browser,
     BrowserContext,
-    Locator,
     TimeoutError as PlaywrightTimeoutError,
     Error as PlaywrightError,
 )
 
-from Framework.Utilities import CommonUtil
+from Framework.Utilities import CommonUtil, ConfigModule
 from Framework.Utilities.decorators import logger
+from settings import ZEUZ_NODE_DOWNLOADS_DIR
 from Framework.Built_In_Automation.Shared_Resources import (
     BuiltInFunctionSharedResources as sr,
 )
-from Framework.Utilities.CommonUtil import passed_tag_list, failed_tag_list
+from Framework.Utilities.CommonUtil import failed_tag_list
 from . import locator as PlaywrightLocator
+from . import utils as PlaywrightUtils
+from Framework.Built_In_Automation.Web.utils import (
+    create_browser_session,
+    extract_session_name,
+    get_browser_session,
+    get_browser_sessions,
+    get_debug_port,
+    remove_browser_session,
+)
+
+def _get_frame_locator():
+    """Helper function to get current frame locator from shared variables."""
+    try:
+        frame_locator = sr.Get_Shared_Variables("playwright_frame")
+        if frame_locator in failed_tag_list:
+            return None
+        return frame_locator
+    except Exception:
+        # Variable doesn't exist yet
+        return None
+
+
+def _has_chromium_arg(args, arg_names):
+    """Return True when Chromium args already include one of the named flags."""
+
+    for arg in args:
+        normalized_arg = arg.strip()
+        for arg_name in arg_names:
+            if normalized_arg == arg_name or normalized_arg.startswith(f"{arg_name}="):
+                return True
+    return False
+
+
+def _set_active_playwright_session(session_name, session):
+    """Update module globals/shared variables for a selected Playwright session."""
+
+    global current_page, current_page_id, context, browser, playwright_instance
+
+    current_page = session.get("playwright_page")
+    context = session.get("playwright_context")
+    browser = session.get("playwright_browser")
+    playwright_instance = session.get("playwright_instance") or playwright_instance
+    current_page_id = session_name
+
+    sr.Set_Shared_Variables("playwright_page", current_page)
+    sr.Set_Shared_Variables("playwright_context", context)
+    sr.Set_Shared_Variables("playwright_browser", browser)
+    sr.Set_Shared_Variables("playwright_frame", session.get("playwright_frame"))
+    sr.Set_Shared_Variables("active_web_driver_type", "playwright")
+    if session.get("selenium_driver"):
+        sr.Set_Shared_Variables("selenium_driver", session["selenium_driver"])
+    CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
+
+
+async def _ensure_playwright_session(session_name, existing_session):
+    """Activate an existing Playwright session or lazily attach to a Selenium one."""
+
+    global playwright_details
+
+    if existing_session and existing_session.get("playwright_page"):
+        _set_active_playwright_session(session_name, existing_session)
+        return "passed"
+
+    if not existing_session or not existing_session.get("selenium_driver"):
+        return "zeuz_failed"
+
+    port = existing_session.get("remote_debugging_port")
+    if not port:
+        return "zeuz_failed"
+
+    try:
+        from Framework.Built_In_Automation.Web.Selenium import BuiltInFunctions as SeleniumBuiltInFunctions
+
+        playwright_instance, connected_browser, connected_context, connected_page = await SeleniumBuiltInFunctions.connect_playwright_to_selenium(port=port)
+        sessions = get_browser_sessions()
+        session = sessions.setdefault(session_name, existing_session)
+        session.update({
+            "selenium_driver": existing_session.get("selenium_driver"),
+            "playwright_page": connected_page,
+            "playwright_browser": connected_browser,
+            "playwright_context": connected_context,
+            "playwright_frame": None,
+            "playwright_instance": playwright_instance,
+            "remote_debugging_port": port,
+        })
+        sr.Set_Shared_Variables("browser_sessions", sessions)
+        playwright_details[session_name] = {
+            "page": connected_page,
+            "context": connected_context,
+            "browser": connected_browser,
+            "playwright": playwright_instance,
+            "remote-debugging-port": port,
+        }
+        _set_active_playwright_session(session_name, session)
+        CommonUtil.ExecLog("_ensure_playwright_session", f"Connected Playwright to Selenium session: {session_name}", 1)
+        return "passed"
+    except Exception as e:
+        CommonUtil.ExecLog("_ensure_playwright_session", f"Failed to connect Playwright to Selenium session '{session_name}': {e}", 3)
+        return "zeuz_failed"
+
+
+def _save_current_playwright_frame(frame_locator):
+    if current_page_id:
+        sessions = get_browser_sessions()
+        if current_page_id in sessions:
+            sessions[current_page_id]["playwright_frame"] = frame_locator
+            sr.Set_Shared_Variables("browser_sessions", sessions)
+
+
+def _get_installed_cft_chromedriver(browser_version):
+    system = platform.system().lower()
+    arch = platform.machine().lower()
+
+    if system == "windows":
+        platform_key = "win64" if arch in ("amd64", "x86_64") else "win32"
+        executable = "chromedriver.exe"
+    elif system == "darwin":
+        platform_key = "mac-arm64" if arch == "arm64" else "mac-x64"
+        executable = "chromedriver"
+    elif system == "linux":
+        platform_key = "linux64"
+        executable = "chromedriver"
+    else:
+        return None
+
+    driver_path = (
+        ZEUZ_NODE_DOWNLOADS_DIR
+        / "chrome_for_testing"
+        / "versions"
+        / browser_version
+        / "driver"
+        / f"chromedriver-{platform_key}"
+        / executable
+    )
+    return str(driver_path) if driver_path.exists() else None
+
+
+async def _activate_browser_session_for_action(step_data, function_name=None):
+    """Select the requested browser session before running Playwright actions."""
+
+    session_name = extract_session_name(step_data)
+    create_or_cleanup_actions = {
+        "Open_Browser",
+        "Go_To_Link",
+        "Tear_Down_Playwright",
+    }
+    if function_name in create_or_cleanup_actions:
+        return "passed"
+
+    if not session_name:
+        if current_page is None:
+            default_session = get_browser_session("default")
+            if default_session and default_session.get("selenium_driver"):
+                return await _ensure_playwright_session("default", default_session)
+        return "passed"
+
+    existing_session = get_browser_session(session_name)
+    result = await _ensure_playwright_session(session_name, existing_session)
+    if result in failed_tag_list:
+        sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+        CommonUtil.ExecLog(sModuleInfo, f"Browser session '{session_name}' not found", 3)
+        return "zeuz_failed"
+
+    return "passed"
+
+
+def connect_selenium_to_playwright(port=9222):
+    """Connect Selenium to Playwright browser via CDP"""
+    try:
+        from selenium import webdriver
+        from selenium.webdriver.chrome.options import Options
+        from selenium.webdriver.chrome.service import Service
+        from webdriver_manager.chrome import ChromeDriverManager
+        
+        options = Options()
+        options.add_experimental_option("debuggerAddress", f"127.0.0.1:{port}")
+
+        service = None
+        try:
+            response = requests.get(f"http://127.0.0.1:{port}/json/version", timeout=5)
+            response.raise_for_status()
+            browser_version = (
+                response.json()
+                .get("Browser", "")
+                .split("/", 1)[-1]
+                .strip()
+            )
+            if browser_version:
+                driver_path = _get_installed_cft_chromedriver(browser_version)
+                if not driver_path:
+                    driver_path = ChromeDriverManager(
+                        driver_version=browser_version
+                    ).install()
+                service = Service(executable_path=driver_path)
+                CommonUtil.ExecLog(
+                    "connect_selenium_to_playwright",
+                    f"Using ChromeDriver matching browser version {browser_version}",
+                    1,
+                )
+        except Exception:
+            CommonUtil.ExecLog(
+                "connect_selenium_to_playwright",
+                "Could not resolve matching ChromeDriver for Playwright browser; falling back to Selenium Manager",
+                2,
+            )
+
+        if service:
+            driver = webdriver.Chrome(service=service, options=options)
+        else:
+            driver = webdriver.Chrome(options=options)
+        
+        from Framework.Built_In_Automation.Web.Selenium import BuiltInFunctions as SeleniumBuiltInFunctions
+        SeleniumBuiltInFunctions.selenium_driver = driver
+        
+        sr.Set_Shared_Variables("selenium_driver", driver)
+        
+        CommonUtil.ExecLog("connect_selenium_to_playwright", "Connected Selenium to Playwright", 1)
+        return driver
+        
+    except Exception as e:
+        CommonUtil.ExecLog("connect_selenium_to_playwright", f"Failed to connect Selenium to Playwright: {e}", 3)
+        return "zeuz_failed"
 
 #########################
 #                       #
@@ -53,6 +279,12 @@
 
 MODULE_NAME = inspect.getmodulename(__file__)
 
+temp_config = str(
+    Path(os.path.abspath(__file__).split("Framework")[0])
+    / "AutomationLog"
+    / ConfigModule.get_config_value("Advanced Options", "_file")
+)
+
 # Playwright instances
 playwright_instance = None
 browser: Browser = None
@@ -62,20 +294,123 @@
 # Multi-page/context support
 playwright_details = {}  # {"page_id": {"page": Page, "context": Context, "browser": Browser}}
 current_page_id = None
+network_log_details = {}
 
 # Default settings
 default_timeout = 30000  # 30 seconds
 default_viewport = {"width": 1920, "height": 1080}
 
 
+def _compact(value):
+    return str(value).replace(" ", "").replace("_", "").replace("-", "").lower()
+
+
+def _is_action_mid(mid):
+    return "action" in str(mid).strip().lower()
+
+
+def _truthy(value):
+    return str(value).strip().lower() in ("true", "yes", "ok", "1", "accept")
+
+
+def _is_placeholder(value, *placeholders):
+    value_l = str(value).strip().lower()
+    return not value_l or value_l in placeholders or value_l == "default"
+
+
+def _has_element_rows(step_data):
+    return any(_is_element_parameter_mid(mid) for _, mid, _ in step_data)
+
+
+def _action_row_value(step_data, *action_names):
+    names = {name.strip().lower() for name in action_names}
+    for left, mid, right in step_data:
+        if _is_action_mid(mid) and (not names or left.strip().lower() in names):
+            return str(right)
+    return None
+
+
+def _save_variable_from_action_or_save_parameter(step_data, *action_names):
+    save_variable = None
+    for left, mid, right in step_data:
+        mid_l = str(mid).strip().lower()
+        if mid_l == "save parameter":
+            save_variable = str(left).strip()
+        elif _is_action_mid(mid) and (not action_names or left.strip().lower() in action_names):
+            value = str(right).strip()
+            if not _is_placeholder(value, left.strip().lower()):
+                save_variable = value
+    return save_variable
+
+
+def _screenshot_folder():
+    try:
+        folder = ConfigModule.get_config_value("sectionOne", "screen_capture_folder", temp_config)
+        if folder:
+            Path(folder).mkdir(parents=True, exist_ok=True)
+            return folder
+    except Exception:
+        pass
+    return os.getcwd()
+
+
+def _download_folder():
+    try:
+        folder = sr.Get_Shared_Variables("zeuz_download_folder")
+        if folder not in failed_tag_list:
+            Path(folder).mkdir(parents=True, exist_ok=True)
+            return folder
+    except Exception:
+        pass
+    return os.getcwd()
+
+
 #########################
 #                       #
 #   Browser Management  #
 #                       #
 #########################
 
+async def _handle_playwright_session(step_data):
+    """
+    Helper function to handle session parameter for Playwright actions.
+    
+    Args:
+        step_data: The step data containing potential session parameter
+        
+    Returns:
+        tuple: (session_name, current_page, current_page_id, context, browser)
+        - session_name: The session name found or None
+        - current_page: The appropriate page instance
+        - current_page_id: The current page ID
+        - context: The browser context
+        - browser: The browser instance
+    """
+    global current_page, current_page_id, context, browser
+    
+    session_name = extract_session_name(step_data)
+    
+    # If session parameter is provided, switch to that session
+    if session_name:
+        existing_session = get_browser_session(session_name)
+        
+        if existing_session and await _ensure_playwright_session(session_name, existing_session) not in failed_tag_list:
+            sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+            CommonUtil.ExecLog(sModuleInfo, f"Using existing browser session: {session_name}", 1)
+        else:
+            sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+            CommonUtil.ExecLog(sModuleInfo, f"Browser session '{session_name}' not found", 3)
+            raise ValueError(f"Browser session '{session_name}' not found")
+    elif current_page is None:
+        default_session = get_browser_session("default")
+        if default_session and default_session.get("selenium_driver"):
+            await _ensure_playwright_session("default", default_session)
+    
+    return session_name, current_page, current_page_id, context, browser
+
+
 @logger
-def Open_Browser(step_data):
+async def Open_Browser(step_data):
     """
     Launch a new browser instance with Playwright.
 
@@ -103,9 +438,13 @@ def Open_Browser(step_data):
     try:
         # Parse parameters
         url = None
+        dependency = sr.Get_Shared_Variables("dependency")
         browser_name = "chromium"
-        headless = True
+        if isinstance(dependency, dict) and dependency.get("Browser"):
+            browser_name = dependency["Browser"].strip().lower().replace("headless", "").strip() or browser_name
+        headless = False
         viewport = default_viewport.copy()
+        resolution = None
         args = []
         timeout = default_timeout
         slow_mo = 0
@@ -130,7 +469,7 @@ def Open_Browser(step_data):
                     url = right_v
                 elif left_l in ("browser", "browser name"):
                     browser_name = right_v.lower()
-                elif left_l in ("driver id", "page id", "driver tag"):
+                elif _compact(left_l) in ("driverid", "pageid", "drivertag", "session"):
                     page_id = right_v
 
             elif mid_l == "optional parameter":
@@ -138,7 +477,11 @@ def Open_Browser(step_data):
                     headless = right_v.lower() in ("true", "yes", "1")
                 elif left_l == "resolution":
                     parts = right_v.replace("x", ",").split(",")
-                    viewport = {"width": int(parts[0].strip()), "height": int(parts[1].strip())}
+                    resolution = {
+                        "width": int(parts[0].strip()),
+                        "height": int(parts[1].strip()),
+                    }
+                    viewport = resolution.copy()
                 elif left_l in ("timeout", "wait time to page load", "page load timeout"):
                     timeout = int(float(right_v) * 1000)
                 elif left_l in ("add argument", "arg", "argument"):
@@ -161,45 +504,80 @@ def Open_Browser(step_data):
                     color_scheme = right_v
                 elif left_l == "permission":
                     permissions.append(right_v)
+                elif _compact(left_l) in ("driverid", "pageid", "drivertag", "session"):
+                    page_id = right_v    
 
             elif mid_l == "shared capability":
                 # Handle Selenium-style capabilities where possible
                 pass
 
+        # Ensure Playwright's managed browser is available in Zeuz's persistent cache.
+        success = PlaywrightUtils.ensure_playwright_browser_installed(sModuleInfo, browser_name)
+        if not success:
+            return "zeuz_failed"
+
         # Launch Playwright
         CommonUtil.ExecLog(sModuleInfo, f"Launching Playwright with {browser_name} browser", 1)
-        playwright_instance = sync_playwright().start()
+        playwright_instance = await async_playwright().start()
 
         # Browser launch options
         launch_options = {
             "headless": headless,
             "slow_mo": slow_mo,
-            "devtools": devtools,
         }
-        if args:
-            launch_options["args"] = args
+        
+        # Add remote debugging port for CDP connection with unique port per session
+        unique_port = get_debug_port(page_id)
+        all_args = args + [f"--remote-debugging-port={unique_port}"]
+        chromium_like_browser = browser_name not in ("firefox", "webkit", "safari")
+        if chromium_like_browser:
+            if resolution and not _has_chromium_arg(all_args, ("--window-size",)):
+                all_args.append(
+                    f"--window-size={resolution['width']},{resolution['height']}"
+                )
+            elif (
+                not headless
+                and not _has_chromium_arg(
+                    all_args,
+                    ("--window-size", "--start-maximized", "--kiosk"),
+                )
+            ):
+                all_args.append("--start-maximized")
+        if devtools:
+            all_args.append("--auto-open-devtools-for-tabs")
+        CommonUtil.ExecLog(sModuleInfo, f"Using remote debugging port {unique_port} for session '{page_id}'", 1)
+        if all_args:
+            launch_options["args"] = all_args
         if downloads_path:
             launch_options["downloads_path"] = downloads_path
+        
+        selenium_cdp_supported = True
 
         # Select and launch browser
         if browser_name in ("chrome", "chromium"):
-            browser = playwright_instance.chromium.launch(**launch_options)
+            browser = await playwright_instance.chromium.launch(**launch_options)
         elif browser_name == "firefox":
-            browser = playwright_instance.firefox.launch(**launch_options)
+            selenium_cdp_supported = False
+            browser = await playwright_instance.firefox.launch(**launch_options)
         elif browser_name in ("webkit", "safari"):
-            browser = playwright_instance.webkit.launch(**launch_options)
+            selenium_cdp_supported = False
+            browser = await playwright_instance.webkit.launch(**launch_options)
         elif browser_name in ("edge", "msedge", "microsoft edge"):
             launch_options["channel"] = "msedge"
-            browser = playwright_instance.chromium.launch(**launch_options)
+            browser = await playwright_instance.chromium.launch(**launch_options)
         elif browser_name == "chrome-beta":
             launch_options["channel"] = "chrome-beta"
-            browser = playwright_instance.chromium.launch(**launch_options)
+            browser = await playwright_instance.chromium.launch(**launch_options)
         else:
             CommonUtil.ExecLog(sModuleInfo, f"Unknown browser '{browser_name}', using chromium", 2)
-            browser = playwright_instance.chromium.launch(**launch_options)
+            browser = await playwright_instance.chromium.launch(**launch_options)
 
-        # Context options
-        context_options = {"viewport": viewport}
+        # Context options. Headed Chromium sessions use the real browser window
+        # size so attached Selenium code observes Selenium-like layout behavior.
+        if selenium_cdp_supported and not headless:
+            context_options = {"no_viewport": True, "accept_downloads": True}
+        else:
+            context_options = {"viewport": viewport, "accept_downloads": True}
         if record_video:
             context_options["record_video_dir"] = video_dir or "videos/"
         if locale:
@@ -214,9 +592,9 @@ def Open_Browser(step_data):
             context_options["color_scheme"] = color_scheme
 
         # Create context and page
-        context = browser.new_context(**context_options)
+        context = await browser.new_context(**context_options)
         context.set_default_timeout(timeout)
-        current_page = context.new_page()
+        current_page = await context.new_page()
         current_page_id = page_id
 
         # Store in details
@@ -225,11 +603,12 @@ def Open_Browser(step_data):
             "context": context,
             "browser": browser,
             "playwright": playwright_instance,
+            "remote-debugging-port": unique_port,
         }
 
         # Navigate if URL provided
         if url:
-            current_page.goto(url, wait_until="domcontentloaded")
+            await current_page.goto(url, wait_until="domcontentloaded")
             CommonUtil.ExecLog(sModuleInfo, f"Navigated to: {url}", 1)
 
         # Save to shared variables for compatibility
@@ -237,6 +616,25 @@ def Open_Browser(step_data):
         sr.Set_Shared_Variables("playwright_context", context)
         sr.Set_Shared_Variables("playwright_browser", browser)
         sr.Set_Shared_Variables("element_wait", timeout / 1000)  # In seconds
+        sr.Set_Shared_Variables("active_web_driver_type", "playwright")
+        
+        # Set screenshot variables for CommonUtil.TakeScreenShot()
+        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
+
+        # Create browser session
+        session = create_browser_session(
+            session_name=page_id,
+            selenium_driver=None,
+            playwright_page=current_page,
+            playwright_browser=browser,
+            playwright_context=context,
+            playwright_frame=None,
+            playwright_instance=playwright_instance,
+            remote_debugging_port=unique_port,
+        )
+        session["selenium_cdp_supported"] = selenium_cdp_supported
+        sr.Set_Shared_Variables("browser_sessions", get_browser_sessions())
+        CommonUtil.ExecLog(sModuleInfo, f"Created browser session: {page_id}", 5)
 
         CommonUtil.ExecLog(sModuleInfo, f"Browser opened successfully (page_id: {page_id})", 1)
         return "passed"
@@ -246,118 +644,501 @@ def Open_Browser(step_data):
 
 
 @logger
-def Go_To_Link(step_data):
+async def Open_Electron_App(step_data):
     """
-    Navigate to a URL.
+    Launch an Electron desktop app via Playwright's Electron API.
 
-    Example:
+    Example - Basic (per-OS binary paths, like Selenium):
         Field               Sub Field           Value
-        go to link          input parameter     https://example.com
-        wait until          optional parameter  networkidle
-        go to link          playwright action   go to link
+        windows             input parameter     C:\\Path\\To\\MyApp.exe
+        mac                 input parameter     /Applications/MyApp.app/Contents/MacOS/MyApp
+        linux               input parameter     /opt/myapp/myapp
+        open electron app   playwright action   open electron app
 
-    wait until options: load, domcontentloaded, networkidle, commit
+    Example - With optional parameters:
+        Field               Sub Field           Value
+        mac                 input parameter     /Applications/MyApp.app/Contents/MacOS/MyApp
+        session             optional parameter  electron_1
+        add argument        optional parameter  --no-sandbox
+        cwd                 optional parameter  /tmp/working_dir
+        timeout             optional parameter  30
+        open electron app   playwright action   open electron app
+
+    Notes:
+        - Only the path matching the current OS is used; other rows are ignored.
+        - The first Electron BrowserWindow becomes the active page, so subsequent
+          element / click / text actions work the same as in a normal browser session.
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
-    global current_page
+    global playwright_instance, browser, context, current_page
+    global current_page_id, playwright_details
 
     try:
-        if current_page is None:
-            CommonUtil.ExecLog(sModuleInfo, "No browser open. Use 'open browser' first.", 3)
+        desktop_app_path = ""
+        driver_id = ""
+        args = []
+        cwd = None
+        env_vars = {}
+        timeout = None
+        record_video = False
+        video_dir = None
+
+        for left, mid, right in step_data:
+            left_compact = left.replace(" ", "").replace("_", "").replace("-", "").lower()
+            mid_l = mid.strip().lower()
+            right_v = right.strip()
+
+            if "windows" in left_compact and platform.system() == "Windows":
+                desktop_app_path = right_v
+            elif "mac" in left_compact and platform.system() == "Darwin":
+                desktop_app_path = right_v
+            elif "linux" in left_compact and platform.system() == "Linux":
+                desktop_app_path = right_v
+            elif left_compact == "driverid":
+                driver_id = right_v
+            elif left_compact == "session" and mid_l == "optional parameter":
+                driver_id = right_v
+            elif mid_l == "optional parameter":
+                if left_compact in ("addargument", "arg", "argument"):
+                    args.append(right_v)
+                elif left_compact == "cwd":
+                    cwd = right_v
+                elif left_compact == "env":
+                    # Format: KEY=VALUE
+                    if "=" in right_v:
+                        k, v = right_v.split("=", 1)
+                        env_vars[k.strip()] = v.strip()
+                elif left_compact == "timeout":
+                    try:
+                        timeout = int(float(right_v) * 1000)
+                    except ValueError:
+                        pass
+                elif left_compact == "recordvideo":
+                    record_video = right_v.lower() in ("true", "yes", "1")
+                elif left_compact == "videodir":
+                    video_dir = right_v
+
+        if not desktop_app_path:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"You did not provide an Electron app path for {platform.system()} OS",
+                3,
+            )
             return "zeuz_failed"
 
+        if not driver_id:
+            driver_id = "default"
+
+        desktop_app_path = CommonUtil.path_parser(desktop_app_path)
+
+        # Reserve a debug port for the session even though Playwright drives Electron via CDP automatically.
+        electron_port = get_debug_port(driver_id or "electron", start=9230, stop=9320)
+
+        launch_options = {"executable_path": desktop_app_path}
+        if args:
+            launch_options["args"] = args
+        if cwd:
+            launch_options["cwd"] = cwd
+        if env_vars:
+            launch_options["env"] = env_vars
+        if timeout:
+            launch_options["timeout"] = timeout
+        if record_video:
+            launch_options["record_video_dir"] = video_dir or "videos/"
+
+        playwright_instance = await async_playwright().start()
+        try:
+            electron_app = await playwright_instance._electron.launch(**launch_options)
+        except Exception:
+            return CommonUtil.Exception_Handler(sys.exc_info())
+
+        try:
+            current_page = await electron_app.first_window()
+        except Exception:
+            # Some Electron apps create no visible BrowserWindow at startup.
+            current_page = None
+
+        # In Electron there is no BrowserContext we own - bind the app object in its place so
+        # downstream session-aware code keeps working.
+        context = electron_app.context if hasattr(electron_app, "context") else None
+        browser = electron_app  # `browser` slot holds the launched app for teardown.
+        current_page_id = driver_id
+
+        playwright_details[driver_id] = {
+            "page": current_page,
+            "context": context,
+            "browser": electron_app,
+            "playwright": playwright_instance,
+            "remote-debugging-port": electron_port,
+        }
+
+        sr.Set_Shared_Variables("playwright_page", current_page)
+        sr.Set_Shared_Variables("playwright_context", context)
+        sr.Set_Shared_Variables("playwright_browser", electron_app)
+        sr.Set_Shared_Variables("active_web_driver_type", "playwright")
+        if timeout:
+            sr.Set_Shared_Variables("element_wait", timeout / 1000)
+        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
+
+        create_browser_session(
+            session_name=driver_id,
+            playwright_page=current_page,
+            playwright_browser=electron_app,
+            playwright_context=context,
+            playwright_frame=None,
+            playwright_instance=playwright_instance,
+            remote_debugging_port=electron_port,
+        )
+
+        CommonUtil.ExecLog(sModuleInfo, "Started Electron App", 1)
+        return "passed"
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+@logger
+async def Go_To_Link(step_data):
+    """
+    Navigate to a URL (and open browser if not already open).
+
+    Example 1 - Basic:
+        Field                       Sub Field           Value
+        go to link                  input parameter     https://example.com
+        go to link                  playwright action   go to link
+
+    Example 2 - Selenium-compatible options:
+        Field                       Sub Field           Value
+        go to link                  input parameter     https://example.com
+        wait time to appear element optional parameter  20
+        wait time to page load      optional parameter  60
+        resolution                  optional parameter  1920,1080
+        wait until                  optional parameter  networkidle
+        go to link                  playwright action   go to link
+
+    Options:
+        - wait until (load | domcontentloaded | networkidle | commit)
+        - timeout / wait time to page load: page load timeout in seconds
+        - wait for element / wait time to appear element: element wait timeout
+          (seconds) saved to the "element_wait" shared variable so subsequent
+          element lookups use it
+        - resolution: WIDTHxHEIGHT or WIDTH,HEIGHT (applied to the current page)
+        - session: reuse or create a named browser session
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        # Parse session parameter first
+        session_name = None
+        for left, mid, right in step_data:
+            left_l = left.strip().lower()
+            mid_l = mid.strip().lower()
+            right_v = right.strip()
+
+            if mid_l == "optional parameter" and _compact(left_l) in ("session", "driverid", "driver", "drivertag", "pageid"):
+                session_name = right_v
+                break
+
+        # Check if session exists and use it
+        if session_name:
+            existing_session = get_browser_session(session_name)
+            if existing_session and await _ensure_playwright_session(session_name, existing_session) not in failed_tag_list:
+                CommonUtil.ExecLog(sModuleInfo, f"Using existing browser session: {session_name}", 1)
+            else:
+                # Session doesn't exist, open new browser with session name
+                CommonUtil.ExecLog(sModuleInfo, f"Session '{session_name}' not found. Opening new browser.", 2)
+
+                # Add session parameter to step_data for Open_Browser
+                step_data_with_session = step_data.copy()
+                if not any(left.strip().lower() == "session" and mid.strip().lower() == "optional parameter" for left, mid, right in step_data_with_session):
+                    step_data_with_session.append(("session", "optional parameter", session_name))
+
+                result = await Open_Browser(step_data_with_session)
+                if result == "zeuz_failed":
+                    CommonUtil.ExecLog(sModuleInfo, "Failed to open browser for new session", 3)
+                    return "zeuz_failed"
+
+        elif current_page is None:
+            default_session = get_browser_session("default")
+            if default_session and default_session.get("selenium_driver"):
+                result = await _ensure_playwright_session("default", default_session)
+                if result in failed_tag_list:
+                    return result
+            else:
+                # No session specified and no browser open
+                CommonUtil.ExecLog(sModuleInfo, "No browser open. Opening browser with default settings.", 2)
+                result = await Open_Browser(step_data)
+                if result == "zeuz_failed":
+                    CommonUtil.ExecLog(sModuleInfo, "Failed to open browser automatically", 3)
+                    return "zeuz_failed"
+
         url = None
         wait_until = "domcontentloaded"
         timeout = None
+        element_wait_sec = None
+        window_size_x = None
+        window_size_y = None
 
         for left, mid, right in step_data:
-            left_l = left.strip().lower()
+            left_raw = left.strip()
+            left_l = left_raw.lower()
+            left_compact = left_l.replace(" ", "").replace("_", "").replace("-", "")
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "input parameter":
-                if left_l in ("go to link", "url", "link"):
-                    url = right_v
+            if left_l in ("go to link", "url", "link"):
+                url = right_v
             elif mid_l == "optional parameter":
+                if _compact(left_l) in ("session", "driverid", "driver", "drivertag", "pageid"):
+                    continue
                 if left_l in ("wait until", "wait_until", "waituntil"):
                     wait_until = right_v.lower()
-                elif left_l == "timeout":
-                    timeout = int(float(right_v) * 1000)
+                elif left_compact in ("timeout", "waittimetopageload", "pageloadtimeout"):
+                    try:
+                        timeout = int(float(right_v) * 1000)
+                    except ValueError:
+                        pass
+                elif left_compact in ("waittimetoappearelement", "waitforelement", "elementwait"):
+                    try:
+                        element_wait_sec = float(right_v)
+                    except ValueError:
+                        pass
+                elif left_l == "resolution":
+                    try:
+                        parts = right_v.replace("x", ",").split(",")
+                        window_size_x = int(parts[0].strip())
+                        window_size_y = int(parts[1].strip())
+                    except (ValueError, IndexError):
+                        pass
 
         if not url:
             CommonUtil.ExecLog(sModuleInfo, "No URL provided", 3)
             return "zeuz_failed"
 
+        if element_wait_sec is not None:
+            sr.Set_Shared_Variables("element_wait", element_wait_sec)
+
+        if timeout:
+            try:
+                current_page.set_default_navigation_timeout(timeout)
+                current_page.set_default_timeout(timeout)
+            except Exception:
+                pass
+
+        if window_size_x and window_size_y:
+            try:
+                await current_page.set_viewport_size({"width": window_size_x, "height": window_size_y})
+            except Exception:
+                pass
+
         goto_options = {"wait_until": wait_until}
         if timeout:
             goto_options["timeout"] = timeout
 
-        current_page.goto(url, **goto_options)
-        CommonUtil.ExecLog(sModuleInfo, f"Navigated to: {url}", 1)
+        try:
+            await current_page.goto(url, **goto_options)
+        except PlaywrightTimeoutError:
+            CommonUtil.ExecLog(sModuleInfo, "Maximum page load time reached. Loading and proceeding", 2)
+
+        # Reset frame context when navigating to a new URL
+        sr.Set_Shared_Variables("playwright_frame", None)
+        _save_current_playwright_frame(None)
+
+        CommonUtil.ExecLog(sModuleInfo, f"Successfully opened your link: {url}", 1)
         return "passed"
 
     except Exception:
-        return CommonUtil.Exception_Handler(sys.exc_info())
+        return CommonUtil.Exception_Handler(sys.exc_info(), None, "failed to open your link")
 
 
 @logger
-def Tear_Down_Playwright(step_data=None):
+async def Go_To_Link_V2(step_data):
+    """Selenium-compatible v2 navigation wrapper."""
+
+    translated = []
+    for left, mid, right in step_data:
+        left_l = left.strip().lower()
+        if left_l == "go to link v2":
+            translated.append(("go to link", mid, right))
+        elif left_l == "driver tag":
+            translated.append(("session", "optional parameter", right))
+        elif left_l == "page load timeout":
+            translated.append(("wait time to page load", "optional parameter", right))
+        elif left_l == "wait for element":
+            translated.append(("wait time to appear element", "optional parameter", right))
+        elif left_l == "page load strategy":
+            translated.append(("wait until", "optional parameter", right))
+        else:
+            translated.append((left, mid, right))
+    return await Go_To_Link(translated)
+
+
+@logger
+async def Tear_Down_Playwright(step_data=None):
     """
     Close browser and clean up Playwright resources.
 
     Example:
         Field               Sub Field           Value
         tear down           playwright action   tear down
+        
+    Example with session:
+        Field               Sub Field           Value
+        session             optional parameter  my_session
+        tear down           playwright action   tear down
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global playwright_instance, browser, context, current_page
     global playwright_details, current_page_id
 
     try:
-        # Close all tracked pages/contexts
-        for page_id, details in playwright_details.items():
+        # Parse session parameter
+        session_name = None
+        if step_data:
+            for left, mid, right in step_data:
+                left_l = left.strip().lower()
+                mid_l = mid.strip().lower()
+                right_v = right.strip()
+                
+                if mid_l == "optional parameter" and _compact(left_l) in ("session", "driverid", "driver", "drivertag", "pageid"):
+                    session_name = right_v
+                    break
+        
+        # Handle session-specific teardown
+        if session_name:
+            existing_session = get_browser_session(session_name)
+            
+            if existing_session and existing_session.get("playwright_page"):
+                try:
+                    # Close the specific session's page and context
+                    session_page = existing_session["playwright_page"]
+                    session_context = existing_session["playwright_context"]
+                    session_browser = existing_session["playwright_browser"]
+                    session_playwright = existing_session.get("playwright_instance")
+                    session_selenium = existing_session.get("selenium_driver")
+                    
+                    if session_page:
+                        await session_page.close()
+                    if session_context:
+                        await session_context.close()
+                    if session_browser:
+                        await session_browser.close()
+                    if session_playwright:
+                        await session_playwright.stop()
+                    if session_selenium and session_selenium != "zeuz_failed":
+                        try:
+                            session_selenium.quit()
+                        except Exception:
+                            pass
+                    
+                    CommonUtil.ExecLog(sModuleInfo, f"Teared down session '{session_name}'", 1)
+                except Exception:
+                    errMsg = f"Unable to tear down session '{session_name}'. may already been killed"
+                    CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
+                
+                remove_browser_session(session_name)
+                
+                # Remove from playwright_details if present
+                if session_name in playwright_details:
+                    del playwright_details[session_name]
+                
+                # If this was the current session, clear globals
+                if current_page_id == session_name:
+                    current_page = None
+                    context = None
+                    browser = None
+                    current_page_id = None
+                    
+                    # Try to switch to another available session
+                    if playwright_details:
+                        for page_id, details in playwright_details.items():
+                            current_page = details["page"]
+                            context = details["context"]
+                            browser = details["browser"]
+                            current_page_id = page_id
+                            
+                            # Update shared variables
+                            sr.Set_Shared_Variables("playwright_page", current_page)
+                            sr.Set_Shared_Variables("playwright_context", context)
+                            sr.Set_Shared_Variables("playwright_browser", browser)
+                            
+                            CommonUtil.ExecLog(sModuleInfo, f"Switched to session '{page_id}'", 1)
+                            break
+            else:
+                CommonUtil.ExecLog(sModuleInfo, f"Session '{session_name}' not found. Nothing to tear down.", 2)
+            return "passed"
+        
+        # Handle full teardown (backwards compatibility)
+        else:
+            for session in get_browser_sessions().values():
+                if not (isinstance(session, dict) and session.get("playwright_page")):
+                    continue
+                try:
+                    if session.get("selenium_driver") and session.get("selenium_driver") != "zeuz_failed":
+                        session["selenium_driver"].quit()
+                except Exception:
+                    pass
+
+            # Close all tracked pages/contexts
+            for page_id, details in list(playwright_details.items()):
+                try:
+                    if details.get("page"):
+                        await details["page"].close()
+                    if details.get("context"):
+                        await details["context"].close()
+                    if details.get("browser"):
+                        await details["browser"].close()
+                    if details.get("playwright"):
+                        await details["playwright"].stop()
+                except Exception:
+                    pass
+
+        # Close main instances
             try:
-                if details.get("page"):
-                    details["page"].close()
-                if details.get("context"):
-                    details["context"].close()
+                if current_page and current_page not in [d.get("page") for d in playwright_details.values()]:
+                    await current_page.close()
             except Exception:
                 pass
 
-        # Close main instances
-        try:
-            if current_page and current_page not in [d.get("page") for d in playwright_details.values()]:
-                current_page.close()
-        except Exception:
-            pass
+            try:
+                if context:
+                    await context.close()
+            except Exception:
+                pass
 
-        try:
-            if context:
-                context.close()
-        except Exception:
-            pass
+            try:
+                if browser:
+                    await browser.close()
+            except Exception:
+                pass
 
-        try:
-            if browser:
-                browser.close()
-        except Exception:
-            pass
+            try:
+                if playwright_instance:
+                    await playwright_instance.stop()
+            except Exception:
+                pass
 
-        try:
-            if playwright_instance:
-                playwright_instance.stop()
-        except Exception:
-            pass
+            # Reset all globals
+            current_page = None
+            context = None
+            browser = None
+            playwright_instance = None
+            playwright_details = {}
+            current_page_id = None
+            
+            # Clear Playwright-backed browser sessions without discarding Selenium-only sessions.
+            sessions = get_browser_sessions()
+            sessions = {
+                name: session
+                for name, session in sessions.items()
+                if not (isinstance(session, dict) and session.get("playwright_page"))
+            }
+            sr.Set_Shared_Variables("browser_sessions", sessions)
 
-        # Reset all globals
-        current_page = None
-        context = None
-        browser = None
-        playwright_instance = None
-        playwright_details = {}
-        current_page_id = None
+            CommonUtil.ExecLog(sModuleInfo, "Browser closed successfully", 1)
+            return "passed"
 
-        CommonUtil.ExecLog(sModuleInfo, "Browser closed successfully", 1)
         return "passed"
 
     except Exception:
@@ -365,7 +1146,7 @@ def Tear_Down_Playwright(step_data=None):
 
 
 @logger
-def Switch_Browser(step_data):
+async def Switch_Browser(step_data):
     """
     Switch between multiple browser instances/pages.
 
@@ -375,7 +1156,7 @@ def Switch_Browser(step_data):
         switch browser      playwright action   switch browser
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
-    global current_page, current_page_id, context
+    global current_page, current_page_id, context, browser
 
     try:
         target_id = None
@@ -385,13 +1166,20 @@ def Switch_Browser(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "input parameter":
-                if left_l in ("driver id", "page id", "driver tag"):
+            if mid_l in ("input parameter", "optional parameter"):
+                if _compact(left_l) in ("driverid", "pageid", "drivertag", "session"):
                     target_id = right_v
 
         if not target_id:
-            CommonUtil.ExecLog(sModuleInfo, "No driver/page ID provided", 3)
-            return "zeuz_failed"
+            target_id = "default"
+
+        existing_session = get_browser_session(target_id)
+        if existing_session and existing_session.get("playwright_page"):
+            _set_active_playwright_session(target_id, existing_session)
+            if current_page:
+                await current_page.bring_to_front()
+            CommonUtil.ExecLog(sModuleInfo, f"Switched to page: {target_id}", 1)
+            return "passed"
 
         if target_id not in playwright_details:
             CommonUtil.ExecLog(sModuleInfo, f"Page ID '{target_id}' not found", 3)
@@ -400,12 +1188,17 @@ def Switch_Browser(step_data):
         details = playwright_details[target_id]
         current_page = details["page"]
         context = details["context"]
+        browser = details["browser"]
         current_page_id = target_id
 
-        current_page.bring_to_front()
+        await current_page.bring_to_front()
 
         sr.Set_Shared_Variables("playwright_page", current_page)
         sr.Set_Shared_Variables("playwright_context", context)
+        sr.Set_Shared_Variables("playwright_browser", browser)
+        
+        # Set screenshot variables for CommonUtil.TakeScreenShot()
+        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
 
         CommonUtil.ExecLog(sModuleInfo, f"Switched to page: {target_id}", 1)
         return "passed"
@@ -421,7 +1214,7 @@ def Switch_Browser(step_data):
 #########################
 
 @logger
-def Click_Element(step_data):
+async def Click_Element(step_data, retry=0):
     """
     Click an element.
 
@@ -430,19 +1223,24 @@ def Click_Element(step_data):
         id                  element parameter   submit-btn
         click               playwright action   click
 
-    Example 2 - With options:
+    Example 2 - With JS click (forces click via JS .click()):
         Field               Sub Field           Value
         id                  element parameter   submit-btn
         use js              optional parameter  true
-        offset              optional parameter  10,5
         click               playwright action   click
 
-    Example 3 - Double click:
+    Example 3 - Click at offset (Selenium-compatible: percent from element center):
+        Field               Sub Field           Value
+        id                  element parameter   submit-btn
+        offset              optional parameter  20,30
+        click               playwright action   click
+
+    Example 4 - Double click:
         Field               Sub Field           Value
         id                  element parameter   item
         double click        playwright action   double click
 
-    Example 4 - Right click:
+    Example 5 - Right click:
         Field               Sub Field           Value
         id                  element parameter   item
         right click         playwright action   right click
@@ -451,13 +1249,15 @@ def Click_Element(step_data):
     global current_page
 
     try:
+        # Handle session parameter
+        session_name, current_page, current_page_id, context, browser = await _handle_playwright_session(step_data)
         if current_page is None:
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
         # Parse options
         use_js = False
-        offset = None
+        offset_value = ""
         double_click = False
         right_click = False
         click_count = 1
@@ -470,12 +1270,15 @@ def Click_Element(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
+            # Skip session parameter - already handled above
+            if mid_l == "optional parameter" and left_l == "session":
+                continue
+
             if mid_l == "optional parameter":
                 if left_l == "use js":
                     use_js = right_v.lower() in ("true", "yes", "1")
                 elif left_l == "offset":
-                    parts = right_v.split(",")
-                    offset = {"x": float(parts[0].strip()), "y": float(parts[1].strip())}
+                    offset_value = right_v
                 elif left_l == "click count":
                     click_count = int(right_v)
                 elif left_l == "modifier":
@@ -485,53 +1288,125 @@ def Click_Element(step_data):
                 elif left_l == "timeout":
                     timeout = int(float(right_v) * 1000)
 
-            elif mid_l == "action":
+            elif "action" in mid_l:
                 if "double" in left_l:
                     double_click = True
                 elif "right" in left_l:
                     right_click = True
 
+        action_timeout = timeout if timeout is not None else PlaywrightLocator.Get_Timeout(step_data)
+
         # Get element
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        locator = await PlaywrightLocator.Get_Element(
+            step_data,
+            current_page,
+            frame_locator=_get_frame_locator(),
+            resolve=False,
+        )
         if locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+            CommonUtil.ExecLog(sModuleInfo, "Could not find element", 3)
             return "zeuz_failed"
 
+        # Click using offset (Selenium-compatible: percentage of half element size from center)
+        if offset_value:
+            try:
+                box = await locator.bounding_box(timeout=action_timeout)
+                if not box:
+                    CommonUtil.ExecLog(sModuleInfo, "Cannot determine element bounding box for offset click", 3)
+                    return "zeuz_failed"
+                parts = offset_value.replace(" ", "").split(",")
+                pct_x = float(parts[0])
+                pct_y = float(parts[1])
+                # Selenium-style: percent of half-size from center, anchored at top-left of element
+                offset_x = (box["width"] / 2.0) + (box["width"] / 2.0) * (pct_x / 100.0)
+                offset_y = (box["height"] / 2.0) + (box["height"] / 2.0) * (pct_y / 100.0)
+                click_options = {"position": {"x": offset_x, "y": offset_y}}
+                if modifiers:
+                    click_options["modifiers"] = modifiers
+                if delay:
+                    click_options["delay"] = delay
+                if action_timeout is not None:
+                    click_options["timeout"] = action_timeout
+                if right_click:
+                    click_options["button"] = "right"
+                if double_click:
+                    await locator.dblclick(**click_options)
+                else:
+                    await locator.click(**click_options)
+                CommonUtil.ExecLog(sModuleInfo, "Click on location successful", 1)
+                return "passed"
+            except Exception:
+                return CommonUtil.Exception_Handler(sys.exc_info(), None, "Error clicking location")
+
         # Build click options
         click_options = {}
-        if use_js:
-            click_options["force"] = True
-        if offset:
-            click_options["position"] = offset
         if modifiers:
             click_options["modifiers"] = modifiers
         if delay:
             click_options["delay"] = delay
-        if timeout:
-            click_options["timeout"] = timeout
+        if action_timeout is not None:
+            click_options["timeout"] = action_timeout
         if click_count > 1:
             click_options["click_count"] = click_count
 
         # Perform click
-        if double_click:
-            locator.dblclick(**{k: v for k, v in click_options.items() if k != "click_count"})
-            CommonUtil.ExecLog(sModuleInfo, "Double click performed", 1)
-        elif right_click:
-            click_options["button"] = "right"
-            locator.click(**click_options)
-            CommonUtil.ExecLog(sModuleInfo, "Right click performed", 1)
-        else:
-            locator.click(**click_options)
-            CommonUtil.ExecLog(sModuleInfo, "Click performed", 1)
-
-        return "passed"
-
-    except Exception:
-        return CommonUtil.Exception_Handler(sys.exc_info())
-
+        try:
+            if double_click:
+                await locator.hover(timeout=action_timeout)
+                await locator.dblclick(**{k: v for k, v in click_options.items() if k != "click_count"})
+                CommonUtil.ExecLog(sModuleInfo, "Double click performed", 1)
+            elif right_click:
+                click_options["button"] = "right"
+                await locator.click(**click_options)
+                CommonUtil.ExecLog(sModuleInfo, "Right click performed", 1)
+            elif use_js:
+                await locator.evaluate("el => el.click()", timeout=action_timeout)
+                CommonUtil.ExecLog(sModuleInfo, "Successfully clicked the element via JS", 1)
+            else:
+                await locator.click(**click_options)
+                CommonUtil.ExecLog(sModuleInfo, "Successfully clicked the element", 1)
+            return "passed"
+        except PlaywrightTimeoutError:
+            # Click intercepted or element not actionable - fall back to JS click (matches Selenium behavior)
+            try:
+                await locator.evaluate("el => el.click()", timeout=action_timeout)
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    "Your element is overlapped with another sibling element. Clicked the element successfully by executing JavaScript",
+                    2,
+                )
+                return "passed"
+            except Exception:
+                return CommonUtil.Exception_Handler(sys.exc_info())
+        except PlaywrightError as e:
+            err_msg = str(e).lower()
+            # Stale element: retry up to 5 times with 1s delay
+            if ("stale" in err_msg or "detached" in err_msg) and retry < 5:
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    "Javascript of the element is not fully loaded. Trying again after 1 second delay",
+                    2,
+                )
+                await asyncio.sleep(1)
+                return await Click_Element(step_data, retry + 1)
+            # Try JS click fallback
+            try:
+                await locator.evaluate("el => el.click()", timeout=action_timeout)
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    "Click failed natively; clicked successfully via JavaScript",
+                    2,
+                )
+                return "passed"
+            except Exception:
+                return CommonUtil.Exception_Handler(sys.exc_info())
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
 
 @logger
-def Double_Click_Element(step_data):
+async def Double_Click_Element(step_data):
     """
     Double-click an element.
 
@@ -544,15 +1419,15 @@ def Double_Click_Element(step_data):
     modified_step_data = list(step_data)
     # Ensure the action indicates double click
     for i, (left, mid, right) in enumerate(modified_step_data):
-        if mid.strip().lower() == "action":
+        if "action" in mid.strip().lower():
             modified_step_data[i] = ("double click", mid, right)
             break
 
-    return Click_Element(modified_step_data)
+    return await Click_Element(modified_step_data)
 
 
 @logger
-def Right_Click_Element(step_data):
+async def Right_Click_Element(step_data):
     """
     Right-click (context click) an element.
 
@@ -563,15 +1438,15 @@ def Right_Click_Element(step_data):
     """
     modified_step_data = list(step_data)
     for i, (left, mid, right) in enumerate(modified_step_data):
-        if mid.strip().lower() == "action":
+        if "action" in mid.strip().lower():
             modified_step_data[i] = ("right click", mid, right)
             break
 
-    return Click_Element(modified_step_data)
+    return await Click_Element(modified_step_data)
 
 
 @logger
-def Hover_Over_Element(step_data):
+async def Hover_Over_Element(step_data):
     """
     Hover over an element.
 
@@ -606,7 +1481,14 @@ def Hover_Over_Element(step_data):
                 elif left_l == "timeout":
                     timeout = int(float(right_v) * 1000)
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        action_timeout = timeout if timeout is not None else PlaywrightLocator.Get_Timeout(step_data)
+
+        locator = await PlaywrightLocator.Get_Element(
+            step_data,
+            current_page,
+            frame_locator=_get_frame_locator(),
+            resolve=False,
+        )
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
             return "zeuz_failed"
@@ -616,10 +1498,10 @@ def Hover_Over_Element(step_data):
             hover_options["force"] = True
         if offset:
             hover_options["position"] = offset
-        if timeout:
-            hover_options["timeout"] = timeout
+        if action_timeout is not None:
+            hover_options["timeout"] = action_timeout
 
-        locator.hover(**hover_options)
+        await locator.hover(**hover_options)
         CommonUtil.ExecLog(sModuleInfo, "Hover performed", 1)
         return "passed"
 
@@ -627,6 +1509,65 @@ def Hover_Over_Element(step_data):
         return CommonUtil.Exception_Handler(sys.exc_info())
 
 
+@logger
+async def Click_and_Download(data_set):
+    """Click an element and wait for a browser download."""
+
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        if current_page is None:
+            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+            return "zeuz_failed"
+
+        wait_download = 20
+        target_path = ""
+        click_dataset = []
+        for left, mid, right in data_set:
+            left_c = _compact(left)
+            mid_l = mid.strip().lower()
+            if left_c == "waitfordownload":
+                wait_download = float(right.strip())
+            elif left_c in ("folderpath", "directory", "filepath", "file", "folder") and mid_l == "optional parameter":
+                target_path = CommonUtil.path_parser(right.strip())
+            elif left_c == "automatefirefoxsavewindow":
+                continue
+            else:
+                click_dataset.append((left, mid, right))
+
+        locator = await PlaywrightLocator.Get_Element(
+            click_dataset,
+            current_page,
+            frame_locator=_get_frame_locator(),
+            resolve=False,
+        )
+        if locator == "zeuz_failed":
+            CommonUtil.ExecLog(sModuleInfo, "Unable to locate your element with given data.", 3)
+            return "zeuz_failed"
+
+        CommonUtil.ExecLog(sModuleInfo, f"Download started. Will wait max {wait_download} seconds...", 1)
+        async with current_page.expect_download(timeout=int(wait_download * 1000)) as download_info:
+            await locator.click(timeout=PlaywrightLocator.Get_Timeout(click_dataset))
+        download = await download_info.value
+
+        if target_path:
+            parsed_path = Path(target_path)
+            if parsed_path.suffix:
+                parsed_path.parent.mkdir(parents=True, exist_ok=True)
+                save_path = parsed_path
+            else:
+                parsed_path.mkdir(parents=True, exist_ok=True)
+                save_path = parsed_path / download.suggested_filename
+        else:
+            save_path = Path(_download_folder()) / download.suggested_filename
+        await download.save_as(str(save_path))
+        CommonUtil.ExecLog(sModuleInfo, f"File downloaded to '{save_path}'", 1)
+        return "passed"
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
 #########################
 #                       #
 #    Text Input         #
@@ -634,7 +1575,7 @@ def Hover_Over_Element(step_data):
 #########################
 
 @logger
-def Enter_Text_In_Text_Box(step_data):
+async def Enter_Text_In_Text_Box(step_data):
     """
     Enter text in a text field.
 
@@ -644,7 +1585,7 @@ def Enter_Text_In_Text_Box(step_data):
         text                action              my_username
         text                playwright action   text
 
-    Example 2 - With options:
+    Example 2 - With options (Selenium-compatible):
         Field               Sub Field           Value
         id                  element parameter   username
         text                action              my_username
@@ -657,6 +1598,8 @@ def Enter_Text_In_Text_Box(step_data):
     global current_page
 
     try:
+        # Handle session parameter
+        session_name, current_page, current_page_id, context, browser = await _handle_playwright_session(step_data)
         if current_page is None:
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
@@ -671,7 +1614,11 @@ def Enter_Text_In_Text_Box(step_data):
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
 
-            if mid_l == "action":
+            # Skip session parameter - already handled above
+            if mid_l == "optional parameter" and left_l == "session":
+                continue
+
+            if "action" in mid_l:
                 text_value = right  # Don't strip - preserve whitespace
             elif mid_l == "optional parameter":
                 if left_l == "delay":
@@ -683,44 +1630,91 @@ def Enter_Text_In_Text_Box(step_data):
                 elif left_l == "timeout":
                     timeout = int(float(right.strip()) * 1000)
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        action_timeout = timeout if timeout is not None else PlaywrightLocator.Get_Timeout(step_data)
+
+        locator = await PlaywrightLocator.Get_Element(
+            step_data,
+            current_page,
+            frame_locator=_get_frame_locator(),
+            resolve=False,
+        )
         if locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+            CommonUtil.ExecLog(sModuleInfo, "Unable to locate your element with given data.", 3)
             return "zeuz_failed"
 
         # Enter text based on options
         if use_js:
-            # Use JavaScript to set value directly
-            locator.evaluate(f"el => {{ el.value = `{text_value}`; }}")
-            # Trigger events
-            locator.dispatch_event("input")
-            locator.dispatch_event("change")
-            CommonUtil.ExecLog(sModuleInfo, f"Text entered via JS: {text_value[:50]}{'...' if len(text_value) > 50 else ''}", 1)
-        elif clear:
-            # fill() clears and sets value - recommended approach
-            fill_options = {}
-            if timeout:
-                fill_options["timeout"] = timeout
-            locator.fill(text_value, **fill_options)
-            CommonUtil.ExecLog(sModuleInfo, f"Text filled: {text_value[:50]}{'...' if len(text_value) > 50 else ''}", 1)
+            # JS mode mirrors Selenium: click, set value, dispatch input/change events, click again.
+            try:
+                await locator.evaluate("el => el.click()", timeout=action_timeout)
+            except Exception:
+                CommonUtil.ExecLog(sModuleInfo, "Entering text without clicking the element", 2)
+            # Use JS template-literal so embedded quotes/newlines are preserved (matches Selenium).
+            escaped = text_value.replace("\\", "\\\\").replace("`", "\\`").replace("${", "\\${")
+            await locator.evaluate(f"el => {{ el.value = `{escaped}`; }}", timeout=action_timeout)
+            await locator.dispatch_event("input", timeout=action_timeout)
+            await locator.dispatch_event("change", timeout=action_timeout)
+            try:
+                await locator.evaluate("el => el.click()", timeout=action_timeout)
+            except Exception:
+                pass
+            CommonUtil.ExecLog(sModuleInfo, f"Successfully set the value of to text to: {text_value}", 1)
+            return "passed"
+
+        # Non-JS path: click first to focus (best-effort), clear if requested, then type/fill.
+        try:
+            await locator.click(timeout=action_timeout)
+        except Exception:
+            CommonUtil.ExecLog(sModuleInfo, "Entering text without clicking the element", 2)
+
+        if clear:
+            try:
+                # Select-all + delete pattern matches Selenium clear logic across platforms.
+                if sys.platform == "darwin":
+                    await locator.press("Meta+A", timeout=action_timeout)
+                else:
+                    await locator.press("Control+A", timeout=action_timeout)
+                await locator.press("Delete", timeout=action_timeout)
+            except Exception:
+                pass
+            try:
+                # fill() always clears first; also handles inputs where Select-All didn't apply.
+                fill_options = {}
+                if action_timeout is not None:
+                    fill_options["timeout"] = action_timeout
+                if delay == 0:
+                    await locator.fill(text_value, **fill_options)
+                else:
+                    # Caller wants per-keystroke delay -> type after clearing.
+                    type_options = {"delay": int(delay * 1000)}
+                    if action_timeout is not None:
+                        type_options["timeout"] = action_timeout
+                    await locator.type(text_value, **type_options)
+            except Exception:
+                return CommonUtil.Exception_Handler(sys.exc_info())
         else:
-            # type() appends to existing value
             type_options = {}
             if delay > 0:
                 type_options["delay"] = int(delay * 1000)
-            if timeout:
-                type_options["timeout"] = timeout
-            locator.type(text_value, **type_options)
-            CommonUtil.ExecLog(sModuleInfo, f"Text typed: {text_value[:50]}{'...' if len(text_value) > 50 else ''}", 1)
+            if action_timeout is not None:
+                type_options["timeout"] = action_timeout
+            await locator.type(text_value, **type_options)
 
+        # Some text fields become unclickable after entering text - best-effort click.
+        try:
+            await locator.click(timeout=action_timeout)
+        except Exception:
+            pass
+
+        CommonUtil.ExecLog(sModuleInfo, f"Successfully set the value of to text to: {text_value}", 1)
         return "passed"
 
     except Exception:
-        return CommonUtil.Exception_Handler(sys.exc_info())
+        return CommonUtil.Exception_Handler(sys.exc_info(), None, "Could not select/click your element.")
 
 
 @logger
-def Keystroke_For_Element(step_data):
+async def Keystroke_For_Element(step_data):
     """
     Send keystrokes to an element or the page.
 
@@ -764,7 +1758,7 @@ def Keystroke_For_Element(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "action":
+            if "action" in mid_l:
                 if left_l == "keystroke keys":
                     keystroke_type = "keys"
                     keystroke_value = right_v
@@ -795,8 +1789,13 @@ def Keystroke_For_Element(step_data):
         key_map = {
             "CTRL": "Control",
             "CONTROL": "Control",
+            "CMD": "Meta",
+            "COMMAND": "Meta",
             "ALT": "Alt",
             "SHIFT": "Shift",
+            "PLUS": "+",
+            "MINUS": "-",
+            "DASH": "-",
             "ENTER": "Enter",
             "RETURN": "Enter",
             "TAB": "Tab",
@@ -806,39 +1805,83 @@ def Keystroke_For_Element(step_data):
             "DELETE": "Delete",
             "SPACE": " ",
             "UP": "ArrowUp",
+            "ARROWUP": "ArrowUp",
             "DOWN": "ArrowDown",
+            "ARROWDOWN": "ArrowDown",
             "LEFT": "ArrowLeft",
+            "ARROWLEFT": "ArrowLeft",
             "RIGHT": "ArrowRight",
+            "ARROWRIGHT": "ArrowRight",
             "HOME": "Home",
             "END": "End",
             "PAGEUP": "PageUp",
             "PAGEDOWN": "PageDown",
+            "INSERT": "Insert",
         }
 
         if keystroke_type == "keys":
+            normalized_keystroke = keystroke_value.replace(" ", "").replace("_", "").lower()
+            if normalized_keystroke in ("ctrl+v", "control+v", "ctrlv", "controlv", "cmd+v", "cmdv", "command+v", "commandv"):
+                try:
+                    import pyperclip
+
+                    paste_text = pyperclip.paste()
+                    if has_element:
+                        locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
+                        if locator == "zeuz_failed":
+                            CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+                            return "zeuz_failed"
+                        await locator.evaluate("""(el, text) => {
+                            el.focus();
+                            const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set;
+                            if (setter) setter.call(el, text); else el.value = text;
+                            el.dispatchEvent(new Event('input', { bubbles: true }));
+                            el.dispatchEvent(new Event('change', { bubbles: true }));
+                        }""", paste_text)
+                    else:
+                        await current_page.evaluate("""text => {
+                            const el = document.activeElement;
+                            if (el && 'value' in el) {
+                                const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set;
+                                if (setter) setter.call(el, text); else el.value = text;
+                                el.dispatchEvent(new Event('input', { bubbles: true }));
+                                el.dispatchEvent(new Event('change', { bubbles: true }));
+                            }
+                        }""", paste_text)
+                    CommonUtil.ExecLog(sModuleInfo, "Paste successfully executed via JavaScript with events", 1)
+                    return "passed"
+                except Exception:
+                    CommonUtil.ExecLog(sModuleInfo, "JavaScript paste execution failed. Trying keypress.", 2)
+
             # Convert key names
-            key = keystroke_value.upper()
-            if "+" in key:
+            def to_playwright_key(token):
+                token = token.strip()
+                normalized_token = token.replace(" ", "").replace("_", "").replace("-", "").upper()
+                if normalized_token in key_map:
+                    return key_map[normalized_token]
+                return token if len(token) == 1 else token.capitalize()
+
+            if "+" in keystroke_value:
                 # Key combination like Ctrl+A
-                parts = key.split("+")
-                converted = [key_map.get(p.strip(), p.strip().capitalize()) for p in parts]
+                parts = keystroke_value.split("+")
+                converted = [to_playwright_key(p) for p in parts]
                 key = "+".join(converted)
             else:
-                key = key_map.get(key, keystroke_value)
+                key = to_playwright_key(keystroke_value)
 
             if has_element:
-                locator = PlaywrightLocator.Get_Element(step_data, current_page)
+                locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
                 if locator == "zeuz_failed":
                     CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
                     return "zeuz_failed"
 
                 for _ in range(key_count):
-                    locator.press(key)
+                    await locator.press(key)
                     if delay > 0:
                         time.sleep(delay)
             else:
                 for _ in range(key_count):
-                    current_page.keyboard.press(key)
+                    await current_page.keyboard.press(key)
                     if delay > 0:
                         time.sleep(delay)
 
@@ -850,13 +1893,13 @@ def Keystroke_For_Element(step_data):
                 type_options["delay"] = int(delay * 1000)
 
             if has_element:
-                locator = PlaywrightLocator.Get_Element(step_data, current_page)
+                locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
                 if locator == "zeuz_failed":
                     CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
                     return "zeuz_failed"
-                locator.type(keystroke_value, **type_options)
+                await locator.type(keystroke_value, **type_options)
             else:
-                current_page.keyboard.type(keystroke_value, **type_options)
+                await current_page.keyboard.type(keystroke_value, **type_options)
 
             CommonUtil.ExecLog(sModuleInfo, f"Typed chars: {keystroke_value[:50]}{'...' if len(keystroke_value) > 50 else ''}", 1)
 
@@ -873,7 +1916,7 @@ def Keystroke_For_Element(step_data):
 #########################
 
 @logger
-def Validate_Text(step_data):
+async def Validate_Text(step_data):
     """
     Validate that an element contains expected text.
 
@@ -906,45 +1949,50 @@ def Validate_Text(step_data):
         expected_text = ""
         partial_match = False
         case_insensitive = False
-        timeout = None
 
         for left, mid, right in step_data:
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "action":
+            if "action" in mid_l:
                 if left_l.startswith("**"):
                     partial_match = True
                     case_insensitive = True
                 elif left_l.startswith("*"):
                     partial_match = True
+                elif "partial" in left_l:
+                    partial_match = True
                 expected_text = right_v
 
             elif mid_l == "optional parameter":
-                if left_l == "timeout":
-                    timeout = int(float(right_v) * 1000)
+                if left_l == "ignore case":
+                    case_insensitive = _truthy(right_v)
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
             return "zeuz_failed"
 
-        # Get actual text
-        actual_text = locator.text_content() or ""
+        # Get visible text, matching Selenium Element.text behavior more closely.
+        try:
+            actual_text = await locator.inner_text() or ""
+        except Exception:
+            actual_text = await locator.text_content() or ""
+        actual_lines = [line for line in actual_text.split("\n") if line != ""]
 
         # Compare
         match = False
         if case_insensitive:
             if partial_match:
-                match = expected_text.lower() in actual_text.lower()
+                match = any(expected_text.lower() in line.lower() for line in actual_lines)
             else:
-                match = expected_text.lower() == actual_text.lower()
+                match = expected_text.lower() in [line.lower() for line in actual_lines]
         else:
             if partial_match:
-                match = expected_text in actual_text
+                match = any(expected_text in line for line in actual_lines)
             else:
-                match = expected_text == actual_text
+                match = expected_text in actual_lines
 
         if match:
             CommonUtil.ExecLog(sModuleInfo, f"Text validation passed: '{expected_text}'", 1)
@@ -952,7 +2000,7 @@ def Validate_Text(step_data):
         else:
             CommonUtil.ExecLog(
                 sModuleInfo,
-                f"Text validation failed.\nExpected: '{expected_text}'\nActual: '{actual_text}'",
+                f"Text validation failed.\nExpected: '{expected_text}'\nActual: '{actual_lines}'",
                 3
             )
             return "zeuz_failed"
@@ -962,16 +2010,24 @@ def Validate_Text(step_data):
 
 
 @logger
-def if_element_exists(step_data):
+async def if_element_exists(step_data):
     """
-    Check if an element exists on the page.
+    Check whether an element exists (true/false).
 
-    Example:
+    Selenium-compatible form (writes the result to a shared variable, always returns "passed"):
+        Field               Sub Field           Value
+        id                  element parameter   optional-element
+        if element exists   playwright action   true=my_flag
+
+        - If found: shared variable my_flag is set to "true"
+        - If not found: shared variable my_flag is set to "false"
+
+    Plain form (no save):
         Field               Sub Field           Value
         id                  element parameter   optional-element
         if element exists   playwright action   if element exists
 
-    Returns "passed" if element exists, "zeuz_failed" if not.
+        - Returns "passed" if found, "zeuz_failed" if not.
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global current_page
@@ -981,43 +2037,73 @@ def if_element_exists(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
+        variable_name = ""
+        value = ""
         timeout = 1000  # Short timeout for existence check
+
         for left, mid, right in step_data:
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "optional parameter" and left_l == "timeout":
+            if "action" in mid_l and "=" in right_v:
+                try:
+                    value_part, var_part = right_v.split("=", 1)
+                    value = value_part.strip()
+                    variable_name = var_part.strip()
+                except ValueError:
+                    pass
+            elif mid_l == "optional parameter" and left_l == "timeout":
                 timeout = int(float(right_v) * 1000)
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page, element_wait=timeout/1000)
+        locator = await PlaywrightLocator.Get_Element(
+            step_data,
+            current_page,
+            element_wait=timeout / 1000,
+            frame_locator=_get_frame_locator(),
+        )
 
-        if locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Element does not exist", 1)
-            return "zeuz_failed"
+        found = False
+        if locator != "zeuz_failed":
+            try:
+                if await locator.count() > 0:
+                    found = True
+            except Exception:
+                found = False
 
-        try:
-            count = locator.count()
-            if count > 0:
-                CommonUtil.ExecLog(sModuleInfo, f"Element exists ({count} found)", 1)
-                return "passed"
-            else:
-                CommonUtil.ExecLog(sModuleInfo, "Element does not exist", 1)
-                return "zeuz_failed"
-        except Exception:
-            CommonUtil.ExecLog(sModuleInfo, "Element does not exist", 1)
-            return "zeuz_failed"
+        if variable_name:
+            # Selenium-compatible: always returns "passed"; the truthiness lives in the variable.
+            sr.Set_Shared_Variables(variable_name, value if found else "false")
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Element {'found' if found else 'not found'} - saved '{value if found else 'false'}' to '{variable_name}'",
+                1,
+            )
+            return "passed"
+
+        if found:
+            CommonUtil.ExecLog(sModuleInfo, "Element exists", 1)
+            return "passed"
+        CommonUtil.ExecLog(sModuleInfo, "Element does not exist", 1)
+        return "zeuz_failed"
 
     except Exception:
-        return CommonUtil.Exception_Handler(sys.exc_info())
+        errMsg = "Failed to parse data/locate element. Data format: variableName = value"
+        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
 
 
 @logger
-def Save_Attribute(step_data):
+async def Save_Attribute(step_data):
     """
     Save an element's attribute value to a shared variable.
 
-    Example:
+    Selenium-compatible form (recommended):
+        Field               Sub Field           Value
+        id                  element parameter   my-link
+        href                save parameter      my_variable
+        save attribute      playwright action   save attribute
+
+    Alternative form (attribute via input parameter):
         Field               Sub Field           Value
         id                  element parameter   my-link
         href                input parameter     attribute_name
@@ -1025,13 +2111,15 @@ def Save_Attribute(step_data):
         save attribute      playwright action   save attribute
 
     Special attribute names:
-        - text: Get text content
-        - innertext: Get inner text
-        - innerhtml: Get inner HTML
-        - outerhtml: Get outer HTML
-        - value: Get input value
-        - checked: Get checkbox state
-        - selected: Get select option state
+        - text:       text content (Selenium .text)
+        - tag:        tag name (Selenium .tag_name)
+        - checked:    checkbox/radio selected state
+        - innertext:  inner text
+        - innerhtml:  inner HTML
+        - outerhtml:  outer HTML
+        - value:      input value
+        - selected:   <option> selected state
+        - visible / enabled / disabled
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global current_page
@@ -1041,58 +2129,82 @@ def Save_Attribute(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
-        attribute_name = None
-        save_variable = None
+        attribute_name = None  # Attribute to read (e.g. "text", "href")
+        save_variable = None   # Shared variable to write
+        # Build a locator-only data set by excluding the save row (mirrors Selenium).
+        new_ds = []
 
         for left, mid, right in step_data:
-            left_l = left.strip().lower()
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "input parameter":
-                attribute_name = left.strip()  # Keep original case
-            elif mid_l == "save parameter":
-                save_variable = left.strip()
+            if mid_l == "save parameter":
+                # Selenium-style: left = attribute, right = variable name.
+                # Playwright legacy style: left = variable, right = "ignore".
+                if right_v and right_v.lower() not in ("ignore", "n/a", "na", ""):
+                    save_variable = right_v
+                    if not attribute_name:
+                        attribute_name = left.strip()
+                else:
+                    save_variable = left.strip()
+            elif mid_l == "input parameter":
+                # Legacy Playwright style: attribute name lives in input parameter
+                attribute_name = left.strip()
+            else:
+                new_ds.append((left, mid, right))
 
-        if not attribute_name:
-            CommonUtil.ExecLog(sModuleInfo, "No attribute name specified", 3)
+        if not save_variable:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                "Variable name should be mentioned. Example: (text, save parameter, var_name)",
+                3,
+            )
             return "zeuz_failed"
 
-        if not save_variable:
-            CommonUtil.ExecLog(sModuleInfo, "No save variable specified", 3)
+        if not attribute_name:
+            CommonUtil.ExecLog(sModuleInfo, "No attribute name specified", 3)
             return "zeuz_failed"
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        locator = await PlaywrightLocator.Get_Element(new_ds, current_page, frame_locator=_get_frame_locator())
         if locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+            CommonUtil.ExecLog(sModuleInfo, "Unable to locate your element with given data.", 3)
             return "zeuz_failed"
 
         # Get attribute value based on name
         attr_lower = attribute_name.lower()
         if attr_lower == "text":
-            value = locator.text_content()
+            value = await locator.inner_text()
+        elif attr_lower == "tag":
+            value = (await locator.evaluate("el => el.tagName") or "").lower()
         elif attr_lower == "innertext":
-            value = locator.inner_text()
+            value = await locator.inner_text()
         elif attr_lower == "innerhtml":
-            value = locator.inner_html()
+            value = await locator.inner_html()
         elif attr_lower == "outerhtml":
-            value = locator.evaluate("el => el.outerHTML")
+            value = await locator.evaluate("el => el.outerHTML")
         elif attr_lower == "value":
-            value = locator.input_value()
+            value = await locator.input_value()
         elif attr_lower == "checked":
-            value = locator.is_checked()
+            value = await locator.is_checked()
         elif attr_lower == "selected":
-            value = locator.evaluate("el => el.selected")
+            value = await locator.evaluate("el => el.selected")
         elif attr_lower == "visible":
-            value = locator.is_visible()
+            value = await locator.is_visible()
         elif attr_lower == "enabled":
-            value = locator.is_enabled()
+            value = await locator.is_enabled()
         elif attr_lower == "disabled":
-            value = locator.is_disabled()
+            value = await locator.is_disabled()
         else:
-            value = locator.get_attribute(attribute_name)
+            value = await locator.get_attribute(attribute_name)
 
-        sr.Set_Shared_Variables(save_variable, value)
+        result = sr.Set_Shared_Variables(save_variable, value)
+        if result in failed_tag_list:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Value of Variable '{save_variable}' could not be saved!!!",
+                3,
+            )
+            return "zeuz_failed"
         CommonUtil.ExecLog(sModuleInfo, f"Saved '{attribute_name}' = '{value}' to '{save_variable}'", 1)
         return "passed"
 
@@ -1101,7 +2213,7 @@ def Save_Attribute(step_data):
 
 
 @logger
-def get_element_info(step_data):
+async def get_element_info(step_data):
     """
     Get detailed information about an element.
 
@@ -1119,36 +2231,19 @@ def get_element_info(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
-        save_variable = None
-        for left, mid, right in step_data:
-            if mid.strip().lower() == "save parameter":
-                save_variable = left.strip()
+        save_variable = _save_variable_from_action_or_save_parameter(step_data, "get element info")
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
             return "zeuz_failed"
 
-        # Gather element info
+        box = await locator.bounding_box()
         info = {
-            "tag_name": locator.evaluate("el => el.tagName"),
-            "text": locator.text_content(),
-            "inner_html": locator.inner_html(),
-            "visible": locator.is_visible(),
-            "enabled": locator.is_enabled(),
-            "bounding_box": locator.bounding_box(),
+            "size": {"width": box["width"], "height": box["height"]} if box else {},
+            "location": {"x": box["x"], "y": box["y"]} if box else {},
         }
 
-        # Get all attributes
-        attributes = locator.evaluate("""el => {
-            const attrs = {};
-            for (const attr of el.attributes) {
-                attrs[attr.name] = attr.value;
-            }
-            return attrs;
-        }""")
-        info["attributes"] = attributes
-
         if save_variable:
             sr.Set_Shared_Variables(save_variable, info)
             CommonUtil.ExecLog(sModuleInfo, f"Element info saved to '{save_variable}'", 1)
@@ -1168,7 +2263,7 @@ def get_element_info(step_data):
 #########################
 
 @logger
-def Navigate(step_data):
+async def Navigate(step_data):
     """
     Navigate browser (back, forward, refresh).
 
@@ -1195,7 +2290,7 @@ def Navigate(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip().lower()
 
-            if mid_l == "action":
+            if "action" in mid_l:
                 direction = right_v
             elif mid_l == "optional parameter":
                 if left_l == "timeout":
@@ -1206,13 +2301,13 @@ def Navigate(step_data):
             nav_options["timeout"] = timeout
 
         if direction in ("back", "go back"):
-            current_page.go_back(**nav_options)
+            await current_page.go_back(**nav_options)
             CommonUtil.ExecLog(sModuleInfo, "Navigated back", 1)
         elif direction in ("forward", "go forward"):
-            current_page.go_forward(**nav_options)
+            await current_page.go_forward(**nav_options)
             CommonUtil.ExecLog(sModuleInfo, "Navigated forward", 1)
         elif direction in ("refresh", "reload"):
-            current_page.reload(**nav_options)
+            await current_page.reload(**nav_options)
             CommonUtil.ExecLog(sModuleInfo, "Page reloaded", 1)
         else:
             CommonUtil.ExecLog(sModuleInfo, f"Unknown navigation direction: {direction}", 3)
@@ -1242,10 +2337,7 @@ def Get_Current_URL(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
-        save_variable = None
-        for left, mid, right in step_data:
-            if mid.strip().lower() == "save parameter":
-                save_variable = left.strip()
+        save_variable = _save_variable_from_action_or_save_parameter(step_data, "get current url")
 
         url = current_page.url
 
@@ -1268,7 +2360,7 @@ def Get_Current_URL(step_data):
 #########################
 
 @logger
-def Scroll(step_data):
+async def Scroll(step_data):
     """
     Scroll the page in a direction.
 
@@ -1296,27 +2388,881 @@ def Scroll(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "input parameter":
+            if _is_action_mid(mid_l) and left_l == "scroll":
+                direction = right_v.lower()
+            elif mid_l == "input parameter":
                 if left_l == "direction":
                     direction = right_v.lower()
                 elif left_l in ("pixel", "pixels", "amount"):
                     pixels = int(right_v)
+            elif left_l in ("pixel", "pixels", "amount"):
+                pixels = int(right_v)
 
         # Calculate delta
         delta_x = 0
         delta_y = 0
 
-        if direction == "down":
-            delta_y = pixels
-        elif direction == "up":
-            delta_y = -pixels
-        elif direction == "right":
-            delta_x = pixels
-        elif direction == "left":
-            delta_x = -pixels
+        if direction == "down":
+            delta_y = pixels
+        elif direction == "up":
+            delta_y = -pixels
+        elif direction == "right":
+            delta_x = pixels
+        elif direction == "left":
+            delta_x = -pixels
+
+        if _has_element_rows(step_data):
+            locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
+            if locator == "zeuz_failed":
+                CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+                return "zeuz_failed"
+            await locator.evaluate("(el, offset) => el.scrollBy(offset.x, offset.y)", {"x": delta_x, "y": delta_y})
+        else:
+            await current_page.mouse.wheel(delta_x, delta_y)
+        CommonUtil.ExecLog(sModuleInfo, f"Scrolled {direction} by {pixels}px", 1)
+        return "passed"
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+@logger
+async def scroll_to_element(step_data):
+    """
+    Scroll an element into view.
+
+    Example 1 - Basic:
+        Field               Sub Field           Value
+        id                  element parameter   footer
+        scroll to element   playwright action   scroll to element
+
+    Example 2 - Selenium-compatible options:
+        Field               Sub Field           Value
+        id                  element parameter   footer
+        use js              optional parameter  true
+        align to top        optional parameter  true
+        method              optional parameter  js
+        additional scroll   optional parameter  0.1
+        scroll to element   playwright action   scroll to element
+
+    Options:
+        - use js (true/false): Use element.scrollIntoView() via JS.
+        - align to top (true/false): When using JS, align element to top of viewport.
+        - method (js | webdriver | action chain): Which scroll mechanism to use.
+            * js (default): element.scrollIntoView()
+            * webdriver: Playwright's scroll_into_view_if_needed()
+            * action chain: Hover the element so it is brought into view by the engine.
+        - additional scroll (fraction, e.g. 0.1): After scrolling into view, scroll an
+          additional fraction of the viewport in the direction the page just moved.
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        if current_page is None:
+            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+            return "zeuz_failed"
+
+        method = "js"
+        align_to_top = "true"
+        additional_scroll = 0.1
+        direction = ""
+
+        for left, mid, right in step_data:
+            left_l = left.strip().lower()
+            mid_l = mid.strip().lower()
+            right_v = right.strip().lower()
+
+            if mid_l == "optional parameter":
+                if left_l == "use js":
+                    method = "js" if right_v in ("true", "yes", "1") else "action chain"
+                elif left_l == "align to top":
+                    align_to_top = "true" if right_v in ("true", "yes", "1") else "false"
+                elif left_l == "method":
+                    method = right_v
+                elif "additional scroll" in left_l:
+                    try:
+                        additional_scroll = float(right_v)
+                    except ValueError:
+                        additional_scroll = 0.1
+                    direction_part = left_l.replace("additional scroll", "").strip()
+                    if direction_part in ("up", "down", "left", "right"):
+                        direction = direction_part
+
+        locator = await PlaywrightLocator.Get_Element(
+            step_data, current_page, frame_locator=_get_frame_locator()
+        )
+        if locator == "zeuz_failed":
+            CommonUtil.ExecLog(sModuleInfo, "Element to which instructed to scroll not found", 3)
+            return "zeuz_failed"
+
+        top, left_pos = None, None
+        if not direction and additional_scroll > 0:
+            try:
+                top, left_pos = await current_page.evaluate(
+                    "() => [window.pageYOffset || document.documentElement.scrollTop,"
+                    " window.pageXOffset || document.documentElement.scrollLeft]"
+                )
+            except Exception:
+                top, left_pos = None, None
+
+        if method == "js":
+            await locator.evaluate(f"el => el.scrollIntoView({align_to_top})")
+        elif method == "webdriver":
+            await locator.scroll_into_view_if_needed()
+        else:
+            # "action chain" -> hover brings element into view in Playwright.
+            await locator.hover()
+
+        CommonUtil.ExecLog(sModuleInfo, f"Scrolled to view with method = {method}", 1)
+
+        if (
+            not direction
+            and additional_scroll > 0
+            and top is not None
+            and left_pos is not None
+        ):
+            try:
+                new_top, new_left = await current_page.evaluate(
+                    "() => [window.pageYOffset || document.documentElement.scrollTop,"
+                    " window.pageXOffset || document.documentElement.scrollLeft]"
+                )
+                if new_top > top:
+                    direction = "down"
+                elif new_top < top:
+                    direction = "up"
+                elif new_left > left_pos:
+                    direction = "right"
+                elif new_left < left_pos:
+                    direction = "left"
+                else:
+                    direction = ""
+            except Exception:
+                direction = ""
+
+            if (
+                method in ("js", "webdriver")
+                and (
+                    (align_to_top == "true" and direction in ("down", "right"))
+                    or (align_to_top == "false" and direction in ("up", "left"))
+                )
+            ):
+                direction = ""
+
+        if direction and additional_scroll > 0:
+            await asyncio.sleep(1)
+            viewport = current_page.viewport_size or {"width": 1280, "height": 720}
+            axis = "height" if direction in ("up", "down") else "width"
+            pixels = round(viewport[axis] * additional_scroll)
+            offset = _generate_scroll_offset(direction, pixels)
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Doing additional scroll in {direction} direction, {additional_scroll * 100}% of "
+                f"{axis} of html body, ({offset}) pixels",
+                1,
+            )
+            await current_page.evaluate(f"window.scrollBy({offset})")
+
+        return "passed"
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+def _generate_scroll_offset(direction: str, pixel: int) -> str:
+    if direction == "down":
+        return f"0,{pixel}"
+    if direction == "up":
+        return f"0,-{pixel}"
+    if direction == "left":
+        return f"-{pixel},0"
+    if direction == "right":
+        return f"{pixel},0"
+    return "0,0"
+
+
+_SCROLL_TO_TOP_JS = """
+(() => {
+    var pre_x = window.pageXOffset;
+    var pre_y = window.pageYOffset;
+    window.scrollTo(window.pageXOffset, 0);
+    return [pre_x, pre_y, window.pageXOffset, window.pageYOffset];
+})()
+"""
+
+
+def _is_session_step_row(left, mid):
+    return _normalize_step_mid(mid) == "optionalparameter" and left.strip().lower() == "session"
+
+
+def _normalize_step_mid(mid):
+    """Match LocateElement: ignore spaces/newlines in sub-field names."""
+    return (
+        mid.replace(" ", "")
+        .replace("\n", "")
+        .replace("\r", "")
+        .replace("\t", "")
+        .lower()
+    )
+
+
+def _is_element_parameter_mid(mid):
+    mid_norm = _normalize_step_mid(mid)
+    return mid_norm == "elementparameter" or (
+        "element" in mid_norm and "parameter" in mid_norm and "target" not in mid_norm
+    )
+
+
+def _is_target_parameter_mid(mid):
+    mid_norm = _normalize_step_mid(mid)
+    # UI may show only "target" on one line; "parameter" on the next (full name is still one row in data).
+    return mid_norm in ("targetparameter", "target") or (
+        "target" in mid_norm and "parameter" in mid_norm
+    )
+
+
+def _resolve_list_action_variable_name(left, mid, right, action_key):
+    """
+    Read shared-variable name from a save-*-in-list action row.
+
+    Zeuz may send the variable in the Value column (right) or Field column (left)
+    when the other column repeats the action keyword.
+    """
+    left_raw = left.strip()
+    right_raw = right.strip()
+    left_norm = left_raw.lower().replace(" ", "").replace("_", "")
+    right_norm = right_raw.lower().replace(" ", "").replace("_", "")
+    mid_norm = _normalize_step_mid(mid)
+
+    if left_norm == action_key:
+        if right_norm and right_norm != action_key:
+            return right_raw
+        return None
+
+    if mid_norm in ("playwrightaction", "seleniumaction"):
+        if right_norm == action_key and left_norm and left_norm != action_key:
+            return left_raw
+        if right_norm and right_norm != action_key:
+            return right_raw
+    return None
+
+
+async def _require_playwright_page(step_data, sModuleInfo):
+    """Activate session from step_data and ensure a page is open."""
+    global current_page
+    await _handle_playwright_session(step_data)
+    if current_page is None:
+        CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+        return "zeuz_failed"
+    return current_page
+
+
+async def _read_element_attribute_for_list(locator, attribute_name):
+    if attribute_name == "text":
+        return await locator.inner_text()
+    if attribute_name == "tag":
+        tag = await locator.evaluate("el => el.tagName")
+        return tag.lower() if tag else ""
+    if attribute_name == "checked":
+        return str(await locator.is_checked())
+    return await locator.get_attribute(attribute_name)
+
+
+def _apply_return_contains_filter(value, contains_rules):
+    if not contains_rules:
+        return value
+    for rule in contains_rules:
+        if (
+            not isinstance(rule, type(value))
+            or rule in value
+            or len(rule) == 0
+        ):
+            break
+    else:
+        return None
+    return value
+
+
+def _apply_return_does_not_contain_filter(value, exclude_rules):
+    for rule in exclude_rules:
+        if (
+            isinstance(rule, type(value))
+            and rule in value
+            and len(rule) != 0
+        ):
+            return None
+    return value
+
+
+def _target_param_continues_previous_target(right):
+    """True when this target-parameter row adds return/filter rules to the prior target."""
+    text = right.strip().lower()
+    return text.startswith(
+        ("return", "return_contains", "return_does_not_contain", "allow hidden", "allowhidden")
+    )
+
+
+def _parse_target_kv_pairs(right, split_on_newline=False, field_hint=None):
+    """Parse target parameter value into (key, value) pairs.
+
+    Matches Selenium semantics for both list actions:
+      - save_attribute_values_in_list expects bare-string filter values:
+            return_contains="128GB" -> ('return_contains', '128GB')
+      - save_web_elements_in_list expects (attr, needle) filter pairs:
+            return_contains="text=128GB" -> ('return_contains', ('text', '128GB'))
+
+    The shape used depends on whether the value (after quote-stripping) has an
+    inner '=', mirroring Selenium's `each.split("=")` behavior on a list of length
+    1 vs 2.
+    """
+    text = right.strip().rstrip(",")
+    # UI may use comma-only (one line) or comma+newline (multi-line) separators.
+    if split_on_newline and ",\n" in text:
+        chunks = text.split(",\n")
+    else:
+        chunks = text.split(",")
+    pairs = []
+    hint = (field_hint or "").strip().lower() or "class"
+    for chunk in chunks:
+        chunk = chunk.strip().rstrip(",")
+        if not chunk:
+            continue
+        if "=" not in chunk:
+            if hint:
+                # Shorthand: "productItemName" with Field column "class"
+                pairs.append((hint, chunk))
+            else:
+                pairs.append((chunk, ""))
+            continue
+
+        key, value = chunk.split("=", 1)
+        key = key.strip()
+        value = value.strip()
+        if key in ("return_contains", "return_does_not_contain"):
+            # Strip the wrapping quotes (if any) on the value first; an INNER '='
+            # then signals the attr=needle pair form used by save_web_elements_in_list.
+            inner = CommonUtil.strip1(value, '"')
+            if "=" in inner:
+                attr, needle = inner.split("=", 1)
+                pairs.append((key, (attr.strip(), needle.strip())))
+            else:
+                pairs.append((key, inner))
+        else:
+            pairs.append((key, value))
+    return pairs
+
+
+def _normalize_target_pair_values(pairs):
+    normalized = []
+    for pair in pairs:
+        if len(pair) == 1:
+            normalized.append((pair[0].strip(), ""))
+            continue
+        key, value = pair[0], pair[1]
+        key = key.strip() if isinstance(key, str) else key
+        if isinstance(value, str):
+            value = CommonUtil.strip1(value.strip(), '"')
+        elif isinstance(value, tuple) and len(value) == 2:
+            value = (
+                CommonUtil.strip1(value[0].strip(), '"'),
+                CommonUtil.strip1(value[1].strip(), '"'),
+            )
+        elif isinstance(value, list) and len(value) == 2:
+            value = (value[0].strip().strip('"'), value[1].strip().strip('"'))
+        normalized.append((key, value))
+    pairs[:] = normalized
+
+
+def _append_target_spec(target_specs, key, value, spec_index):
+    spec = target_specs[spec_index]
+    if key == "return":
+        spec[1] = value
+    elif key == "return_contains":
+        spec[2].append(value)
+    elif key == "return_does_not_contain":
+        spec[3].append(value)
+    elif key.replace(" ", "").replace("_", "") in ("allowhidden", "allowdisable"):
+        spec[0].append(("allow hidden", "optional parameter", value))
+    else:
+        spec[0].append((key, "element parameter", value))
+
+
+async def _element_matches_return_contains(elem, rules):
+    text = await elem.inner_text()
+    tag = (await elem.evaluate("el => el.tagName")).lower()
+    for attr, needle in rules:
+        if attr == "text" and needle in text:
+            return True
+        if attr == "tag" and needle in tag:
+            return True
+        if attr not in ("text", "tag"):
+            attr_val = await elem.get_attribute(attr)
+            if attr_val is None:
+                return False
+            if needle in attr_val:
+                return True
+    return False
+
+
+async def _element_matches_return_does_not_contain(elem, rules):
+    text = await elem.inner_text()
+    tag = (await elem.evaluate("el => el.tagName")).lower()
+    for attr, needle in rules:
+        if attr == "text" and needle in text:
+            return True
+        if attr == "tag" and needle in tag:
+            return True
+        if attr not in ("text", "tag"):
+            attr_val = await elem.get_attribute(attr)
+            if attr_val is None or needle in (attr_val or ""):
+                return True
+    return False
+
+
+async def _filter_elements_return_contains(elements, contains_rules):
+    if not contains_rules:
+        return elements
+    filtered = []
+    for elem in elements:
+        if await _element_matches_return_contains(elem, contains_rules):
+            filtered.append(elem)
+    return filtered
+
+
+async def _filter_elements_return_does_not_contain(elements, exclude_rules):
+    if not exclude_rules:
+        return elements
+    return [
+        elem
+        for elem in elements
+        if not await _element_matches_return_does_not_contain(elem, exclude_rules)
+    ]
+
+
+@logger
+async def scroll_to_top(step_data):
+    """
+    Scroll the browser window to the top of the page (vertical offset 0).
+
+    Example:
+        Field               Sub Field           Value
+        scroll to top       playwright action   scroll to top
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+
+    try:
+        page = await _require_playwright_page(step_data, sModuleInfo)
+        if page == "zeuz_failed":
+            return "zeuz_failed"
+
+        pre_x, pre_y, x, y = await page.evaluate(_SCROLL_TO_TOP_JS)
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"Scrolled to top of the html.\npre_x, pre_y, x, y = [{pre_x}, {pre_y}, {x}, {y}]",
+            1 if (x, y) == (0, 0) else 2,
+        )
+        return "passed"
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+@logger
+async def save_attribute_values_in_list(step_data):
+    """
+    Collect attribute or text values from multiple child element groups under a parent.
+
+    Each target parameter block defines locators plus optional return filters. Results are
+    stored in a shared variable as rows (paired) or columns (paired=no).
+
+    Example 1 - Product names and prices:
+        Field                               Sub Field           Value
+        aria-label                          element parameter   Calendar
+        attributes                          target parameter    data-automation="productItemName",
+                                                                class="S58f2saa25a3w1",
+                                                                return="text"
+        attributes                          target parameter    class="productPricingContainer_3gTS3",
+                                                                return="text",
+                                                                return_does_not_contain="99.99"
+        save attribute values in list       playwright action   product_rows
+
+    Example 2 - Unpaired columns:
+        Field                               Sub Field           Value
+        tag                                 element parameter   html
+        class                               target parameter    item, return="text"
+        class                               target parameter    price, return="text"
+        paired                              optional parameter  no
+        save attribute values in list       playwright action   columns_list
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        if await _require_playwright_page(step_data, sModuleInfo) == "zeuz_failed":
+            return "zeuz_failed"
+
+        frame = _get_frame_locator()
+        parent = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=frame)
+        if parent == "zeuz_failed":
+            CommonUtil.ExecLog(
+                sModuleInfo, "Unable to locate your element with given data.", 3
+            )
+            return "zeuz_failed"
+
+        targets = []
+        variable_name = ""
+        paired = True
+
+        try:
+            spec_index = -1
+            for left, mid, right in step_data:
+                if _is_session_step_row(left, mid):
+                    continue
+                left_l = left.strip().lower()
+                right = right.strip()
+                if _is_target_parameter_mid(mid):
+                    if spec_index >= 0 and _target_param_continues_previous_target(right):
+                        pass  # append to current target spec
+                    else:
+                        targets.append([[], "", [], []])
+                        spec_index += 1
+                    pairs = _parse_target_kv_pairs(
+                        right, split_on_newline=True, field_hint=left_l
+                    )
+                    _normalize_target_pair_values(pairs)
+                    for key, value in pairs:
+                        _append_target_spec(targets, key, value, spec_index)
+                else:
+                    var_candidate = _resolve_list_action_variable_name(
+                        left,
+                        mid,
+                        right,
+                        "saveattributevaluesinlist",
+                    )
+                    if var_candidate:
+                        variable_name = var_candidate
+                if left_l == "paired":
+                    paired = right.lower() != "no"
+            if not targets:
+                CommonUtil.ExecLog(sModuleInfo, "No target parameter rows found in step data", 3)
+                return "zeuz_failed"
+            if not variable_name:
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    "No variable name for save attribute values in list (set action value e.g. product_data)",
+                    3,
+                )
+                return "zeuz_failed"
+        except Exception as exc:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Unable to parse data. Please write data in correct format ({exc})",
+                3,
+            )
+            return "zeuz_failed"
+
+        element_groups = []
+        for locator_rows, return_attr, contains_rules, exclude_rules in targets:
+            elements = await PlaywrightLocator.Get_Element(
+                locator_rows,
+                current_page,
+                return_all=True,
+                frame_locator=frame,
+                parent_locator=parent,
+            )
+            if elements == "zeuz_failed":
+                CommonUtil.ExecLog(sModuleInfo, "Unable to locate target elements.", 3)
+                return "zeuz_failed"
+            element_groups.append((elements, return_attr, contains_rules, exclude_rules))
+
+        max_len = max((len(group[0]) for group in element_groups), default=0)
+        rows = [[] for _ in range(max_len)]
+
+        for elements, return_attr, contains_rules, exclude_rules in element_groups:
+            for index, elem in enumerate(elements):
+                value = await _read_element_attribute_for_list(elem, return_attr)
+                try:
+                    value = _apply_return_contains_filter(value, contains_rules)
+                    value = _apply_return_does_not_contain_filter(value, exclude_rules)
+                except Exception:
+                    CommonUtil.ExecLog(
+                        sModuleInfo,
+                        "Couldn't search by return_contains and return_does_not_contain",
+                        2,
+                    )
+                rows[index].append(value)
+
+        if len(targets) == 1:
+            # Match Selenium: one target => flat list of values (all elements), not rows[0] only.
+            result = list(map(list, zip(*rows)))[0] if rows else []
+        elif not paired:
+            result = list(map(list, zip(*rows))) if rows else []
+        else:
+            result = rows
+
+        return sr.Set_Shared_Variables(variable_name, result)
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+_ELEMENT_SCOPE_MIDS = frozenset(
+    {
+        "element parameter",
+        "parent parameter",
+        "unique parameter",
+        "child parameter",
+        "sibling parameter",
+    }
+)
+
+
+@logger
+async def save_web_elements_in_list(step_data):
+    """
+    Save Playwright locators for multiple element groups into a shared variable.
+
+    Optional parent scope limits the search. Use return_contains / return_does_not_contain
+    in target parameters to filter matched elements before saving.
+
+    Example 1 - Under a container:
+        Field                           Sub Field           Value
+        id                              element parameter   product-list
+        class                           target parameter    item, return_contains=text=Phone
+        save web elements in list       playwright action   phone_items
+
+    Example 2 - Whole page (no parent rows):
+        Field                           Sub Field           Value
+        class                           target parameter    btn-primary
+        save web elements in list       playwright action   all_buttons
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        if await _require_playwright_page(step_data, sModuleInfo) == "zeuz_failed":
+            return "zeuz_failed"
+
+        frame = _get_frame_locator()
+        targets = []
+        variable_name = ""
+        has_parent_scope = False
+
+        try:
+            spec_index = -1
+            for left, mid, right in step_data:
+                if _is_session_step_row(left, mid):
+                    continue
+                left = left.strip().lower()
+                mid = mid.strip().lower()
+                right = right.strip()
+                if not has_parent_scope and _is_element_parameter_mid(mid):
+                    has_parent_scope = True
+                elif _is_target_parameter_mid(mid):
+                    if spec_index >= 0 and _target_param_continues_previous_target(right):
+                        pass
+                    else:
+                        targets.append([[], [], [], []])
+                        spec_index += 1
+                    pairs = _parse_target_kv_pairs(right, field_hint=left)
+                    _normalize_target_pair_values(pairs)
+                    for key, value in pairs:
+                        _append_target_spec(targets, key, value, spec_index)
+                else:
+                    var_candidate = _resolve_list_action_variable_name(
+                        left,
+                        mid,
+                        right,
+                        "savewebelementsinlist",
+                    )
+                    if var_candidate:
+                        variable_name = var_candidate
+
+            if has_parent_scope:
+                parent = await PlaywrightLocator.Get_Element(
+                    step_data, current_page, frame_locator=frame
+                )
+                if parent == "zeuz_failed":
+                    CommonUtil.ExecLog(
+                        sModuleInfo, "Unable to locate your element with given data.", 3
+                    )
+                    return "zeuz_failed"
+            else:
+                parent = None
+        except Exception:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                "Unable to parse data. Please write data in correct format",
+                3,
+            )
+            return "zeuz_failed"
+
+        element_lists = []
+        for locator_rows, _return_attr, contains_rules, exclude_rules in targets:
+            elements = await PlaywrightLocator.Get_Element(
+                locator_rows,
+                current_page,
+                return_all=True,
+                frame_locator=frame,
+                parent_locator=parent,
+            )
+            if elements == "zeuz_failed":
+                CommonUtil.ExecLog(sModuleInfo, "Unable to locate target elements.", 3)
+                return "zeuz_failed"
+            elements = await _filter_elements_return_contains(elements, contains_rules)
+            elements = await _filter_elements_return_does_not_contain(elements, exclude_rules)
+            element_lists.append(elements)
+
+        if len(targets) == 1:
+            return sr.Set_Shared_Variables(variable_name, element_lists[0])
+        return sr.Set_Shared_Variables(variable_name, element_lists)
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+def _insert_string_targets(string: str, str_to_insert: str, index: int) -> str:
+    return string[:index] + str_to_insert + string[index:]
+
+
+def _parse_multiple_check_targets(target_parameter_value):
+    """Parse target parameter string into (locator_key, locator_value, action) tuples."""
+    inside = False
+    temp = target_parameter_value.strip()
+    i = 0
+    while i < len(temp):
+        if temp[i] == "(":
+            inside = True
+            temp = _insert_string_targets(temp, '"', i + 1)
+        elif inside and temp[i] == ",":
+            temp = _insert_string_targets(temp, '"', i + 1)
+            temp = _insert_string_targets(temp, '"', i)
+            i += 1
+        elif temp[i] == ")":
+            inside = False
+            temp = _insert_string_targets(temp, '"', i)
+            i += 1
+        i += 1
+    temp = _insert_string_targets(temp, "[", 0)
+    temp = _insert_string_targets(temp, "]", len(temp))
+    parsed = CommonUtil.parse_value_into_object(temp)
+    return [
+        (row[0].strip().lower(), row[1].strip(), row[2].strip().lower())
+        for row in parsed
+    ]
+
+
+async def _toggle_checkbox_target(locator, action, use_js, target_label):
+    """Check or uncheck one target; logs and swallows per-target failures like Selenium."""
+    try:
+        checked = await locator.is_checked()
+    except Exception:
+        try:
+            checked = await locator.evaluate("el => Boolean(el.checked || el.getAttribute('aria-checked') === 'true')")
+        except Exception:
+            checked = None
+    if checked is not None:
+        if action == "check" and checked:
+            CommonUtil.ExecLog("", f"{target_label} is already checked so skipped it", 1)
+            return
+        if action == "uncheck" and not checked:
+            CommonUtil.ExecLog("", f"{target_label} is already unchecked so skipped it", 1)
+            return
+
+    via_js = use_js
+    try:
+        if use_js:
+            await locator.evaluate("el => el.click()")
+        else:
+            try:
+                await locator.click()
+            except Exception:
+                await locator.evaluate("el => el.click()")
+                via_js = True
+        verb = "checked" if action == "check" else "unchecked"
+        suffix = " using Java Script" if via_js else ""
+        CommonUtil.ExecLog("", f"{target_label} is {verb} successfully{suffix}", 1)
+    except Exception:
+        verb = "checked" if action == "check" else "unchecked"
+        CommonUtil.ExecLog("", f"{target_label} couldn't be {verb} so skipped it", 3)
+
+
+@logger
+async def multiple_check_uncheck(data_set):
+    """
+    Check or uncheck multiple checkbox/radio elements under one parent.
+
+    Each entry in target parameter is (locator field, locator value, check|uncheck).
+    Missing targets are skipped; the step still returns passed.
+
+    Example 1 - Basic:
+        Field                       Sub Field           Value
+        id                          element parameter   form-panel
+        target parameter            target parameter    (id, opt-a, check), (id, opt-b, uncheck)
+        multiple check uncheck      playwright action   multiple check uncheck
+
+    Example 2 - JavaScript click:
+        Field                       Sub Field           Value
+        class                       element parameter   options-group
+        use js                      optional parameter  true
+        allow hidden                optional parameter  yes
+        target parameter            target parameter    (name, hidden-opt, check)
+        multiple check uncheck      playwright action   multiple check uncheck
+    """
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    use_js = False
+    allow_hidden = ""
+    targets = None
+
+    try:
+        for left, mid, right in data_set:
+            left = left.lower().strip()
+            mid = mid.lower().strip()
+            if _is_session_step_row(left, mid):
+                continue
+            if left == "use js":
+                use_js = right.strip().lower() in ("true", "yes", "ok")
+            elif left == "allow hidden":
+                allow_hidden = right
+            elif mid == "target parameter":
+                targets = _parse_multiple_check_targets(right)
+
+    except Exception:
+        return CommonUtil.Exception_Handler(
+            sys.exc_info(), None, "Error parsing data set"
+        )
+
+    if not targets:
+        CommonUtil.ExecLog(sModuleInfo, "No target parameter found in step data", 3)
+        return "zeuz_failed"
+
+    try:
+        if await _require_playwright_page(data_set, sModuleInfo) == "zeuz_failed":
+            return "zeuz_failed"
+
+        frame = _get_frame_locator()
+        parent = await PlaywrightLocator.Get_Element(data_set, current_page, frame_locator=frame)
+        if parent == "zeuz_failed":
+            CommonUtil.ExecLog(sModuleInfo, "Could not find the parent element", 3)
+            return "zeuz_failed"
+
+        for locator_key, locator_value, action in targets:
+            locate_rows = [(locator_key, "element parameter", locator_value)]
+            if allow_hidden:
+                locate_rows.insert(0, ("allow hidden", "option", allow_hidden))
+
+            locator = await PlaywrightLocator.Get_Element(
+                locate_rows, current_page, frame_locator=frame, parent_locator=parent
+            )
+            target_label = str((locator_key, locator_value, action))
+            if locator == "zeuz_failed":
+                CommonUtil.ExecLog("", f"{target_label} was not found so skipped it", 3)
+                continue
+
+            await _toggle_checkbox_target(locator, action, use_js, target_label)
 
-        current_page.mouse.wheel(delta_x, delta_y)
-        CommonUtil.ExecLog(sModuleInfo, f"Scrolled {direction} by {pixels}px", 1)
         return "passed"
 
     except Exception:
@@ -1324,53 +3270,64 @@ def Scroll(step_data):
 
 
 @logger
-def scroll_to_element(step_data):
+async def Change_Attribute_Value(step_data):
     """
-    Scroll an element into view.
+    Set a DOM property on the located element via JavaScript (same idea as Selenium).
 
-    Example:
-        Field               Sub Field           Value
-        id                  element parameter   footer
-        use js              optional parameter  false
-        scroll to element   playwright action   scroll to element
+    The left column of an input parameter row is the property name; the right column is the value.
+
+    Example 1 - Input value:
+        Field                       Sub Field           Value
+        id                          element parameter   email-field
+        value                       input parameter     user@example.com
+        change attribute value      playwright action   change attribute value
+
+    Example 2 - Read-only flag:
+        Field                       Sub Field           Value
+        id                          element parameter   age-input
+        readOnly                    input parameter     true
+        change attribute value      playwright action   change attribute value
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global current_page
 
     try:
-        if current_page is None:
-            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+        if await _require_playwright_page(step_data, sModuleInfo) == "zeuz_failed":
             return "zeuz_failed"
 
-        use_js = False
-        align_to_top = True
-
+        attribute_name = ""
+        change_value = ""
         for left, mid, right in step_data:
-            left_l = left.strip().lower()
-            mid_l = mid.strip().lower()
-            right_v = right.strip()
-
-            if mid_l == "optional parameter":
-                if left_l == "use js":
-                    use_js = right_v.lower() in ("true", "yes", "1")
-                elif left_l == "align to top":
-                    align_to_top = right_v.lower() in ("true", "yes", "1")
-
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+            if _is_session_step_row(left, mid):
+                continue
+            if "input parameter" in mid.strip().lower():
+                attribute_name = left.strip().lower()
+                change_value = right
+
+        locator = await PlaywrightLocator.Get_Element(
+            step_data, current_page, frame_locator=_get_frame_locator()
+        )
         if locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+            CommonUtil.ExecLog(
+                sModuleInfo, "Unable to locate your element with given data.", 3
+            )
             return "zeuz_failed"
 
-        if use_js:
-            locator.evaluate(f"el => el.scrollIntoView({str(align_to_top).lower()})")
-        else:
-            locator.scroll_into_view_if_needed()
-
-        CommonUtil.ExecLog(sModuleInfo, "Scrolled element into view", 1)
+        await locator.evaluate(
+            "(el, payload) => { el[payload.name] = payload.value; }",
+            {"name": attribute_name, "value": change_value},
+        )
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"Successfully set the value of the attribute to: {change_value}",
+            1,
+        )
         return "passed"
 
     except Exception:
-        return CommonUtil.Exception_Handler(sys.exc_info())
+        return CommonUtil.Exception_Handler(
+            sys.exc_info(), None, "Could not find your element."
+        )
 
 
 #########################
@@ -1380,7 +3337,7 @@ def scroll_to_element(step_data):
 #########################
 
 @logger
-def Select_Deselect(step_data):
+async def Select_Deselect(step_data):
     """
     Select or deselect options in a dropdown/select element.
 
@@ -1413,15 +3370,18 @@ def Select_Deselect(step_data):
         select_type = "label"  # label, value, index
         select_value = None
         is_deselect = False
+        deselect_all = False
 
         for left, mid, right in step_data:
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "action":
+            if "action" in mid_l:
                 if "deselect" in left_l:
                     is_deselect = True
+                    if "all" in left_l:
+                        deselect_all = True
 
                 if "by value" in left_l or "byvalue" in left_l:
                     select_type = "value"
@@ -1432,11 +3392,13 @@ def Select_Deselect(step_data):
 
                 select_value = right_v
 
-        if not select_value:
+        if deselect_all:
+            select_value = ""
+        elif not select_value:
             CommonUtil.ExecLog(sModuleInfo, "No selection value provided", 3)
             return "zeuz_failed"
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
             return "zeuz_failed"
@@ -1444,24 +3406,27 @@ def Select_Deselect(step_data):
         # Build selection option
         if select_type == "value":
             option = {"value": select_value}
-        elif select_type == "index":
+        elif select_type == "index" and select_value != "":
             option = {"index": int(select_value)}
         else:  # label
             option = {"label": select_value}
 
         if is_deselect:
             # Playwright doesn't have direct deselect, use JavaScript
-            locator.evaluate(f"""el => {{
-                for (const opt of el.options) {{
-                    if (opt.{'value' if select_type == 'value' else 'text'} === '{select_value}') {{
+            await locator.evaluate("""(el, data) => {
+                for (const opt of el.options) {
+                    if (data.all ||
+                        (data.type === 'value' && opt.value === data.value) ||
+                        (data.type === 'label' && opt.text === data.value) ||
+                        (data.type === 'index' && opt.index === Number(data.value))) {
                         opt.selected = false;
-                    }}
-                }}
+                    }
+                }
                 el.dispatchEvent(new Event('change'));
-            }}""")
+            }""", {"all": deselect_all, "type": select_type, "value": select_value})
             CommonUtil.ExecLog(sModuleInfo, f"Deselected: {select_value}", 1)
         else:
-            locator.select_option(**option)
+            await locator.select_option(**option)
             CommonUtil.ExecLog(sModuleInfo, f"Selected: {select_value}", 1)
 
         return "passed"
@@ -1477,7 +3442,7 @@ def Select_Deselect(step_data):
 #########################
 
 @logger
-def check_uncheck(step_data):
+async def check_uncheck(step_data):
     """
     Check or uncheck a checkbox/radio button.
 
@@ -1505,7 +3470,7 @@ def check_uncheck(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip().lower()
 
-            if mid_l == "action":
+            if "action" in mid_l:
                 if "uncheck" in left_l or "uncheck" in right_v:
                     action = "uncheck"
                 else:
@@ -1514,24 +3479,105 @@ def check_uncheck(step_data):
                 if left_l == "use js":
                     use_js = right_v in ("true", "yes", "1")
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        locator = await PlaywrightLocator.Get_Element(step_data, current_page, frame_locator=_get_frame_locator())
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
             return "zeuz_failed"
 
-        options = {}
-        if use_js:
-            options["force"] = True
+        await _toggle_checkbox_target(locator, action, use_js, "The element")
 
-        if action == "check":
-            locator.check(**options)
-            CommonUtil.ExecLog(sModuleInfo, "Checkbox checked", 1)
-        else:
-            locator.uncheck(**options)
-            CommonUtil.ExecLog(sModuleInfo, "Checkbox unchecked", 1)
+        return "passed"
+
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+@logger
+async def check_uncheck_all(data_set):
+    """Check or uncheck all target elements under a parent element."""
+
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        if current_page is None:
+            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+            return "zeuz_failed"
+
+        use_js = False
+        target = []
+        command = "check"
+        for left, mid, right in data_set:
+            left_l = left.lower().strip()
+            mid_l = mid.lower().strip()
+            if left_l == "use js":
+                use_js = _truthy(right)
+            elif mid_l == "target parameter":
+                target.append((left, "element parameter", right))
+            elif left_l == "check uncheck all":
+                command = "uncheck" if "uncheck" in right.lower() else "check"
+            elif left_l == "allow hidden":
+                target.append((left, "option", right))
+
+        parent = await PlaywrightLocator.Get_Element(data_set, current_page, frame_locator=_get_frame_locator())
+        if parent == "zeuz_failed":
+            CommonUtil.ExecLog(sModuleInfo, "Could not find the parent element", 3)
+            return "zeuz_failed"
+
+        all_elements = await PlaywrightLocator.Get_Element(target, current_page, return_all=True, parent_locator=parent)
+        if not all_elements or all_elements == "zeuz_failed":
+            CommonUtil.ExecLog(sModuleInfo, "No target was found", 3)
+            return "zeuz_failed"
+
+        for index, element in enumerate(all_elements, start=1):
+            suffix = "th"
+            if index == 1:
+                suffix = "st"
+            elif index == 2:
+                suffix = "nd"
+            elif index == 3:
+                suffix = "rd"
+            await _toggle_checkbox_target(element, command, use_js, f"{index}{suffix} target")
 
         return "passed"
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
+@logger
+async def slider_bar(data_set):
+    """Set a slider by clicking at a percentage across the element."""
+
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page
+
+    try:
+        if current_page is None:
+            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+            return "zeuz_failed"
+
+        value = None
+        for left, mid, right in data_set:
+            if _is_action_mid(mid):
+                value = int(right.strip())
+        if value is None:
+            CommonUtil.ExecLog(sModuleInfo, "Slider value must be provided", 3)
+            return "zeuz_failed"
+
+        locator = await PlaywrightLocator.Get_Element(data_set, current_page, frame_locator=_get_frame_locator())
+        if locator == "zeuz_failed":
+            CommonUtil.ExecLog(sModuleInfo, "Could not find the element", 3)
+            return "zeuz_failed"
 
+        box = await locator.bounding_box()
+        if not box:
+            CommonUtil.ExecLog(sModuleInfo, "Could not compute slider size", 3)
+            return "zeuz_failed"
+        x = box["x"] + (value / 100) * box["width"]
+        y = box["y"] + box["height"] / 2
+        await current_page.mouse.click(x, y)
+        CommonUtil.ExecLog(sModuleInfo, f"Successfully set the slider to %{value}", 1)
+        return "passed"
     except Exception:
         return CommonUtil.Exception_Handler(sys.exc_info())
 
@@ -1543,7 +3589,7 @@ def check_uncheck(step_data):
 #########################
 
 @logger
-def switch_window_or_tab(step_data):
+async def switch_window_or_tab(step_data):
     """
     Switch to a different window/tab.
 
@@ -1592,19 +3638,21 @@ def switch_window_or_tab(step_data):
 
         if switch_by_title:
             for page in pages:
-                page_title = page.title()
+                page_title = await page.title()
                 if partial_match:
                     if switch_by_title.lower() in page_title.lower():
                         current_page = page
-                        page.bring_to_front()
+                        await page.bring_to_front()
                         sr.Set_Shared_Variables("playwright_page", current_page)
+                        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
                         CommonUtil.ExecLog(sModuleInfo, f"Switched to tab: {page_title}", 1)
                         return "passed"
                 else:
                     if switch_by_title.lower() == page_title.lower():
                         current_page = page
-                        page.bring_to_front()
+                        await page.bring_to_front()
                         sr.Set_Shared_Variables("playwright_page", current_page)
+                        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
                         CommonUtil.ExecLog(sModuleInfo, f"Switched to tab: {page_title}", 1)
                         return "passed"
 
@@ -1614,9 +3662,10 @@ def switch_window_or_tab(step_data):
         elif switch_by_index is not None:
             if 0 <= switch_by_index < len(pages):
                 current_page = pages[switch_by_index]
-                current_page.bring_to_front()
+                await current_page.bring_to_front()
                 sr.Set_Shared_Variables("playwright_page", current_page)
-                CommonUtil.ExecLog(sModuleInfo, f"Switched to tab index {switch_by_index}: {current_page.title()}", 1)
+                CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
+                CommonUtil.ExecLog(sModuleInfo, f"Switched to tab index {switch_by_index}: {await current_page.title()}", 1)
                 return "passed"
             else:
                 CommonUtil.ExecLog(sModuleInfo, f"Invalid tab index: {switch_by_index}", 3)
@@ -1630,7 +3679,7 @@ def switch_window_or_tab(step_data):
 
 
 @logger
-def open_new_tab(step_data):
+async def open_new_tab(step_data):
     """
     Open a new browser tab.
 
@@ -1656,12 +3705,18 @@ def open_new_tab(step_data):
             if mid_l == "input parameter" and left_l in ("url", "link", "go to link"):
                 url = right_v
 
-        new_page = context.new_page()
+        new_page = await context.new_page()
         current_page = new_page
         sr.Set_Shared_Variables("playwright_page", current_page)
+        if current_page_id:
+            sessions = get_browser_sessions()
+            if current_page_id in sessions:
+                sessions[current_page_id]["playwright_page"] = current_page
+                sr.Set_Shared_Variables("browser_sessions", sessions)
+        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
 
         if url:
-            new_page.goto(url)
+            await new_page.goto(url)
             CommonUtil.ExecLog(sModuleInfo, f"Opened new tab with URL: {url}", 1)
         else:
             CommonUtil.ExecLog(sModuleInfo, "Opened new blank tab", 1)
@@ -1673,7 +3728,7 @@ def open_new_tab(step_data):
 
 
 @logger
-def close_tab(step_data):
+async def close_tab(step_data):
     """
     Close a browser tab.
 
@@ -1696,6 +3751,7 @@ def close_tab(step_data):
 
         tab_title = None
         tab_index = None
+        close_tabs = []
 
         for left, mid, right in step_data:
             left_l = left.strip().lower()
@@ -1707,13 +3763,33 @@ def close_tab(step_data):
                     tab_title = right_v
                 elif left_l == "tab index":
                     tab_index = int(right_v)
+                elif left_l == "tabs":
+                    close_tabs = CommonUtil.parse_value_into_object(right_v)
 
         pages = context.pages
 
-        if tab_title:
+        if close_tabs:
+            for target in close_tabs:
+                pages = context.pages
+                if isinstance(target, int):
+                    if -len(pages) <= target < len(pages):
+                        await pages[target].close()
+                    else:
+                        CommonUtil.ExecLog(sModuleInfo, f"Invalid tab index: {target}", 3)
+                        return "zeuz_failed"
+                else:
+                    target_l = str(target).lower()
+                    for page in pages:
+                        if target_l in (await page.title()).lower():
+                            await page.close()
+                            break
+                    else:
+                        CommonUtil.ExecLog(sModuleInfo, f"Tab not found: {target}", 3)
+                        return "zeuz_failed"
+        elif tab_title:
             for page in pages:
-                if tab_title.lower() in page.title().lower():
-                    page.close()
+                if tab_title.lower() in (await page.title()).lower():
+                    await page.close()
                     CommonUtil.ExecLog(sModuleInfo, f"Closed tab: {tab_title}", 1)
                     break
             else:
@@ -1721,7 +3797,7 @@ def close_tab(step_data):
                 return "zeuz_failed"
         elif tab_index is not None:
             if 0 <= tab_index < len(pages):
-                pages[tab_index].close()
+                await pages[tab_index].close()
                 CommonUtil.ExecLog(sModuleInfo, f"Closed tab at index {tab_index}", 1)
             else:
                 CommonUtil.ExecLog(sModuleInfo, f"Invalid tab index: {tab_index}", 3)
@@ -1729,14 +3805,26 @@ def close_tab(step_data):
         else:
             # Close current tab
             if current_page:
-                current_page.close()
+                current_index = pages.index(current_page) if current_page in pages else len(pages) - 1
+                await current_page.close()
                 CommonUtil.ExecLog(sModuleInfo, "Closed current tab", 1)
 
         # Switch to remaining tab if available
         pages = context.pages
         if pages:
-            current_page = pages[-1]
+            if 'current_index' in locals() and current_index > 0 and current_index - 1 < len(pages):
+                current_page = pages[current_index - 1]
+            elif 'current_index' in locals():
+                current_page = pages[0]
+            else:
+                current_page = pages[-1]
             sr.Set_Shared_Variables("playwright_page", current_page)
+            if current_page_id:
+                sessions = get_browser_sessions()
+                if current_page_id in sessions:
+                    sessions[current_page_id]["playwright_page"] = current_page
+                    sr.Set_Shared_Variables("browser_sessions", sessions)
+            CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
 
         return "passed"
 
@@ -1751,7 +3839,7 @@ def close_tab(step_data):
 #########################
 
 @logger
-def switch_iframe(step_data):
+async def switch_iframe(step_data):
     """
     Switch to an iframe or back to main content.
 
@@ -1760,15 +3848,27 @@ def switch_iframe(step_data):
         id                  iframe parameter    my-iframe
         switch iframe       playwright action   switch iframe
 
-    Example 2 - Switch by index:
+    Example 2 - Switch by index (positive or negative):
         Field               Sub Field           Value
-        index               input parameter     0
+        index               iframe parameter    0
         switch iframe       playwright action   switch iframe
 
     Example 3 - Switch to default/main:
         Field               Sub Field           Value
         index               input parameter     default content
         switch iframe       playwright action   switch iframe
+
+    Example 4 - Nested frames (multiple rows, applied in order):
+        Field               Sub Field           Value
+        id                  iframe parameter    outer-frame
+        id                  iframe parameter    inner-frame
+        switch iframe       playwright action   switch iframe
+
+    Behavior notes (Selenium-compatible):
+        - Index lookup is retried (up to 5 times, 2s apart) to wait for iframes to load.
+        - Negative indexes are supported (-1 = last iframe).
+        - If a target cannot be located in the current context, this walks
+          back to parent frames and retries.
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global current_page
@@ -1778,42 +3878,173 @@ def switch_iframe(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
-        iframe_index = None
-        iframe_selector = None
+        default_aliases = ("default content", "default", "main")
+        frame_targets = []
         switch_to_default = False
 
         for left, mid, right in step_data:
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
             right_v = right.strip()
-
-            if mid_l in ("iframe parameter", "frame parameter"):
-                iframe_selector = f"[{left}='{right_v}']" if left_l not in ("tag",) else right_v
-            elif mid_l == "input parameter":
-                if left_l == "index":
-                    if right_v.lower() in ("default content", "default", "main"):
-                        switch_to_default = True
-                    else:
-                        iframe_index = int(right_v)
+            right_l = right_v.lower()
+
+            if "action" in mid_l and left_l == "switch iframe":
+                continue
+
+            if left_l == "index" and right_l in default_aliases:
+                switch_to_default = True
+                continue
+
+            if mid_l not in ("iframe parameter", "frame parameter", "input parameter"):
+                continue
+
+            if left_l == "index":
+                frame_targets.append(
+                    {
+                        "kind": "index",
+                        "mid": mid_l if mid_l in ("iframe parameter", "frame parameter") else "iframe parameter",
+                        "left": left_l,
+                        "right": right_v,
+                    }
+                )
+            elif mid_l in ("iframe parameter", "frame parameter"):
+                frame_targets.append(
+                    {
+                        "kind": "selector",
+                        "mid": mid_l,
+                        "left": left_l,
+                        "right": right_v,
+                    }
+                )
 
         if switch_to_default:
-            # In Playwright, we work with the main page directly
-            # Store a flag or reset frame locator
-            CommonUtil.ExecLog(sModuleInfo, "Switched to default content", 1)
-            return "passed"
+            sr.Set_Shared_Variables("playwright_frame", None)
+            _save_current_playwright_frame(None)
+            CommonUtil.ExecLog(sModuleInfo, "Exited all iframes and switched to default content", 1)
+            if not frame_targets:
+                return "passed"
 
-        # Build frame locator
-        if iframe_selector:
-            frame_locator = current_page.frame_locator(iframe_selector)
-        elif iframe_index is not None:
-            frame_locator = current_page.frame_locator(f"iframe >> nth={iframe_index}")
-        else:
+        if not frame_targets:
             CommonUtil.ExecLog(sModuleInfo, "No iframe selector or index provided", 3)
             return "zeuz_failed"
 
-        # Store frame locator for subsequent actions
+        def _build_selector(target):
+            tag_name = "frame" if target["mid"] == "frame parameter" else "iframe"
+            left_l = target["left"]
+            right_v = target["right"]
+            if left_l == "tag":
+                return tag_name, right_v
+            if left_l == "xpath":
+                expr = right_v if right_v.startswith("xpath=") else f"xpath={right_v}"
+                return tag_name, expr
+            return tag_name, f"{tag_name}[{left_l}='{right_v}']"
+
+        async def _resolve_index(base, tag_name, idx_str):
+            try:
+                idx = int(idx_str)
+            except Exception:
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    f"Invalid {tag_name} index '{idx_str}'",
+                    3,
+                )
+                return None, "fatal"
+            # Retry to wait for iframes to load (mirrors Selenium 5x2s loop).
+            for _ in range(5):
+                try:
+                    count = await base.locator(tag_name).count()
+                except Exception:
+                    count = 0
+                if count and -count <= idx < count:
+                    break
+                await asyncio.sleep(2)
+            else:
+                return None, "not_found"
+            log_idx = idx
+            if idx < 0:
+                idx = count + idx
+            CommonUtil.ExecLog(sModuleInfo, f"Iframe switched to index {log_idx}", 1)
+            return base.frame_locator(tag_name).nth(idx), "passed"
+
+        async def _resolve_selector(base, target):
+            tag_name, selector = _build_selector(target)
+            try:
+                fl = base.frame_locator(selector)
+                # Probe count; Playwright frame_locator does not auto-validate existence here.
+                if await base.locator(selector).count() == 0:
+                    return None, "not_found"
+                CommonUtil.ExecLog(sModuleInfo, "Iframe switched using above Xpath", 1)
+                return fl, "passed"
+            except Exception:
+                return None, "not_found"
+
+        active_stack = []  # list of frame_locators resolved so far
+        pending = frame_targets[:]
+        unknown_parent_hops = 0
+        max_unknown_parent_hops = len(frame_targets) + 5
+
+        def _current_base():
+            return active_stack[-1] if active_stack else current_page
+
+        while pending:
+            switched = False
+            for idx, target in enumerate(pending):
+                base = _current_base()
+                tag_name = "frame" if target["mid"] == "frame parameter" else "iframe"
+                if target["kind"] == "index":
+                    fl, status = await _resolve_index(base, tag_name, target["right"])
+                else:
+                    fl, status = await _resolve_selector(base, target)
+
+                if status == "fatal":
+                    return "zeuz_failed"
+                if status == "passed":
+                    active_stack.append(fl)
+                    pending.pop(idx)
+                    switched = True
+                    unknown_parent_hops = 0
+                    break
+
+            if switched:
+                continue
+
+            if active_stack:
+                # Walk back to parent (mirrors Selenium switch_to.parent_frame()).
+                active_stack.pop()
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    "No matching frame in current context. Switched to parent frame and retrying",
+                    2,
+                )
+                continue
+
+            if switch_to_default:
+                unresolved = [f"{t['left']}={t['right']}" for t in pending]
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    f"Unable to resolve iframe/frame targets: {', '.join(unresolved)}",
+                    3,
+                )
+                return "zeuz_failed"
+
+            unknown_parent_hops += 1
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                "No matching frame in current context. Switched to parent frame and retrying",
+                2,
+            )
+            if unknown_parent_hops > max_unknown_parent_hops:
+                unresolved = [f"{t['left']}={t['right']}" for t in pending]
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    f"Unable to resolve iframe/frame targets from current starting context: {', '.join(unresolved)}",
+                    3,
+                )
+                return "zeuz_failed"
+
+        frame_locator = active_stack[-1] if active_stack else None
         sr.Set_Shared_Variables("playwright_frame", frame_locator)
-        CommonUtil.ExecLog(sModuleInfo, "Switched to iframe", 1)
+        _save_current_playwright_frame(frame_locator)
         return "passed"
 
     except Exception:
@@ -1827,7 +4058,7 @@ def switch_iframe(step_data):
 #########################
 
 @logger
-def Handle_Browser_Alert(step_data):
+async def Handle_Browser_Alert(step_data):
     """
     Handle browser alerts/dialogs.
 
@@ -1871,8 +4102,14 @@ def Handle_Browser_Alert(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "action":
+            if "action" in mid_l:
                 action = right_v.lower()
+                if action.startswith("get text") and "=" in action:
+                    save_variable = right_v.split("=", 1)[1].strip()
+                    action = "accept"
+                elif action.startswith("send text") and "=" in action:
+                    prompt_text = right_v.split("=", 1)[1].strip()
+                    action = "accept"
             elif mid_l == "input parameter":
                 if left_l in ("prompt text", "text", "send text"):
                     prompt_text = right_v
@@ -1882,45 +4119,30 @@ def Handle_Browser_Alert(step_data):
                 if left_l in ("timeout", "wait"):
                     timeout = int(float(right_v) * 1000)
 
-        # Set up dialog handler
-        dialog_info = {"message": None, "handled": False}
-
-        def handle_dialog(dialog):
-            dialog_info["message"] = dialog.message
-            dialog_info["type"] = dialog.type
-
-            if action in ("accept", "ok", "yes"):
-                if prompt_text:
-                    dialog.accept(prompt_text)
-                else:
-                    dialog.accept()
-            elif action in ("dismiss", "cancel", "no"):
-                dialog.dismiss()
-            else:
-                dialog.accept()
-
-            dialog_info["handled"] = True
-
-        current_page.on("dialog", handle_dialog)
-
-        # Wait for dialog
         try:
-            current_page.wait_for_event("dialog", timeout=timeout)
+            dialog = await current_page.wait_for_event("dialog", timeout=timeout)
         except PlaywrightTimeoutError:
-            CommonUtil.ExecLog(sModuleInfo, "No alert appeared within timeout", 2)
-            current_page.remove_listener("dialog", handle_dialog)
-            return "passed"  # Not necessarily a failure
+            CommonUtil.ExecLog(sModuleInfo, "No alert appeared within timeout", 3)
+            return "zeuz_failed"
 
-        # Remove listener
-        current_page.remove_listener("dialog", handle_dialog)
+        message = dialog.message
+        if action in ("accept", "pass", "ok", "yes"):
+            if prompt_text:
+                await dialog.accept(prompt_text)
+            else:
+                await dialog.accept()
+        elif action in ("dismiss", "reject", "fail", "cancel", "no"):
+            await dialog.dismiss()
+        else:
+            await dialog.accept()
 
         # Save text if requested
-        if save_variable and dialog_info["message"]:
-            sr.Set_Shared_Variables(save_variable, dialog_info["message"])
+        if save_variable and message:
+            sr.Set_Shared_Variables(save_variable, message)
 
         CommonUtil.ExecLog(
             sModuleInfo,
-            f"Alert handled ({action}): {dialog_info.get('message', 'N/A')}",
+            f"Alert handled ({action}): {message or 'N/A'}",
             1
         )
         return "passed"
@@ -1936,15 +4158,30 @@ def handle_dialog(dialog):
 #########################
 
 @logger
-def drag_and_drop(step_data):
+async def drag_and_drop(step_data):
     """
-    Drag and drop an element to a target.
-
-    Example:
-        Field               Sub Field           Value
-        id                  element parameter   drag-item
-        id                  target parameter    drop-zone
-        drag and drop       playwright action   drag and drop
+    Drag and drop a source element to a destination element.
+
+    Example 1 - Basic (src + dst):
+        Field               Sub Field               Value
+        id                  src element parameter   drag-item
+        id                  dst element parameter   drop-zone
+        drag and drop       playwright action       drag and drop
+
+    Example 2 - With destination offset and hold delay:
+        Field               Sub Field               Value
+        id                  src element parameter   drag-item
+        id                  dst element parameter   drop-zone
+        destination offset  optional parameter      20,0
+        delay               optional parameter      0.5
+        drag and drop       playwright action       drag and drop
+
+    Supported param prefixes (matches Selenium): src / source / dst / destination.
+    Supported scopes: element parameter, parent parameter, child parameter, sibling parameter.
+
+    destination offset: "x,y" as percentage of half the destination's size from its center
+                       (e.g. "20,0" = 20% right of center).
+    delay: seconds to pause between click-and-hold and release (mouse-step pattern).
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global current_page
@@ -1954,35 +4191,121 @@ def drag_and_drop(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
-        # Separate source and target parameters
-        source_params = []
-        target_params = []
+        source = []
+        destination = []
+        destination_offset = None
+        delay = None
+        param_dict = {
+            "elementparameter": "element parameter",
+            "parentparameter": "parent parameter",
+            "siblingparameter": "sibling parameter",
+            "childparameter": "child parameter",
+            "optionalparameter": "optional parameter",
+        }
 
         for left, mid, right in step_data:
-            mid_l = mid.strip().lower()
-            if mid_l == "target parameter":
-                target_params.append((left, "element parameter", right))
-            elif mid_l == "element parameter":
-                source_params.append((left, mid, right))
-            else:
-                source_params.append((left, mid, right))
-                target_params.append((left, mid, right))
+            mid_clean = mid.strip().lower()
+            left_l = left.strip().lower()
+            if mid_clean.startswith("src") or mid_clean.startswith("source"):
+                key = mid_clean.replace("src", "", 1) if mid_clean.startswith("src") else mid_clean.replace("source", "", 1)
+                key = key.replace(" ", "")
+                if key in param_dict:
+                    source.append((left, param_dict[key], right))
+            elif mid_clean.startswith("dst") or mid_clean.startswith("destination"):
+                key = mid_clean.replace("dst", "", 1) if mid_clean.startswith("dst") else mid_clean.replace("destination", "", 1)
+                key = key.replace(" ", "")
+                if key in param_dict:
+                    destination.append((left, param_dict[key], right))
+            elif left_l in ("wait", "allow disable", "allow hidden") and mid_clean == "option":
+                source.append((left, mid, right))
+                destination.append((left, mid, right))
+            elif left_l == "destination offset" and mid_clean == "optional parameter":
+                destination_offset = right.strip()
+            elif left_l == "delay" and mid_clean == "optional parameter":
+                try:
+                    delay = float(right.strip())
+                except ValueError:
+                    delay = None
+
+        if not source:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                'Please provide source element with "src element parameter", "src parent parameter" etc. Example:\n'
+                "(id, src element parameter, file)",
+                3,
+            )
+            return "zeuz_failed"
+
+        if not destination:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                'Please provide Destination element with "dst element parameter", "dst parent parameter" etc. Example:\n'
+                "(id, dst element parameter, table)",
+                3,
+            )
+            return "zeuz_failed"
 
-        # Get source element
-        source_locator = PlaywrightLocator.Get_Element(source_params, current_page)
+        frame = _get_frame_locator()
+        action_timeout = PlaywrightLocator.Get_Timeout(source)
+        target_timeout = PlaywrightLocator.Get_Timeout(destination)
+        source_locator = await PlaywrightLocator.Get_Element(
+            source,
+            current_page,
+            frame_locator=frame,
+            resolve=False,
+        )
         if source_locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Source element not found", 3)
+            CommonUtil.ExecLog(sModuleInfo, "Source Element is not found", 3)
             return "zeuz_failed"
 
-        # Get target element
-        target_locator = PlaywrightLocator.Get_Element(target_params, current_page)
+        target_locator = await PlaywrightLocator.Get_Element(
+            destination,
+            current_page,
+            frame_locator=frame,
+            resolve=False,
+        )
         if target_locator == "zeuz_failed":
-            CommonUtil.ExecLog(sModuleInfo, "Target element not found", 3)
+            CommonUtil.ExecLog(sModuleInfo, "Destination Element is not found", 3)
             return "zeuz_failed"
 
-        # Perform drag and drop
-        source_locator.drag_to(target_locator)
-        CommonUtil.ExecLog(sModuleInfo, "Drag and drop completed", 1)
+        if destination_offset or delay is not None:
+            # Manual mouse-step path so we can apply offset and/or a hold delay.
+            await source_locator.scroll_into_view_if_needed(timeout=action_timeout)
+            src_box = await source_locator.bounding_box(timeout=action_timeout)
+            await target_locator.scroll_into_view_if_needed(timeout=target_timeout)
+            tgt_box = await target_locator.bounding_box(timeout=target_timeout)
+            if not src_box or not tgt_box:
+                CommonUtil.ExecLog(sModuleInfo, "Could not compute bounding box for drag and drop", 3)
+                return "zeuz_failed"
+
+            src_x = src_box["x"] + src_box["width"] / 2
+            src_y = src_box["y"] + src_box["height"] / 2
+
+            tgt_center_x = tgt_box["x"] + tgt_box["width"] / 2
+            tgt_center_y = tgt_box["y"] + tgt_box["height"] / 2
+            if destination_offset:
+                try:
+                    parts = destination_offset.replace(" ", "").split(",")
+                    pct_x = float(parts[0])
+                    pct_y = float(parts[1])
+                    tgt_x = tgt_center_x + (tgt_box["width"] / 2.0) * (pct_x / 100.0)
+                    tgt_y = tgt_center_y + (tgt_box["height"] / 2.0) * (pct_y / 100.0)
+                except (ValueError, IndexError):
+                    tgt_x, tgt_y = tgt_center_x, tgt_center_y
+            else:
+                tgt_x, tgt_y = tgt_center_x, tgt_center_y
+
+            await current_page.mouse.move(src_x, src_y)
+            await current_page.mouse.down()
+            # Intermediate steps help frameworks that listen for dragover events.
+            await current_page.mouse.move(tgt_x, tgt_y, steps=10)
+            if delay is not None:
+                await asyncio.sleep(delay)
+            await current_page.mouse.up()
+        else:
+            await source_locator.drag_to(target_locator, timeout=action_timeout)
+
+        CommonUtil.ExecLog(sModuleInfo, "Drag and drop completed from source to destination", 1)
         return "passed"
 
     except Exception:
@@ -1996,7 +4319,7 @@ def drag_and_drop(step_data):
 #########################
 
 @logger
-def take_screenshot_playwright(step_data):
+async def take_screenshot_playwright(step_data):
     """
     Take a screenshot.
 
@@ -2023,41 +4346,75 @@ def take_screenshot_playwright(step_data):
         save_variable = None
         custom_path = None
         has_element = False
+        image_type = "jpeg"
+        image_quality = CommonUtil.PLAYWRIGHT_AUTO_SCREENSHOT_QUALITY
 
         for left, mid, right in step_data:
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "element parameter":
+            if _is_action_mid(mid_l) and left_l == "take screenshot web":
+                if not _is_placeholder(right_v, "take screenshot web"):
+                    custom_path = time.strftime(right_v) + ".png"
+                    image_type = "png"
+            elif mid_l == "element parameter":
                 has_element = True
             elif mid_l == "optional parameter":
                 if left_l in ("fullscreen", "full page", "fullpage"):
                     full_page = right_v.lower() in ("true", "yes", "1")
                 elif left_l == "path":
                     custom_path = right_v
+                elif left_l in ("format", "type", "image type"):
+                    image_type = right_v.lower().replace("jpg", "jpeg")
+                elif left_l == "quality":
+                    image_quality = int(right_v)
             elif mid_l == "save parameter":
                 save_variable = left.strip()
 
+        if image_type not in ("jpeg", "png"):
+            CommonUtil.ExecLog(sModuleInfo, f"Unsupported screenshot format '{image_type}'. Use jpeg or png.", 3)
+            return "zeuz_failed"
+
         # Generate filename
         if custom_path:
             screenshot_path = custom_path
+            suffix = Path(screenshot_path).suffix.lower()
+            if suffix in (".png", ".jpg", ".jpeg"):
+                image_type = "png" if suffix == ".png" else "jpeg"
+            else:
+                screenshot_path = str(Path(screenshot_path).with_suffix(".jpg" if image_type == "jpeg" else ".png"))
         else:
             timestamp = time.strftime("%Y_%m_%d_%H-%M-%S")
-            screenshot_path = f"screenshot_{timestamp}.png"
+            screenshot_path = str(Path(_screenshot_folder()) / f"screenshot_{timestamp}.{'jpg' if image_type == 'jpeg' else 'png'}")
+
+        if not Path(screenshot_path).is_absolute():
+            screenshot_path = str(Path(_screenshot_folder()) / screenshot_path)
+
+        screenshot_options = {"path": screenshot_path, "type": image_type}
+        if image_type == "jpeg":
+            screenshot_options["quality"] = image_quality
 
         # Take screenshot
         if has_element:
-            locator = PlaywrightLocator.Get_Element(step_data, current_page)
+            screenshot_options["timeout"] = PlaywrightLocator.Get_Timeout(step_data)
+            locator = await PlaywrightLocator.Get_Element(
+                step_data,
+                current_page,
+                frame_locator=_get_frame_locator(),
+                resolve=False,
+            )
             if locator == "zeuz_failed":
                 CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
                 return "zeuz_failed"
-            locator.screenshot(path=screenshot_path)
+            await locator.screenshot(**screenshot_options)
         else:
-            current_page.screenshot(path=screenshot_path, full_page=full_page)
+            screenshot_options["full_page"] = full_page
+            await current_page.screenshot(**screenshot_options)
 
         if save_variable:
             sr.Set_Shared_Variables(save_variable, screenshot_path)
+        sr.Set_Shared_Variables("zeuz_screenshot", Path(screenshot_path).name)
 
         CommonUtil.ExecLog(sModuleInfo, f"Screenshot saved: {screenshot_path}", 1)
         return "passed"
@@ -2073,7 +4430,7 @@ def take_screenshot_playwright(step_data):
 #########################
 
 @logger
-def execute_javascript(step_data):
+async def execute_javascript(step_data):
     """
     Execute JavaScript code in the browser.
 
@@ -2104,27 +4461,45 @@ def execute_javascript(step_data):
         for left, mid, right in step_data:
             left_l = left.strip().lower()
             mid_l = mid.strip().lower()
+            right_v = right.strip()
 
-            if mid_l == "action":
-                js_code = right
-            elif mid_l == "element parameter":
+            if _is_session_step_row(left, mid):
+                continue
+            if "javascript" in left_l or (_is_action_mid(mid_l) and left_l == "execute javascript"):
+                js_code = right_v
+            elif _is_element_parameter_mid(mid):
                 has_element = True
             elif mid_l == "save parameter":
                 save_variable = left.strip()
+            elif mid_l == "optional parameter" and left_l == "variable":
+                save_variable = right_v
 
         if not js_code:
             CommonUtil.ExecLog(sModuleInfo, "No JavaScript code provided", 3)
             return "zeuz_failed"
 
+        action_timeout = PlaywrightLocator.Get_Timeout(step_data)
+
         # Execute JS
         if has_element:
-            locator = PlaywrightLocator.Get_Element(step_data, current_page)
+            locator = await PlaywrightLocator.Get_Element(
+                step_data,
+                current_page,
+                frame_locator=_get_frame_locator(),
+                resolve=False,
+            )
             if locator == "zeuz_failed":
                 CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
                 return "zeuz_failed"
-            result = locator.evaluate(js_code)
+            if "$elem" in js_code:
+                element_script = js_code.replace("$elem", "el")
+                result = await locator.evaluate(f"el => {{ {element_script} }}", timeout=action_timeout)
+            else:
+                result = await locator.evaluate(js_code, timeout=action_timeout)
         else:
-            result = current_page.evaluate(js_code)
+            if js_code.strip().startswith("return "):
+                js_code = f"() => {{ {js_code} }}"
+            result = await current_page.evaluate(js_code)
 
         if save_variable:
             sr.Set_Shared_Variables(save_variable, result)
@@ -2145,7 +4520,7 @@ def execute_javascript(step_data):
 #########################
 
 @logger
-def upload_file(step_data):
+async def upload_file(step_data):
     """
     Upload a file via file input.
 
@@ -2170,7 +4545,9 @@ def upload_file(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "input parameter":
+            if _is_action_mid(mid_l) and left_l == "upload file" and not _is_placeholder(right_v, "upload file"):
+                file_path = right_v
+            elif mid_l == "input parameter":
                 if left_l in ("file path", "filepath", "file", "path"):
                     file_path = right_v
 
@@ -2188,12 +4565,19 @@ def upload_file(step_data):
                 CommonUtil.ExecLog(sModuleInfo, f"File not found: {file_path}", 3)
                 return "zeuz_failed"
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        action_timeout = PlaywrightLocator.Get_Timeout(step_data)
+
+        locator = await PlaywrightLocator.Get_Element(
+            step_data,
+            current_page,
+            frame_locator=_get_frame_locator(),
+            resolve=False,
+        )
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
             return "zeuz_failed"
 
-        locator.set_input_files(file_path)
+        await locator.set_input_files(file_path, timeout=action_timeout)
         CommonUtil.ExecLog(sModuleInfo, f"File uploaded: {file_path}", 1)
         return "passed"
 
@@ -2201,6 +4585,81 @@ def upload_file(step_data):
         return CommonUtil.Exception_Handler(sys.exc_info())
 
 
+@logger
+async def copy_image_into_browser(data_set):
+    """Copy a PNG/SVG image into the browser clipboard."""
+
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page, context
+
+    try:
+        if current_page is None:
+            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+            return "zeuz_failed"
+
+        image_path = ""
+        variable_name = ""
+        for left, mid, right in data_set:
+            left_c = _compact(left)
+            right_v = right.strip()
+            if left_c == "imagefile":
+                image_path = right_v if os.path.exists(right_v) else CommonUtil.path_parser(right_v)
+            elif left_c == "imagevariable":
+                if os.path.exists(right_v):
+                    image_path = right_v
+                else:
+                    variable_name = right_v
+
+        if not image_path and variable_name:
+            image_path = sr.Get_Shared_Variables(variable_name)
+        if not image_path:
+            CommonUtil.ExecLog(sModuleInfo, "Must provide either 'image file' or 'image variable'", 3)
+            return "zeuz_failed"
+        if not os.path.exists(image_path):
+            CommonUtil.ExecLog(sModuleInfo, f"Image file not found: {image_path}", 3)
+            return "zeuz_failed"
+
+        image_l = image_path.lower()
+        if image_l.endswith(".svg"):
+            mime_type = "image/svg+xml"
+        elif image_l.endswith(".png"):
+            mime_type = "image/png"
+        else:
+            CommonUtil.ExecLog(sModuleInfo, "Unsupported file format. You can copy only PNG or SVG image.", 2)
+            return "zeuz_failed"
+
+        if context:
+            try:
+                parsed = urlparse(current_page.url)
+                origin = f"{parsed.scheme}://{parsed.netloc}" if parsed.scheme and parsed.netloc else None
+                await context.grant_permissions(["clipboard-read", "clipboard-write"], origin=origin)
+            except Exception:
+                pass
+
+        image_b64 = base64.b64encode(Path(image_path).read_bytes()).decode("utf-8")
+        success = await current_page.evaluate("""async ({ imageB64, mimeType }) => {
+            const byteCharacters = atob(imageB64);
+            const byteArrays = [];
+            for (let offset = 0; offset < byteCharacters.length; offset += 512) {
+                const slice = byteCharacters.slice(offset, offset + 512);
+                const byteNumbers = new Array(slice.length);
+                for (let i = 0; i < slice.length; i++) byteNumbers[i] = slice.charCodeAt(i);
+                byteArrays.push(new Uint8Array(byteNumbers));
+            }
+            const blob = new Blob(byteArrays, { type: mimeType });
+            window.focus();
+            await navigator.clipboard.write([new ClipboardItem({ [mimeType]: blob })]);
+            return true;
+        }""", {"imageB64": image_b64, "mimeType": mime_type})
+        if success:
+            CommonUtil.ExecLog(sModuleInfo, f"Image copied to clipboard: {image_path}", 1)
+            return "passed"
+        CommonUtil.ExecLog(sModuleInfo, f"Failed to copy image to clipboard: {image_path}", 3)
+        return "zeuz_failed"
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
+
+
 #########################
 #                       #
 #    Window Resize      #
@@ -2208,7 +4667,7 @@ def upload_file(step_data):
 #########################
 
 @logger
-def resize_window(step_data):
+async def resize_window(step_data):
     """
     Resize the browser viewport.
 
@@ -2234,7 +4693,7 @@ def resize_window(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "input parameter":
+            if mid_l in ("input parameter", "element parameter"):
                 if left_l == "width":
                     # Handle percentage
                     if "%" in right_v:
@@ -2257,7 +4716,7 @@ def resize_window(step_data):
             width = width or current_size["width"]
             height = height or current_size["height"]
 
-        current_page.set_viewport_size({"width": width, "height": height})
+        await current_page.set_viewport_size({"width": width, "height": height})
         CommonUtil.ExecLog(sModuleInfo, f"Window resized to {width}x{height}", 1)
         return "passed"
 
@@ -2272,23 +4731,30 @@ def resize_window(step_data):
 #########################
 
 @logger
-def Wait_For_Element(step_data):
+async def Wait_For_Element(step_data):
     """
-    Wait for an element to appear/disappear.
+    Wait for an element to appear/disappear/attach/detach.
 
-    Example 1 - Wait for visible:
+    Example 1 - Wait for visible with explicit timeout (seconds):
+        Field               Sub Field           Value
+        id                  element parameter   results
+        wait for element    playwright action   30
+
+    Example 2 - Wait for hidden:
         Field               Sub Field           Value
         id                  element parameter   loading-spinner
         wait                input parameter     hidden
         wait for element    playwright action   wait for element
 
-    Example 2 - Wait with timeout:
+    Example 3 - Timeout via optional parameter:
         Field               Sub Field           Value
         id                  element parameter   results
         timeout             optional parameter  30
+        state               input parameter     visible
         wait for element    playwright action   wait for element
 
-    States: attached, detached, visible, hidden
+    States: attached, detached, visible, hidden (default: visible)
+    Timeout: seconds (defaults to element_wait shared variable, or 10s)
     """
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global current_page
@@ -2298,8 +4764,10 @@ def Wait_For_Element(step_data):
             CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
             return "zeuz_failed"
 
-        state = "visible"
-        timeout = None
+        inferred_state = "visible"
+        explicit_state = None
+        timeout_sec = None
+        allow_hidden = False
 
         for left, mid, right in step_data:
             left_l = left.strip().lower()
@@ -2308,31 +4776,60 @@ def Wait_For_Element(step_data):
 
             if mid_l == "input parameter":
                 if left_l in ("wait", "state"):
-                    state = right_v.lower()
-            elif mid_l == "optional parameter":
-                if left_l == "timeout":
-                    timeout = int(float(right_v) * 1000)
+                    explicit_state = right_v.lower()
+            elif mid_l == "optional parameter" and left_l == "timeout":
+                try:
+                    timeout_sec = float(right_v)
+                except ValueError:
+                    pass
+            elif mid_l in ("optional parameter", "option") and left_l == "allow hidden":
+                allow_hidden = right_v.lower() in ("yes", "true", "ok", "enable", "enabled", "1")
+            elif "action" in mid_l and left_l in ("wait", "wait disable", "wait for element"):
+                if left_l == "wait disable":
+                    inferred_state = "hidden"
+                # Selenium-style: action value carries the timeout in seconds.
+                try:
+                    timeout_sec = float(right_v)
+                except ValueError:
+                    pass
+
+        state = explicit_state or inferred_state
+        if explicit_state is None and allow_hidden:
+            if inferred_state == "visible":
+                state = "attached"
+            elif inferred_state == "hidden":
+                state = "detached"
+
+        if timeout_sec is None:
+            default_wait = sr.Get_Shared_Variables("element_wait")
+            if default_wait not in failed_tag_list:
+                try:
+                    timeout_sec = float(default_wait)
+                except (TypeError, ValueError):
+                    timeout_sec = 10
+            else:
+                timeout_sec = 10
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page, element_wait=0.1)
+        timeout_ms = int(timeout_sec * 1000)
 
-        if locator == "zeuz_failed":
-            # For hidden/detached states, element not found is actually success
-            if state in ("hidden", "detached"):
-                CommonUtil.ExecLog(sModuleInfo, f"Element already {state}", 1)
-                return "passed"
-            CommonUtil.ExecLog(sModuleInfo, "Element not found", 3)
+        try:
+            result = await PlaywrightLocator.wait_for_element(
+                step_data,
+                current_page,
+                state=state,
+                timeout=timeout_ms,
+                frame_locator=_get_frame_locator(),
+            )
+            if result == "zeuz_failed":
+                return "zeuz_failed"
+            CommonUtil.ExecLog(sModuleInfo, f"Element reached state: {state}", 1)
+            return "passed"
+        except PlaywrightTimeoutError:
+            CommonUtil.ExecLog(sModuleInfo, f"Timeout waiting for element to be {state}", 3)
             return "zeuz_failed"
 
-        wait_options = {"state": state}
-        if timeout:
-            wait_options["timeout"] = timeout
-
-        locator.wait_for(**wait_options)
-        CommonUtil.ExecLog(sModuleInfo, f"Element reached state: {state}", 1)
-        return "passed"
-
     except PlaywrightTimeoutError:
-        CommonUtil.ExecLog(sModuleInfo, f"Timeout waiting for element to be {state}", 3)
+        CommonUtil.ExecLog(sModuleInfo, "Timeout waiting for element", 3)
         return "zeuz_failed"
     except Exception:
         return CommonUtil.Exception_Handler(sys.exc_info())
@@ -2345,7 +4842,7 @@ def Wait_For_Element(step_data):
 #########################
 
 @logger
-def Start_Tracing(step_data):
+async def Start_Tracing(step_data):
     """
     Start Playwright trace recording.
 
@@ -2380,7 +4877,7 @@ def Start_Tracing(step_data):
                 elif left_l == "sources":
                     sources = right_v in ("true", "yes", "1")
 
-        context.tracing.start(
+        await context.tracing.start(
             screenshots=screenshots,
             snapshots=snapshots,
             sources=sources
@@ -2393,7 +4890,7 @@ def Start_Tracing(step_data):
 
 
 @logger
-def Stop_Tracing(step_data):
+async def Stop_Tracing(step_data):
     """
     Stop tracing and save trace file.
 
@@ -2420,7 +4917,7 @@ def Stop_Tracing(step_data):
             if mid_l == "input parameter" and left_l == "path":
                 trace_path = right_v
 
-        context.tracing.stop(path=trace_path)
+        await context.tracing.stop(path=trace_path)
         CommonUtil.ExecLog(sModuleInfo, f"Trace saved to: {trace_path}", 1)
         return "passed"
 
@@ -2429,7 +4926,121 @@ def Stop_Tracing(step_data):
 
 
 @logger
-def Intercept_Network(step_data):
+async def capture_network_log(step_data):
+    """Capture request/response metadata and save filtered network logs."""
+
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+    global current_page, current_page_id, network_log_details
+
+    def parse_status_codes(code_str):
+        result = []
+        for part in code_str.split(","):
+            part = part.strip()
+            if "-" in part:
+                start, end = map(int, part.split("-"))
+                result.extend(range(start, end + 1))
+            elif part:
+                result.append(int(part))
+        return result
+
+    try:
+        if current_page is None:
+            CommonUtil.ExecLog(sModuleInfo, "No browser open", 3)
+            return "zeuz_failed"
+
+        params = {
+            "variable_name": None,
+            "mode": None,
+            "filter_domains": [],
+            "status_filter": [],
+            "method_filter": [],
+            "include_body": False,
+        }
+        for left, mid, right in step_data:
+            left_l = left.lower().strip()
+            if left_l == "capture network log":
+                params["mode"] = right.lower().strip()
+            elif left_l == "save":
+                params["variable_name"] = right.strip()
+            elif left_l == "filter domain":
+                params["filter_domains"] = [d.strip() for d in right.split(",")]
+            elif left_l == "include status code":
+                params["status_filter"] = parse_status_codes(right.strip())
+            elif left_l == "include request method":
+                params["method_filter"] = [m.strip().upper() for m in right.split(",")]
+            elif left_l == "include response body":
+                params["include_body"] = _truthy(right)
+
+        session_key = current_page_id or "default"
+        if params["mode"] == "start":
+            requests = {}
+            events = []
+
+            async def on_request(request):
+                requests[id(request)] = request
+
+            async def on_response(response):
+                request = response.request
+                entry = {
+                    "url": response.url,
+                    "status": response.status,
+                    "method": request.method,
+                    "mimeType": response.headers.get("content-type", ""),
+                    "type": request.resource_type,
+                    "timestamp": time.time(),
+                }
+                if params["include_body"]:
+                    try:
+                        entry["body"] = await response.text()
+                    except Exception:
+                        entry["body"] = "Unavailable"
+                events.append(entry)
+
+            current_page.on("request", on_request)
+            current_page.on("response", on_response)
+            network_log_details[session_key] = {"events": events, "on_request": on_request, "on_response": on_response}
+            CommonUtil.ExecLog(sModuleInfo, "Started collecting network logs...", 1)
+            return "passed"
+
+        if params["mode"] == "stop":
+            state = network_log_details.pop(session_key, {"events": []})
+            try:
+                current_page.remove_listener("request", state.get("on_request"))
+                current_page.remove_listener("response", state.get("on_response"))
+            except Exception:
+                pass
+
+            excluded_ext = (".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".woff", ".woff2", ".ttf", ".eot", ".webp", ".map", ".txt")
+            excluded_mime = ("image/", "font/", "text/css", "application/javascript", "text/javascript", "application/font-", "application/x-font-")
+            api_logs = []
+            for entry in state.get("events", []):
+                url = entry.get("url", "")
+                mime_type = entry.get("mimeType", "")
+                if any(url.endswith(ext) for ext in excluded_ext) or any(mime_type.startswith(prefix) for prefix in excluded_mime):
+                    continue
+                if params["filter_domains"]:
+                    domain = urlparse(url).netloc
+                    if not any(d in domain for d in params["filter_domains"]):
+                        continue
+                if params["method_filter"] and entry.get("method", "").upper() not in params["method_filter"]:
+                    continue
+                if params["status_filter"] and entry.get("status") not in params["status_filter"]:
+                    continue
+                api_logs.append(entry)
+
+            if params["variable_name"]:
+                sr.Set_Shared_Variables(params["variable_name"], api_logs)
+                CommonUtil.ExecLog(sModuleInfo, f"Saved {len(api_logs)} network events to '{params['variable_name']}'", 1)
+            return "passed"
+
+        CommonUtil.ExecLog(sModuleInfo, "Mode must be start or stop", 3)
+        return "zeuz_failed"
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info(), None, "Could not collect network logs")
+
+
+@logger
+async def Intercept_Network(step_data):
     """
     Set up network request interception.
 
@@ -2466,23 +5077,23 @@ def Intercept_Network(step_data):
                     response_body = right_v
                 elif left_l == "response status":
                     response_status = int(right_v)
-            elif mid_l == "action":
+            elif "action" in mid_l:
                 action = right_v.lower()
 
-        def handle_route(route):
+        async def handle_route(route):
             if action == "abort":
-                route.abort()
+                await route.abort()
             elif action == "fulfill":
                 fulfill_options = {}
                 if response_body:
                     fulfill_options["body"] = response_body
                 if response_status:
                     fulfill_options["status"] = response_status
-                route.fulfill(**fulfill_options)
+                await route.fulfill(**fulfill_options)
             else:
-                route.continue_()
+                await route.continue_()
 
-        current_page.route(url_pattern, handle_route)
+        await current_page.route(url_pattern, handle_route)
         CommonUtil.ExecLog(sModuleInfo, f"Network interception set up for: {url_pattern}", 1)
         return "passed"
 
@@ -2497,7 +5108,7 @@ def handle_route(route):
 #########################
 
 @logger
-def Extract_Table_Data(step_data):
+async def Extract_Table_Data(step_data):
     """
     Extract data from an HTML table.
 
@@ -2524,7 +5135,9 @@ def Extract_Table_Data(step_data):
             mid_l = mid.strip().lower()
             right_v = right.strip()
 
-            if mid_l == "save parameter":
+            if _is_action_mid(mid_l) and left_l == "extract table data" and not _is_placeholder(right_v, "extract table data"):
+                save_variable = right_v
+            elif mid_l == "save parameter":
                 save_variable = left.strip()
             elif mid_l == "optional parameter":
                 if left_l == "row":
@@ -2532,13 +5145,19 @@ def Extract_Table_Data(step_data):
                 elif left_l == "column":
                     col_filter = right_v
 
-        locator = PlaywrightLocator.Get_Element(step_data, current_page)
+        action_timeout = PlaywrightLocator.Get_Timeout(step_data)
+        locator = await PlaywrightLocator.Get_Element(
+            step_data,
+            current_page,
+            frame_locator=_get_frame_locator(),
+            resolve=False,
+        )
         if locator == "zeuz_failed":
             CommonUtil.ExecLog(sModuleInfo, "Table element not found", 3)
             return "zeuz_failed"
 
         # Extract table data using JavaScript
-        table_data = locator.evaluate("""table => {
+        table_data = await locator.evaluate("""table => {
             const data = [];
             const rows = table.querySelectorAll('tr');
             rows.forEach(row => {
@@ -2552,7 +5171,18 @@ def Extract_Table_Data(step_data):
                 }
             });
             return data;
-        }""")
+        }""", timeout=action_timeout)
+
+        if row_filter and "," not in row_filter and "-" not in row_filter:
+            try:
+                table_data = [table_data[int(row_filter.replace(" ", ""))]]
+            except Exception:
+                table_data = eval("table_data[%s]" % row_filter.replace(" ", ""))
+        if col_filter and "," not in col_filter and "-" not in col_filter:
+            try:
+                table_data = [[row[int(col_filter.replace(" ", ""))]] for row in table_data]
+            except Exception:
+                table_data = [eval("row[%s]" % col_filter.replace(" ", "")) for row in table_data]
 
         if save_variable:
             sr.Set_Shared_Variables(save_variable, table_data)
diff --git a/Framework/Built_In_Automation/Web/Playwright/locator.py b/Framework/Built_In_Automation/Web/Playwright/locator.py
index 5e7420d83..5ebd290f4 100644
--- a/Framework/Built_In_Automation/Web/Playwright/locator.py
+++ b/Framework/Built_In_Automation/Web/Playwright/locator.py
@@ -2,32 +2,47 @@
 """
 Playwright Element Locator Module
 
-This module provides element location functionality using Playwright's native
-Locator API while reusing the query building logic from LocateElement.py.
-
-Key Features:
-- Native Playwright Locator API (lazy evaluation, auto-wait)
-- Supports all existing element parameter formats
-- Supports Playwright-native selectors (test-id, role, text, etc.)
-- Preserves Playwright's speed advantage
+This module resolves the standard Zeuz element step-data format to Playwright
+Locator objects. Selenium compatibility is the primary contract: Selenium-style
+element parameters are converted through LocateElement.py's query builder, then
+executed with Playwright's Locator API.
 """
 
-import sys
 import inspect
 import re
+import sys
+from dataclasses import dataclass
+from typing import Any
 
-from Framework.Utilities import CommonUtil
 from Framework.Built_In_Automation.Shared_Resources import (
     BuiltInFunctionSharedResources as sr,
 )
-from Framework.Utilities.CommonUtil import passed_tag_list, failed_tag_list
+from Framework.Utilities import CommonUtil
+from Framework.Utilities.CommonUtil import failed_tag_list
 
 MODULE_NAME = inspect.getmodulename(__file__)
 
 
-def Get_Element(step_data, page, return_all=False, element_wait=None):
+@dataclass
+class LocatorBuildResult:
+    locator: Any
+    query_type: str
+    query: Any
+
+
+async def Get_Element(
+    step_data,
+    page,
+    return_all=False,
+    element_wait=None,
+    frame_locator=None,
+    parent_locator=None,
+    return_all_elements=False,
+    resolve=True,
+    log_outer_html=False,
+):
     """
-    Get element using Playwright's native Locator API.
+    Resolve Zeuz step-data to a Playwright Locator.
 
     This function parses the same step_data format as LocateElement.Get_Element()
     but uses Playwright's Locator API for execution, preserving auto-wait and
@@ -38,6 +53,8 @@ def Get_Element(step_data, page, return_all=False, element_wait=None):
         page: Playwright Page object
         return_all: If True, return list of all matching ElementHandles
         element_wait: Override default wait timeout (in seconds)
+        frame_locator: Optional frame locator for iframe context
+        parent_locator: Optional Locator to scope the search under a container element
 
     Returns:
         Locator | List[ElementHandle] | "zeuz_failed"
@@ -49,188 +66,230 @@ def Get_Element(step_data, page, return_all=False, element_wait=None):
         ]
         locator = Get_Element(step_data, page)
         locator.click()  # Auto-waits for element
+
+    The returned object intentionally mirrors Selenium LocateElement.Get_Element()
+    semantics where possible: visible elements are preferred by default, multiple
+    matches return the first match unless an index is provided, save/get parameter
+    rows use shared variables, and failures return "zeuz_failed".
     """
+
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
 
     try:
-        # Parse all parameters from step_data
+        if return_all_elements:
+            return_all = True
+
         params = _parse_element_params(step_data)
+        if params.get("parse_error"):
+            CommonUtil.ExecLog(sModuleInfo, params["parse_error"], 3)
+            return "zeuz_failed"
 
-        # Check for get parameter (retrieve saved element)
-        if params.get('get_parameter'):
-            result = sr.parse_variable(params['get_parameter'])
+        if params.get("get_parameter"):
+            result = sr.parse_variable(params["get_parameter"])
+            result = CommonUtil.ZeuZ_map_code_decoder(result)
             if result not in failed_tag_list:
                 CommonUtil.ExecLog(
                     sModuleInfo,
-                    f"Returning saved element '{params['get_parameter']}' from shared variables",
+                    "Returning saved element '%s' from shared variables" % params["get_parameter"],
                     1,
                 )
                 return result
-            else:
-                CommonUtil.ExecLog(
-                    sModuleInfo,
-                    f"Element '{params['get_parameter']}' not found in shared variables",
-                    3,
-                )
-                return "zeuz_failed"
 
-        # Build the locator
-        locator = _build_locator(page, step_data, params)
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                "Element named '%s' not found in shared variables" % params["get_parameter"],
+                3,
+            )
+            return "zeuz_failed"
 
-        if locator is None:
+        timeout = _resolve_timeout(params, element_wait)
+        build_result = _build_locator(page, step_data, params, frame_locator, parent_locator)
+        if build_result is None or build_result.locator is None:
             CommonUtil.ExecLog(sModuleInfo, "Could not build locator from step data", 3)
             return "zeuz_failed"
 
-        # Set timeout if specified
-        if element_wait is not None:
-            timeout = int(float(element_wait) * 1000)
-        elif params.get('wait') is not None:
-            timeout = int(float(params['wait']) * 1000)
-        else:
-            # Get default from shared variables
-            default_wait = sr.Get_Shared_Variables("element_wait")
-            if default_wait not in failed_tag_list:
-                timeout = int(float(default_wait) * 1000)
-            else:
-                timeout = 10000  # Default 10 seconds
-
-        # Apply visibility filter if not allowing hidden
-        if not params.get('allow_hidden'):
-            # Filter to visible elements only
-            locator = locator.locator("visible=true")
-
-        # Apply index if specified
-        if params.get('index') is not None:
-            index = params['index']
-            locator = locator.nth(index)
-
-        # Log the locator being used
-        CommonUtil.ExecLog(sModuleInfo, f"Playwright locator: {locator}", 5)
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"To locate the Element we used {build_result.query_type}:\n{build_result.query}",
+            5,
+        )
 
-        # Save if requested
-        if params.get('save_parameter'):
-            sr.Set_Shared_Variables(params['save_parameter'], locator)
-            CommonUtil.ExecLog(
-                sModuleInfo,
-                f"Saved element to variable '{params['save_parameter']}'",
-                1,
-            )
+        must_resolve = _requires_resolved_lookup(params, return_all)
+        if not resolve and not must_resolve:
+            result = _first_locator(_effective_locator(build_result.locator, params))
+            if params.get("save_parameter"):
+                sr.Set_Shared_Variables(params["save_parameter"], result)
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    "Saved element to variable '%s'" % params["save_parameter"],
+                    1,
+                )
+            sr.Set_Shared_Variables("zeuz_element", result)
+            return result
 
-        # Return all elements if requested
         if return_all:
-            try:
-                elements = locator.all()
-                CommonUtil.ExecLog(sModuleInfo, f"Found {len(elements)} elements", 1)
-                return elements
-            except Exception as e:
-                CommonUtil.ExecLog(sModuleInfo, f"Error getting all elements: {e}", 3)
-                return "zeuz_failed"
-
-        # Check if element exists (with timeout)
-        try:
-            count = locator.count()
-            if count == 0:
-                CommonUtil.ExecLog(sModuleInfo, "No elements found matching locator", 3)
-                return "zeuz_failed"
-            elif count > 1 and params.get('index') is None:
+            result = await _resolve_all(build_result.locator, params, timeout, sModuleInfo)
+            if not result and params.get("text_filter"):
+                result = await _text_filter(step_data, page, frame_locator, params, timeout, return_all)
+        else:
+            result = await _resolve_single(build_result.locator, params, timeout, sModuleInfo)
+            if result == "zeuz_failed" and params.get("text_filter"):
+                result = await _text_filter(step_data, page, frame_locator, params, timeout, return_all)
+
+        if result not in failed_tag_list:
+            if not return_all and (log_outer_html or getattr(CommonUtil, "debug_status", False)):
+                await _log_outer_html(result, sModuleInfo)
+            if params.get("save_parameter"):
+                sr.Set_Shared_Variables(params["save_parameter"], result)
                 CommonUtil.ExecLog(
                     sModuleInfo,
-                    f"Found {count} elements. Returning first. Consider using index parameter.",
-                    2,
+                    "Saved element to variable '%s'" % params["save_parameter"],
+                    1,
                 )
-        except Exception:
-            pass  # Count might fail, but locator might still work with auto-wait
+            sr.Set_Shared_Variables("zeuz_element", result)
+            return result
 
-        return locator
+        await _log_frame_hint(page, sModuleInfo)
+        return "zeuz_failed"
 
     except Exception:
         return CommonUtil.Exception_Handler(sys.exc_info())
 
 
+def Get_Timeout(step_data, element_wait=None):
+    """Return the Playwright timeout in milliseconds for an element step."""
+
+    params = _parse_element_params(step_data)
+    if params.get("parse_error"):
+        raise ValueError(params["parse_error"])
+    return _resolve_timeout(params, element_wait)
+
+
 def _parse_element_params(step_data):
-    """
-    Parse element parameters from step data.
-
-    Returns dict with:
-        - index: Element index (int or None)
-        - allow_hidden: Whether to include hidden elements (bool)
-        - save_parameter: Variable name to save element (str or None)
-        - get_parameter: Variable name to retrieve element (str or None)
-        - wait: Custom wait timeout in seconds (float or None)
-        - element_params: List of element parameter tuples
-        - parent_params: List of parent parameter tuples
-        - And other parameter lists...
-    """
+    """Parse Zeuz step-data without losing Selenium locator semantics."""
+
     params = {
-        'index': None,
-        'allow_hidden': False,
-        'save_parameter': None,
-        'get_parameter': None,
-        'wait': None,
-        'element_params': [],
-        'parent_params': [],
-        'child_params': [],
-        'sibling_params': [],
-        'unique_params': [],
-        'shadow_root_params': [],
+        "index": None,
+        "allow_hidden": False,
+        "allow_disabled": False,
+        "save_parameter": None,
+        "get_parameter": None,
+        "wait": None,
+        "text_filter": False,
+        "parse_error": None,
+        "element_params": [],
+        "parent_params": [],
+        "child_params": [],
+        "sibling_params": [],
+        "preceding_params": [],
+        "following_params": [],
+        "unique_params": [],
+        "shadow_root_params": [],
+        "locator_rows": [],
+        "element_ds": [],
+        "all_rows": [],
     }
 
     for left, mid, right in step_data:
-        left_lower = left.strip().lower()
-        mid_lower = mid.strip().lower()
-        right_stripped = right.strip()
+        left_raw = str(left).strip()
+        mid_raw = str(mid).strip()
+        right_raw = str(right)
+        right_stripped = right_raw.strip()
+        left_lower = left_raw.lower()
+        mid_lower = mid_raw.lower()
+        mid_key = _mid_key(mid_raw)
+        row = (left_raw, mid_raw, right_raw)
+        params["all_rows"].append(row)
 
-        # Save parameter
         if mid_lower == "save parameter":
             if right_stripped != "ignore":
-                params['save_parameter'] = left.strip()
+                params["save_parameter"] = left_raw
+            continue
 
-        # Get parameter
-        elif mid_lower == "get parameter":
+        if mid_lower == "get parameter":
             if right_stripped.startswith("%|") and right_stripped.endswith("|%"):
-                params['get_parameter'] = right_stripped.strip("%").strip("|")
+                params["get_parameter"] = right_stripped.strip("%").strip("|")
+            else:
+                params["parse_error"] = "Use '%| |%' sign at right column to get variable value"
+            continue
 
         # Optional parameters
-        elif mid_lower == "optional parameter":
-            if left_lower in ("allow hidden", "allow disable"):
-                params['allow_hidden'] = right_stripped.lower() in ("yes", "true", "ok", "1")
+        if mid_lower in ("optional parameter", "option"):
+            if left_lower == "allow hidden":
+                params["allow_hidden"] = _truthy(right_stripped)
+            elif left_lower == "allow disable":
+                params["allow_disabled"] = _truthy(right_stripped)
             elif left_lower == "wait":
-                params['wait'] = float(right_stripped)
-
-        # Element parameters
-        elif mid_lower == "element parameter":
+                try:
+                    params["wait"] = float(right_stripped)
+                except Exception:
+                    params["parse_error"] = "Wait optional parameter must be numeric"
+            elif left_lower == "text filter":
+                params["text_filter"] = _truthy(right_stripped)
+            continue
+
+        if mid_lower.startswith("sr"):
+            params["shadow_root_params"].append(row)
+            continue
+
+        if mid_key == "uniqueparameter":
+            params["unique_params"].append((left_raw, right_raw))
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
+            continue
+
+        if "parent" in mid_key and "parameter" in mid_key:
+            params["parent_params"].append(row)
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
+            continue
+
+        if "child" in mid_key and "parameter" in mid_key:
+            params["child_params"].append(row)
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
+            continue
+
+        if "sibling" in mid_key and "parameter" in mid_key:
+            params["sibling_params"].append(row)
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
+            continue
+
+        if "preceding" in mid_key and "parameter" in mid_key:
+            params["preceding_params"].append(row)
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
+            continue
+
+        if "following" in mid_key and "parameter" in mid_key:
+            params["following_params"].append(row)
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
+            continue
+
+        if mid_key == "elementparameter":
+            params["locator_rows"].append(row)
+            params["element_ds"].append(row)
             if left_lower == "index":
                 try:
-                    params['index'] = int(right_stripped)
-                except ValueError:
-                    pass
+                    params["index"] = int(right_stripped)
+                except Exception:
+                    params["parse_error"] = "Index = 0 is set"
             else:
-                params['element_params'].append((left.strip(), right_stripped))
-
-        # Unique parameter
-        elif mid_lower == "unique parameter":
-            params['unique_params'].append((left.strip(), right_stripped))
-
-        # Parent parameters (including numbered: parent 2 parameter)
-        elif "parent" in mid_lower and "parameter" in mid_lower:
-            params['parent_params'].append((left.strip(), mid.strip(), right_stripped))
+                params["element_params"].append((left_raw, right_raw))
+            continue
 
-        # Child parameters
-        elif "child" in mid_lower and "parameter" in mid_lower:
-            params['child_params'].append((left.strip(), mid.strip(), right_stripped))
+        params["element_ds"].append(row)
 
-        # Sibling parameters
-        elif "sibling" in mid_lower and "parameter" in mid_lower:
-            params['sibling_params'].append((left.strip(), mid.strip(), right_stripped))
+    return params
 
-        # Shadow root parameters
-        elif mid_lower.startswith("sr"):
-            params['shadow_root_params'].append((left.strip(), mid.strip(), right_stripped))
 
-    return params
+def _requires_resolved_lookup(params, return_all=False):
+    return bool(return_all or params.get("text_filter") or params.get("index") is not None)
 
 
-def _build_locator(page, step_data, params):
+def _build_locator(page, step_data, params, frame_locator=None, parent_locator=None):
     """
     Build a Playwright Locator from step data.
 
@@ -238,270 +297,564 @@ def _build_locator(page, step_data, params):
     1. Playwright-native selectors (test-id, role, text, etc.) - fastest
     2. Direct xpath/css if provided
     3. Build xpath from element parameters using existing logic
+    
+    Args:
+        page: Playwright Page object
+        step_data: Step data for building xpath
+        params: Parsed element parameters
+        frame_locator: Optional frame locator for iframe context
+        parent_locator: Scope search within this locator (overrides frame when both set).
     """
 
-    # Strategy 1: Check for Playwright-native selectors (fastest path)
-    for left, right in params['element_params']:
-        left_lower = left.lower()
-
-        # Test ID selectors
-        if left_lower in ("test-id", "testid", "data-testid", "data-test-id"):
-            return page.get_by_test_id(right)
-
-        # Role selector
-        if left_lower == "role":
-            # Check if there's a name parameter too
-            name = None
-            for l, r in params['element_params']:
-                if l.lower() in ("name", "role name", "aria-label"):
-                    name = r
-                    break
-            if name:
-                return page.get_by_role(right, name=name)
-            return page.get_by_role(right)
-
-        # Text selectors
-        if left_lower == "text":
-            return page.get_by_text(right, exact=True)
-        if left_lower == "*text":
-            return page.get_by_text(right, exact=False)
-        if left_lower == "**text":
-            # Case-insensitive partial match
-            return page.get_by_text(re.compile(re.escape(right), re.IGNORECASE))
-
-        # Label selector
-        if left_lower == "label":
-            return page.get_by_label(right)
-
-        # Placeholder selector
-        if left_lower == "placeholder":
-            return page.get_by_placeholder(right)
-
-        # Alt text selector
-        if left_lower in ("alt", "alt text", "alt-text"):
-            return page.get_by_alt_text(right)
-
-        # Title selector
-        if left_lower == "title" and "parameter" not in params.get('mid', ''):
-            return page.get_by_title(right)
-
-        # Direct xpath
+    # Parent scope wins, then iframe, then full page.
+    if parent_locator is not None:
+        base_locator = parent_locator
+    else:
+        base_locator = frame_locator if frame_locator else page
+
+    if params["shadow_root_params"]:
+        return _build_shadow_dom_locator(base_locator, params)
+
+    native_locator = _build_native_locator(base_locator, params)
+    if native_locator is not None:
+        return native_locator
+
+    if params["unique_params"]:
+        legacy_locator = _build_legacy_locator(base_locator, params)
+        if legacy_locator is not None:
+            return legacy_locator
+
+    raw_locator = _build_raw_locator(base_locator, step_data)
+    if raw_locator is not None:
+        return raw_locator
+
+    legacy_locator = _build_legacy_locator(base_locator, params)
+    if legacy_locator is not None:
+        return legacy_locator
+
+    return None
+
+
+def _build_native_locator(base_locator, params):
+    """Support explicit Playwright-only selector aliases without overriding Selenium semantics."""
+
+    if _has_relationship_params(params) or params["unique_params"] or len(params["element_params"]) != 1:
+        return None
+
+    left, right = params["element_params"][0]
+    left_lower = left.lower()
+    if left_lower in ("test-id", "testid"):
+        return LocatorBuildResult(base_locator.get_by_test_id(right), "playwright test-id", right)
+    return None
+
+
+def _build_raw_locator(base_locator, step_data):
+    xpath_rows = []
+    css_rows = []
+    for left, mid, right in step_data:
+        left_lower = str(left).strip().lower()
+        mid_key = _mid_key(str(mid))
+        if mid_key != "elementparameter":
+            continue
         if left_lower == "xpath":
-            return page.locator(f"xpath={right}")
-
-        # Direct CSS selector
-        if left_lower in ("css", "css selector", "css_selector"):
-            return page.locator(right)
-
-    # Strategy 2: Check for unique parameters
-    for left, right in params['unique_params']:
-        left_lower = left.lower()
-
-        if left_lower == "id":
-            return page.locator(f"#{right}")
-        elif left_lower == "name":
-            return page.locator(f"[name='{right}']")
-        elif left_lower == "class":
-            return page.locator(f".{right}")
-        elif left_lower == "tag":
-            return page.locator(right)
-
-    # Strategy 3: Build xpath from element/parent/child parameters
-    xpath = _build_xpath_from_params(step_data, params)
-    if xpath:
-        CommonUtil.ExecLog(
-            "_build_locator",
-            f"Built xpath from parameters: {xpath}",
-            5
-        )
-        return page.locator(f"xpath={xpath}")
-
-    # Strategy 4: Simple element parameters as xpath
-    if params['element_params']:
-        xpath_parts = []
-        tag = "*"
-
-        for left, right in params['element_params']:
-            left_lower = left.lower()
-
-            if left_lower == "tag":
-                tag = right
-            elif left_lower == "id":
-                xpath_parts.append(f"@id='{right}'")
-            elif left_lower == "name":
-                xpath_parts.append(f"@name='{right}'")
-            elif left_lower == "class":
-                xpath_parts.append(f"contains(@class,'{right}')")
-            elif left_lower.startswith("*"):
-                # Partial match
-                attr = left_lower[1:]
-                xpath_parts.append(f"contains(@{attr},'{right}')")
-            elif left_lower.startswith("**"):
-                # Case-insensitive partial match
-                attr = left_lower[2:]
-                xpath_parts.append(
-                    f"contains(translate(@{attr},'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),'{right.lower()}')"
-                )
-            elif left_lower not in ("index", "text", "*text", "**text"):
-                # Generic attribute
-                xpath_parts.append(f"@{left}='{right}'")
+            xpath_rows.append(str(right).strip())
+        elif left_lower in ("css", "css selector", "css_selector"):
+            css_rows.append(str(right).strip())
+
+    if xpath_rows and not css_rows:
+        query = xpath_rows[0]
+        return LocatorBuildResult(base_locator.locator(_as_playwright_xpath(query)), "xpath", query)
+    if css_rows and not xpath_rows:
+        query = css_rows[0]
+        return LocatorBuildResult(base_locator.locator(query), "css", query)
+    return None
+
 
-        if xpath_parts:
-            xpath = f"//{tag}[{' and '.join(xpath_parts)}]"
-            return page.locator(f"xpath={xpath}")
-        elif tag != "*":
-            return page.locator(tag)
+def _build_legacy_locator(base_locator, params):
+    query, query_type = _build_legacy_query(params["locator_rows"])
+    if not query or not query_type:
+        return None
 
+    if query_type == "unique":
+        locator = _build_unique_locator(base_locator, query[0], query[1])
+        return LocatorBuildResult(locator, query_type, query)
+    if query_type == "css":
+        return LocatorBuildResult(base_locator.locator(query), query_type, query)
+    if query_type == "xpath":
+        return LocatorBuildResult(base_locator.locator(_as_playwright_xpath(query)), query_type, query)
     return None
 
 
-def _build_xpath_from_params(step_data, params):
-    """
-    Build complex xpath from element/parent/child/sibling parameters.
+def _build_legacy_query(locator_rows):
+    if not locator_rows:
+        return None, None
 
-    This reuses the logic from LocateElement._construct_query() but simplified
-    for the most common cases.
-    """
     try:
-        # Import the existing query builder for complex cases
         from Framework.Built_In_Automation.Shared_Resources import LocateElement
 
-        # Filter step_data to only include element-related rows
-        element_rows = []
-        for left, mid, right in step_data:
-            mid_lower = mid.strip().lower().replace(" ", "")
-            if any(x in mid_lower for x in [
-                "elementparameter", "parentparameter", "childparameter",
-                "siblingparameter", "uniqueparameter", "precedingparameter",
-                "followingparameter"
-            ]):
-                element_rows.append((left, mid, right))
-
-        if not element_rows:
-            return None
-
-        # Use existing query builder
-        # Temporarily set driver_type to selenium for xpath generation
-        original_driver_type = getattr(LocateElement, 'driver_type', None)
+        original_driver_type = getattr(LocateElement, "driver_type", None)
         LocateElement.driver_type = "selenium"
-
         try:
-            xpath, query_type = LocateElement._construct_query(element_rows)
-            if xpath and query_type in ("xpath", "css"):
-                return xpath
+            return LocateElement._construct_query(locator_rows)
         finally:
-            if original_driver_type is not None:
-                LocateElement.driver_type = original_driver_type
-
+            LocateElement.driver_type = original_driver_type
     except Exception as e:
-        CommonUtil.ExecLog(
-            "_build_xpath_from_params",
-            f"Error building xpath: {e}",
-            2
+        CommonUtil.ExecLog("_build_legacy_query", f"Error building Selenium-compatible query: {e}", 2)
+        return None, None
+
+
+def _build_unique_locator(base_locator, unique_key, unique_value):
+    key = str(unique_key).strip().lower()
+    value = str(unique_value).strip()
+
+    if key in ("accessibility id", "accessibility-id", "content-desc", "content desc"):
+        return base_locator.locator(_as_playwright_xpath(f"//*[@aria-label={_xpath_literal(value)}]"))
+    if key == "id":
+        return base_locator.locator(_as_playwright_xpath(f"//*[@id={_xpath_literal(value)}]"))
+    if key == "name":
+        return base_locator.locator(_as_playwright_xpath(f"//*[@name={_xpath_literal(value)}]"))
+    if key == "class":
+        klass = _xpath_literal(f" {value} ")
+        return base_locator.locator(
+            _as_playwright_xpath(f"//*[contains(concat(' ', normalize-space(@class), ' '), {klass})]")
+        )
+    if key == "tag":
+        return base_locator.locator(_as_playwright_xpath(f"//{value}"))
+    if key == "css":
+        return base_locator.locator(value)
+    if key == "xpath":
+        return base_locator.locator(_as_playwright_xpath(value))
+    if key == "text":
+        return base_locator.locator(_as_playwright_xpath(f"//*[text()={_xpath_literal(value)}]"))
+    if key == "*text":
+        return base_locator.locator(_as_playwright_xpath(f"//*[contains(text(),{_xpath_literal(value)})]"))
+    if key.startswith("**"):
+        attr = key[2:]
+        return base_locator.locator(
+            _as_playwright_xpath(
+                "//*[contains(translate(@%s,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),%s)]"
+                % (attr, _xpath_literal(value.lower()))
+            )
         )
+    if key.startswith("*"):
+        attr = key[1:]
+        return base_locator.locator(_as_playwright_xpath(f"//*[contains(@{attr},{_xpath_literal(value)})]"))
+    return base_locator.locator(_as_playwright_xpath(f"//*[@{key}={_xpath_literal(value)}]"))
 
-    return None
 
+def _build_shadow_dom_locator(base_locator, params):
+    try:
+        from Framework.Built_In_Automation.Shared_Resources import LocateElement
 
-def handle_shadow_dom(page, shadow_params, element_params):
-    """
-    Handle Shadow DOM element location.
+        shadow_root_params = []
+        parent_params = []
 
-    Playwright supports automatic shadow DOM piercing with the >> selector.
+        for left, mid, right in params["shadow_root_params"]:
+            left_lower = left.strip().lower()
+            if "text" in left_lower:
+                CommonUtil.ExecLog(
+                    "_build_shadow_dom_locator",
+                    "Shadow DOM access requires attribute/tag/css selectors; text selectors are not supported",
+                    3,
+                )
+                return None
+
+            words = mid.strip().lower().split()
+            if len(words) < 3 or len(words) > 4:
+                CommonUtil.ExecLog("_build_shadow_dom_locator", f"Invalid shadow root parameter format: {mid}", 3)
+                return None
+            idx = int(words[1]) if len(words) == 4 else 1
+            param = " ".join(words[-2:])
+            normalized_row = [left, param, right]
+
+            if "parent" in param:
+                parent_params.append((idx, normalized_row))
+            elif "element" in param:
+                shadow_root_params.append((idx, normalized_row))
+            else:
+                CommonUtil.ExecLog(
+                    "_build_shadow_dom_locator",
+                    "Only shadow root parent parameter and element parameter rows are supported",
+                    3,
+                )
+                return None
 
-    Args:
-        page: Playwright Page object
-        shadow_params: List of shadow root parameters
-        element_params: Final element parameters
+        parent_indices = [idx for idx, _ in parent_params]
+        shadow_indices = [idx for idx, _ in shadow_root_params]
+        if len(parent_indices) != len(set(parent_indices)) or len(shadow_indices) != len(set(shadow_indices)):
+            CommonUtil.ExecLog("_build_shadow_dom_locator", "Duplicate shadow root indices found", 3)
+            return None
 
-    Returns:
-        Locator for element inside shadow DOM
-    """
-    sModuleInfo = "handle_shadow_dom"
+        parent_params.sort(key=lambda item: item[0])
+        shadow_root_params.sort(key=lambda item: item[0])
+        current = base_locator
+        query_parts = []
 
-    try:
-        # Build a chain of selectors using Playwright's shadow-piercing >>
-        # Sort shadow params by their index (sr 1, sr 2, etc.)
-        sorted_params = sorted(shadow_params, key=lambda x: _extract_sr_index(x[1]))
-
-        selector_parts = []
-
-        for left, mid, right in sorted_params:
-            left_lower = left.lower()
-            if left_lower == "tag":
-                selector_parts.append(right)
-            elif left_lower == "id":
-                selector_parts.append(f"#{right}")
-            elif left_lower == "class":
-                selector_parts.append(f".{right}")
-            else:
-                selector_parts.append(f"[{left}='{right}']")
-
-        # Add final element
-        for left, right in element_params:
-            left_lower = left.lower()
-            if left_lower == "tag":
-                selector_parts.append(right)
-            elif left_lower == "id":
-                selector_parts.append(f"#{right}")
-            elif left_lower == "class":
-                selector_parts.append(f".{right}")
+        for idx, shadow_param in shadow_root_params:
+            query_rows = []
+            for parent_idx, parent_param in parent_params:
+                if parent_idx == idx:
+                    query_rows.append(parent_param)
+                    break
+            query_rows.append(shadow_param)
+            if idx == 1:
+                host_query, host_query_type = _build_legacy_query(query_rows)
+                if host_query_type == "xpath":
+                    host_query = _as_playwright_xpath(host_query)
             else:
-                selector_parts.append(f"[{left}='{right}']")
+                host_query = LocateElement.build_css_selector_query(query_rows)
+            if not host_query:
+                return None
+            current = current.locator(host_query)
+            host_index = _index_from_rows([shadow_param]) or 0
+            current = current.nth(host_index)
+            query_parts.append(host_query)
+
+        element_query = LocateElement.build_css_selector_query([list(row) for row in params["element_ds"]])
+        if not element_query:
+            return None
+        query_parts.append(element_query)
+        return LocatorBuildResult(current.locator(element_query), "shadow css", " >> ".join(query_parts))
+    except Exception:
+        return CommonUtil.Exception_Handler(sys.exc_info())
 
-        # Join with >> for shadow DOM piercing
-        full_selector = " >> ".join(selector_parts)
-        CommonUtil.ExecLog(sModuleInfo, f"Shadow DOM selector: {full_selector}", 5)
 
-        return page.locator(full_selector)
+async def _resolve_single(locator, params, timeout, sModuleInfo):
+    effective_locator = _effective_locator(locator, params)
+    state = "attached" if params.get("allow_hidden") else "visible"
 
-    except Exception:
-        return CommonUtil.Exception_Handler(sys.exc_info())
+    if not await _wait_for_locator(effective_locator, state, timeout):
+        await _log_no_match(locator, params, sModuleInfo)
+        return "zeuz_failed"
 
+    count = await _safe_count(effective_locator)
+    total_count = await _safe_count(locator)
+    hidden_count = max(total_count - count, 0) if not params.get("allow_hidden") else 0
 
-def _extract_sr_index(mid_value):
-    """Extract index from 'sr N element parameter' format."""
-    try:
-        parts = mid_value.lower().split()
-        for i, part in enumerate(parts):
-            if part == "sr" and i + 1 < len(parts):
-                return int(parts[i + 1])
-    except (ValueError, IndexError):
-        pass
-    return 1
+    index = params.get("index")
+    if count == 0:
+        await _log_no_match(locator, params, sModuleInfo)
+        return "zeuz_failed"
 
+    if index is None:
+        if count > 1:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Found {count} displayed elements. Returning the first displayed element only. Consider providing index",
+                2,
+            )
+        elif hidden_count > 0:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Found {hidden_count} hidden elements and {count} displayed element. Returning the displayed element only",
+                2,
+            )
+        return _first_locator(effective_locator)
 
-def wait_for_element(step_data, page, state="visible", timeout=None):
-    """
-    Wait for element to reach a specific state.
+    if count == 1:
+        if index not in (-1, 0):
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Found {count} element but provided index {index} is out of range. Returning the only element",
+                2,
+            )
+        return _first_locator(effective_locator)
 
-    Args:
-        step_data: Standard step data format
-        page: Playwright Page object
-        state: One of "attached", "detached", "visible", "hidden"
-        timeout: Timeout in milliseconds
+    resolved_index = index if index >= 0 else count + index
+    if 0 <= resolved_index < count:
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"Found {count} elements. Returning the element of index {index}",
+            1,
+        )
+        return effective_locator.nth(resolved_index)
+
+    CommonUtil.ExecLog(sModuleInfo, f"Found {count} elements. Index {index} exceeds the number of elements found", 3)
+    return "zeuz_failed"
+
+
+async def _resolve_all(locator, params, timeout, sModuleInfo):
+    effective_locator = _effective_locator(locator, params)
+    state = "attached" if params.get("allow_hidden") else "visible"
+    if not await _wait_for_locator(effective_locator, state, timeout):
+        CommonUtil.ExecLog(sModuleInfo, "Found 0 elements", 3)
+        return []
+
+    all_locators = await effective_locator.all()
+    total_count = await _safe_count(locator)
+    displayed_count = len(all_locators)
+    hidden_count = max(total_count - displayed_count, 0) if not params.get("allow_hidden") else 0
+
+    if params.get("allow_hidden"):
+        CommonUtil.ExecLog(sModuleInfo, f"Found {displayed_count} elements. Returning all of them", 1)
+    else:
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"Found {hidden_count} hidden elements and {displayed_count} displayed elements. Returning displayed elements only",
+            1,
+        )
+    return all_locators
+
+
+async def _text_filter(step_data, page, frame_locator, original_params, timeout, return_all):
+    sModuleInfo = "text_filter : " + MODULE_NAME
+
+    if original_params["sibling_params"]:
+        return "zeuz_failed"
+
+    filters = []
+    temp_step_data = []
+    for left, mid, right in step_data:
+        left_lower = str(left).strip().lower()
+        mid_lower = str(mid).strip().lower()
+        if left_lower.replace("*", "") == "text" and mid_lower == "element parameter":
+            filters.append((left_lower, str(right)))
+        else:
+            temp_step_data.append((left, mid, right))
+
+    if not filters:
+        return "zeuz_failed"
+
+    temp_params = _parse_element_params(temp_step_data)
+    temp_params["allow_hidden"] = original_params.get("allow_hidden", False)
+    build_result = _build_locator(page, temp_step_data, temp_params, frame_locator)
+    if build_result is None:
+        return "zeuz_failed"
+
+    CommonUtil.ExecLog(sModuleInfo, "No Element found. Now we are trying to handle &nbsp; and <space>", 1)
+    CommonUtil.ExecLog(sModuleInfo, f"To locate the Element we used {build_result.query_type}:\n{build_result.query}", 5)
+
+    candidate_locator = _effective_locator(build_result.locator, temp_params)
+    state = "attached" if temp_params.get("allow_hidden") else "visible"
+    if not await _wait_for_locator(candidate_locator, state, timeout):
+        return "zeuz_failed"
+
+    candidates = await candidate_locator.all()
+    matches = []
+    similar_texts = []
+    for candidate in candidates:
+        try:
+            text = await candidate.text_content() or ""
+        except Exception:
+            continue
+        if _matches_text_filters(text, filters):
+            matches.append(candidate)
+        elif _similar_text(text, filters) and text not in similar_texts:
+            similar_texts.append(text)
+
+    if return_all:
+        CommonUtil.ExecLog(sModuleInfo, f"Returning {len(matches)} elements after applying Text Filter", 1)
+        return matches
+
+    if not matches:
+        CommonUtil.ExecLog(sModuleInfo, "Found no element after applying Text Filter", 3)
+        if similar_texts:
+            CommonUtil.ExecLog(sModuleInfo, f"These are the similar texts found in the HTML: {str(similar_texts)[1:-1]}", 3)
+        return "zeuz_failed"
+
+    index = original_params.get("index") or 0
+    resolved_index = index if index >= 0 else len(matches) + index
+    if not 0 <= resolved_index < len(matches):
+        CommonUtil.ExecLog(sModuleInfo, f"Found {len(matches)} elements after applying Text Filter. Index out of range", 3)
+        return "zeuz_failed"
+
+    CommonUtil.ExecLog(sModuleInfo, f"Found {len(matches)} elements after applying Text Filter. Returning index {index}", 1)
+    return matches[resolved_index]
+
+
+async def wait_for_element(step_data, page, state="visible", timeout=None, frame_locator=None, parent_locator=None):
+    """Wait for an element to reach a Playwright state."""
 
-    Returns:
-        "passed" | "zeuz_failed"
-    """
     sModuleInfo = "wait_for_element"
 
     try:
-        locator = Get_Element(step_data, page)
-        if locator == "zeuz_failed":
+        params = _parse_element_params(step_data)
+        if timeout is None:
+            timeout = _resolve_timeout(params, None)
+        build_result = _build_locator(page, step_data, params, frame_locator, parent_locator)
+        if build_result is None:
+            CommonUtil.ExecLog(sModuleInfo, "Could not build locator from step data", 3)
             return "zeuz_failed"
 
-        if timeout is None:
-            default_wait = sr.Get_Shared_Variables("element_wait")
-            if default_wait not in failed_tag_list:
-                timeout = int(float(default_wait) * 1000)
-            else:
-                timeout = 10000
+        locator = build_result.locator
+        if not params.get("allow_hidden"):
+            locator = _effective_locator(locator, params)
+        if params.get("index") is not None:
+            locator = locator.nth(params["index"])
+        else:
+            locator = _first_locator(locator)
 
-        locator.wait_for(state=state, timeout=timeout)
+        await locator.wait_for(state=state, timeout=timeout)
         CommonUtil.ExecLog(sModuleInfo, f"Element reached state: {state}", 1)
         return "passed"
-
     except Exception as e:
         CommonUtil.ExecLog(sModuleInfo, f"Wait for element failed: {e}", 3)
         return "zeuz_failed"
+
+
+def _effective_locator(locator, params):
+    if params.get("allow_hidden"):
+        return locator
+    return locator.filter(visible=True)
+
+
+async def _wait_for_locator(locator, state, timeout):
+    try:
+        await _first_locator(locator).wait_for(state=state, timeout=timeout)
+        return True
+    except Exception:
+        return False
+
+
+async def _safe_count(locator):
+    try:
+        return await locator.count()
+    except Exception:
+        return 0
+
+
+async def _log_no_match(locator, params, sModuleInfo):
+    total_count = await _safe_count(locator)
+    if total_count > 0 and not params.get("allow_hidden"):
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            "Found %s hidden elements and no displayed elements. Nothing to return.\n" % total_count
+            + 'To get hidden elements add a row ("allow hidden", "optional parameter", "yes")',
+            3,
+        )
+    else:
+        CommonUtil.ExecLog(sModuleInfo, "No elements found matching locator", 3)
+
+
+async def _log_outer_html(locator, sModuleInfo):
+    try:
+        outer_html = await locator.evaluate("el => el.outerHTML")
+        CommonUtil.ExecLog(sModuleInfo, _opening_tag(outer_html), 5)
+    except Exception:
+        pass
+
+
+async def _log_frame_hint(page, sModuleInfo):
+    try:
+        if await page.locator("iframe").count() > 0:
+            CommonUtil.ExecLog(sModuleInfo, 'You have Iframes in your Webpage. Try switching Iframe with "Switch Iframe" action', 3)
+        elif await page.locator("frame").count() > 0:
+            CommonUtil.ExecLog(sModuleInfo, 'You have Frames in your Webpage. Try switching Frame with "Switch Iframe" action', 3)
+    except Exception:
+        pass
+
+
+def _resolve_timeout(params, element_wait):
+    if element_wait is not None:
+        return int(float(element_wait) * 1000)
+    if params.get("wait") is not None:
+        return int(float(params["wait"]) * 1000)
+    default_wait = sr.Get_Shared_Variables("element_wait")
+    if default_wait not in failed_tag_list:
+        return int(float(default_wait) * 1000)
+    return 10000
+
+
+def _first_locator(locator):
+    first = getattr(locator, "first")
+    return first() if callable(first) else first
+
+
+def _has_relationship_params(params):
+    return any(
+        params[key]
+        for key in (
+            "parent_params",
+            "child_params",
+            "sibling_params",
+            "preceding_params",
+            "following_params",
+            "shadow_root_params",
+        )
+    )
+
+
+def _index_from_rows(rows):
+    for left, mid, right in rows:
+        if str(left).strip().lower() == "index" and str(mid).strip().lower() == "element parameter":
+            try:
+                return int(str(right).strip())
+            except Exception:
+                return None
+    return None
+
+
+def _matches_text_filters(text, filters):
+    normalized_text = text.replace("\xa0", " ")
+    for left, value in filters:
+        normalized_value = value.replace("\xa0", " ")
+        if left.startswith("**") and normalized_value.lower() in normalized_text.lower():
+            return True
+        if left.startswith("*") and normalized_value in normalized_text:
+            return True
+        if normalized_value == normalized_text:
+            return True
+    return False
+
+
+def _similar_text(text, filters):
+    collapsed_text = re.sub(r"\s+", "", text.lower().replace("\xa0", ""))
+    for _, value in filters:
+        if value.lower().replace("\xa0", "").replace(" ", "") in collapsed_text:
+            return True
+    return False
+
+
+def _opening_tag(outer_html):
+    i, quote_count = 0, 0
+    for i in range(len(outer_html)):
+        if outer_html[i] == '"':
+            quote_count += 1
+        if outer_html[i] == ">" and quote_count % 2 == 0:
+            break
+    return outer_html[: i + 1]
+
+
+def _as_playwright_xpath(query):
+    query = str(query).strip()
+    return query if query.startswith("xpath=") else f"xpath={query}"
+
+
+def _xpath_literal(value):
+    value = str(value)
+    if '"' not in value:
+        return f'"{value}"'
+    if "'" not in value:
+        return f"'{value}'"
+    parts = value.split('"')
+    return "concat(%s)" % ", '\"', ".join(f'"{part}"' for part in parts)
+
+
+def _mid_key(mid):
+    return str(mid).replace(" ", "").lower()
+
+
+def _truthy(value):
+    return str(value).strip().lower() in ("yes", "true", "ok", "1", "enable")
+
+
+def _extract_sr_index(mid_value):
+    """Extract index from 'sr N element parameter' format."""
+    try:
+        parts = mid_value.lower().split()
+        for i, part in enumerate(parts):
+            if part == "sr" and i + 1 < len(parts):
+                return int(parts[i + 1])
+    except (ValueError, IndexError):
+        pass
+    return 1
+
+
+# Backwards-compatible alias for code that imported the old helper directly.
+def handle_shadow_dom(page, shadow_params, element_params):
+    params = {
+        "shadow_root_params": shadow_params,
+        "element_ds": [(left, "element parameter", right) for left, right in element_params],
+    }
+    result = _build_shadow_dom_locator(page, params)
+    return result.locator if result not in failed_tag_list and result is not None else "zeuz_failed"
diff --git a/Framework/Built_In_Automation/Web/Playwright/utils.py b/Framework/Built_In_Automation/Web/Playwright/utils.py
new file mode 100644
index 000000000..f6e531f7f
--- /dev/null
+++ b/Framework/Built_In_Automation/Web/Playwright/utils.py
@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""
+Playwright Utility Functions for Zeuz Node
+
+This module provides utility functions for Playwright automation,
+including browser download and setup functionality.
+
+Author: Zeuz/AutomationSolutionz
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from filelock import FileLock
+
+from Framework.Utilities import CommonUtil
+from settings import ZEUZ_NODE_DOWNLOADS_DIR
+
+PLAYWRIGHT_BROWSERS_DIR = ZEUZ_NODE_DOWNLOADS_DIR / "playwright_browsers"
+PLAYWRIGHT_INSTALLABLE_BROWSERS = {
+    "chromium": "chromium",
+    "chrome": "chromium",
+    "firefox": "firefox",
+    "webkit": "webkit",
+    "safari": "webkit",
+}
+PLAYWRIGHT_SYSTEM_CHANNEL_BROWSERS = {
+    "edge",
+    "msedge",
+    "microsoft edge",
+    "chrome-beta",
+}
+
+
+def _set_playwright_browsers_path():
+    """Use Zeuz's persistent downloads directory for Playwright browser binaries."""
+
+    PLAYWRIGHT_BROWSERS_DIR.mkdir(parents=True, exist_ok=True)
+    os.environ["PLAYWRIGHT_BROWSERS_PATH"] = str(PLAYWRIGHT_BROWSERS_DIR)
+    return PLAYWRIGHT_BROWSERS_DIR
+
+
+def _get_playwright_browser_name(browser_name):
+    browser_name = (browser_name or "chromium").strip().lower()
+    return PLAYWRIGHT_INSTALLABLE_BROWSERS.get(browser_name)
+
+
+def _get_playwright_executable_path(browser_name):
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            (
+                "from playwright.sync_api import sync_playwright\n"
+                "with sync_playwright() as p:\n"
+                f"    print(p.{browser_name}.executable_path)\n"
+            ),
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=os.environ.copy(),
+    )
+
+    if result.returncode != 0:
+        return None
+
+    executable_path = result.stdout.strip().splitlines()[-1] if result.stdout.strip() else ""
+    return Path(executable_path) if executable_path else None
+
+
+def _is_playwright_browser_installed(browser_name):
+    executable_path = _get_playwright_executable_path(browser_name)
+    return bool(executable_path and executable_path.exists())
+
+
+def ensure_playwright_browser_installed(sModuleInfo, browser_name="chromium"):
+    """
+    Ensure Playwright's managed browser is installed in Zeuz's persistent cache.
+     
+    Args:
+        sModuleInfo: Module information for logging
+        browser_name: Requested Playwright browser/channel name
+         
+    Returns:
+        bool: True if the browser is ready or no managed download is required
+    """
+    try:
+        browsers_dir = _set_playwright_browsers_path()
+        requested_browser = (browser_name or "chromium").strip().lower()
+        install_browser = _get_playwright_browser_name(requested_browser)
+
+        if requested_browser in PLAYWRIGHT_SYSTEM_CHANNEL_BROWSERS:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Using Playwright browser cache: {browsers_dir}. Browser '{browser_name}' uses a system channel.",
+                1,
+            )
+            return True
+
+        if not install_browser:
+            install_browser = "chromium"
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Unknown browser '{browser_name}', preparing Playwright chromium",
+                2,
+            )
+
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"Ensuring Playwright {install_browser} browser is installed in {browsers_dir}",
+            1,
+        )
+
+        if _is_playwright_browser_installed(install_browser):
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Playwright {install_browser} browser already exists in {browsers_dir}",
+                1,
+            )
+            return True
+
+        lock_path = browsers_dir / f"{install_browser}.install.lock"
+        with FileLock(str(lock_path)):
+            if _is_playwright_browser_installed(install_browser):
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    f"Playwright {install_browser} browser already exists in {browsers_dir}",
+                    1,
+                )
+                return True
+
+            result = subprocess.run(
+                [sys.executable, "-m", "playwright", "install", "--with-deps", install_browser],
+                env=os.environ.copy(),
+            )
+
+        if result.returncode == 0:
+            CommonUtil.ExecLog(
+                sModuleInfo,
+                f"Playwright {install_browser} browser is ready",
+                1,
+            )
+            return True
+
+        CommonUtil.ExecLog(
+            sModuleInfo,
+            f"Failed to install Playwright {install_browser} browser. See terminal output for details.",
+            3,
+        )
+        return False
+
+    except Exception as e:
+        CommonUtil.ExecLog(sModuleInfo, f"Error setting up Playwright browser: {str(e)}", 3)
+        return False
diff --git a/Framework/Built_In_Automation/Web/Selenium/BuiltInFunctions.py b/Framework/Built_In_Automation/Web/Selenium/BuiltInFunctions.py
index 55797f587..cc64d4e92 100644
--- a/Framework/Built_In_Automation/Web/Selenium/BuiltInFunctions.py
+++ b/Framework/Built_In_Automation/Web/Selenium/BuiltInFunctions.py
@@ -71,6 +71,16 @@
 from Framework.AI.NLP import binary_classification
 from .utils import ChromeForTesting, ChromeExtensionDownloader
 
+from playwright.async_api import async_playwright
+from Framework.Built_In_Automation.Web.utils import (
+    create_browser_session,
+    extract_session_name,
+    get_browser_session,
+    get_browser_sessions,
+    get_debug_port,
+    remove_browser_session,
+)
+
 #########################
 #                       #
 #    Global Variables   #
@@ -147,6 +157,166 @@
 ReturnType = Literal["passed", "zeuz_failed"]
 
 
+def _set_active_selenium_session(session_name, session):
+    """Update module globals/shared variables for a selected Selenium session."""
+
+    global selenium_driver, current_driver_id, selenium_details
+
+    selenium_driver = session.get("selenium_driver")
+    current_driver_id = session_name
+    selenium_details.setdefault(session_name, {})["driver"] = selenium_driver
+    if session.get("remote_debugging_port"):
+        selenium_details[session_name]["remote-debugging-port"] = session["remote_debugging_port"]
+    Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+    Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
+    if session.get("playwright_page"):
+        Shared_Resources.Set_Shared_Variables("playwright_page", session["playwright_page"])
+    CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
+
+
+def _ensure_selenium_session(session_name, existing_session):
+    """Activate an existing Selenium session or lazily attach to a Playwright one."""
+
+    if existing_session and existing_session.get("selenium_driver"):
+        _set_active_selenium_session(session_name, existing_session)
+        return "passed"
+
+    if not existing_session or not existing_session.get("playwright_page"):
+        return "zeuz_failed"
+
+    if existing_session.get("selenium_cdp_supported") is False:
+        CommonUtil.ExecLog(
+            "_ensure_selenium_session",
+            f"Selenium attach is only supported for Chromium Playwright sessions: {session_name}",
+            3,
+        )
+        return "zeuz_failed"
+
+    port = existing_session.get("remote_debugging_port")
+    if not port:
+        return "zeuz_failed"
+
+    try:
+        from Framework.Built_In_Automation.Web.Playwright import BuiltInFunctions as PlaywrightBuiltInFunctions
+
+        driver = PlaywrightBuiltInFunctions.connect_selenium_to_playwright(port=port)
+        if driver in failed_tag_list:
+            return "zeuz_failed"
+
+        sessions = get_browser_sessions()
+        session = sessions.setdefault(session_name, existing_session)
+        session["selenium_driver"] = driver
+        session["remote_debugging_port"] = port
+        Shared_Resources.Set_Shared_Variables("browser_sessions", sessions)
+        _set_active_selenium_session(session_name, session)
+        CommonUtil.ExecLog("_ensure_selenium_session", f"Connected Selenium to Playwright session: {session_name}", 1)
+        return "passed"
+    except Exception as e:
+        CommonUtil.ExecLog("_ensure_selenium_session", f"Failed to connect Selenium to Playwright session '{session_name}': {e}", 3)
+        return "zeuz_failed"
+
+
+def _handle_selenium_session(step_data):
+    """
+    Helper function to handle session parameter for Selenium actions.
+    
+    Args:
+        step_data: The step data containing potential session parameter
+        
+    Returns:
+        tuple: (session_name, selenium_driver, current_driver_id)
+        - session_name: The session name found or None
+        - selenium_driver: The appropriate selenium driver instance
+        - current_driver_id: The current driver ID
+    """
+    global selenium_driver, current_driver_id
+    
+    session_name = extract_session_name(step_data)
+    
+    if session_name:
+        existing_session = get_browser_session(session_name)
+        if _ensure_selenium_session(session_name, existing_session) not in failed_tag_list:
+            sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+            CommonUtil.ExecLog(sModuleInfo, f"Using existing browser session: {session_name}", 1)
+        else:
+            sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+            CommonUtil.ExecLog(sModuleInfo, f"Browser session '{session_name}' not found", 3)
+            raise ValueError(f"Browser session '{session_name}' not found")
+    elif selenium_driver is None:
+        default_session = get_browser_session("default")
+        if default_session and default_session.get("playwright_page"):
+            _ensure_selenium_session("default", default_session)
+    
+    return session_name, selenium_driver, current_driver_id
+
+
+def _activate_browser_session_for_action(step_data, function_name=None):
+    """Select the requested browser session before running Selenium actions."""
+
+    global selenium_driver, current_driver_id, selenium_details
+
+    session_name = extract_session_name(step_data)
+
+    create_or_cleanup_actions = {
+        "Go_To_Link",
+        "Go_To_Link_V2",
+        "Open_Electron_App",
+        "Tear_Down_Selenium",
+    }
+    if function_name in create_or_cleanup_actions:
+        return "passed"
+
+    if not session_name:
+        if selenium_driver is None:
+            default_session = get_browser_session("default")
+            if default_session and default_session.get("playwright_page"):
+                return _ensure_selenium_session("default", default_session)
+        return "passed"
+
+    existing_session = get_browser_session(session_name)
+    if _ensure_selenium_session(session_name, existing_session) in failed_tag_list:
+        sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+        CommonUtil.ExecLog(sModuleInfo, f"Browser session '{session_name}' not found", 3)
+        return "zeuz_failed"
+    return "passed"
+
+
+def _run_async_from_sync(awaitable):
+    """Run an awaitable from Selenium's sync actions, including inside an event loop."""
+
+    import asyncio
+    from concurrent.futures import ThreadPoolExecutor
+
+    try:
+        loop = asyncio.get_running_loop()
+        if loop.is_running():
+            def run_in_thread():
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+                try:
+                    return new_loop.run_until_complete(awaitable)
+                finally:
+                    new_loop.close()
+
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                return executor.submit(run_in_thread).result(timeout=30)
+    except RuntimeError:
+        pass
+
+    return asyncio.run(awaitable)
+
+
+def _close_maybe_async(resource, method_name="close"):
+    if not resource:
+        return
+    method = getattr(resource, method_name, None)
+    if not method:
+        return
+    result = method()
+    if inspect.iscoroutine(result):
+        _run_async_from_sync(result)
+
+
 class DefaultChromiumArguments(TypedDict):
     add_argument: list[str]
     add_experimental_option: dict[str, Any]
@@ -426,7 +596,7 @@ def Open_Electron_App(data_set):
         desktop_app_path = ""
         driver_id = ""
         chrome_version = ""
-        for left, _, right in data_set:
+        for left, mid, right in data_set:
             left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
             if "windows" in left and platform.system() == "Windows":
                 desktop_app_path = right.strip()
@@ -436,6 +606,8 @@ def Open_Electron_App(data_set):
                 desktop_app_path = right.strip()
             elif left == "driverid":
                 driver_id = right.strip()
+            elif left == "session" and mid.strip().lower() == "optional parameter":
+                driver_id = right.strip()
             elif left == "chrome:version":
                 chrome_version = right.strip()
 
@@ -464,7 +636,9 @@ def Open_Electron_App(data_set):
 
             opts = Options()
             opts.binary_location = desktop_app_path
-            opts.add_argument("--remote-debugging-port=9222")
+            electron_port = get_debug_port(driver_id or "electron", start=9230, stop=9320)
+            opts.add_argument(f"--remote-debugging-port={electron_port}")
+            CommonUtil.ExecLog(sModuleInfo, f"Using remote debugging port {electron_port} for Electron app", 1)
             # service = Service(executable_path=electron_chrome_path)
             arch = platform.machine().lower()
             if platform.system() == "Darwin" and arch == "arm64":
@@ -481,15 +655,21 @@ def Open_Electron_App(data_set):
             selenium_driver.implicitly_wait(0.5)
             CommonUtil.ExecLog(sModuleInfo, "Started Electron App", 1)
             Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+            Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
             CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
 
         except Exception:
             return CommonUtil.Exception_Handler(sys.exc_info())
 
-        if driver_id in selenium_details:
-            pass  # we need to decide later based on the situation
-        else:
-            selenium_details[driver_id] = {"driver": selenium_driver}
+        selenium_details[driver_id] = {
+            "driver": selenium_driver,
+            "remote-debugging-port": electron_port,
+        }
+        create_browser_session(
+            session_name=driver_id,
+            selenium_driver=selenium_driver,
+            remote_debugging_port=electron_port,
+        )
         current_driver_id = driver_id
         return "passed"
     except:
@@ -656,8 +836,27 @@ def headless():
     return options
 
 
+async def connect_playwright_to_selenium(port=9222):
+    playwright_instance = await async_playwright().start()
+    browser = await playwright_instance.chromium.connect_over_cdp(f"http://localhost:{port}")
+    context = browser.contexts[0]
+    page = context.pages[0]
+
+    from Framework.Built_In_Automation.Web.Playwright import BuiltInFunctions as PlaywrightBuiltInFunctions
+    PlaywrightBuiltInFunctions.playwright_instance = playwright_instance
+    PlaywrightBuiltInFunctions.browser = browser
+    PlaywrightBuiltInFunctions.context = context
+    PlaywrightBuiltInFunctions.current_page = page
+
+    Shared_Resources.Set_Shared_Variables("playwright_context", context)
+    Shared_Resources.Set_Shared_Variables("playwright_browser", browser)
+    Shared_Resources.Set_Shared_Variables("playwright_page", page)
+
+    return playwright_instance, browser, context, page
+
+
 @logger
-def Open_Browser(browser, browser_options: BrowserOptions):
+async def Open_Browser(browser, browser_options: BrowserOptions, session_name: str = "default"):
     """Launch browser from options and service object"""
     try:
         global selenium_driver
@@ -687,6 +886,11 @@ def Open_Browser(browser, browser_options: BrowserOptions):
 
         options = generate_options(browser, browser_options)
 
+        # Enable remote debugging / CDP with a unique port per session.
+        unique_port = get_debug_port(session_name)
+        options.add_argument(f"--remote-debugging-port={unique_port}")
+        CommonUtil.ExecLog(sModuleInfo, f"Using remote debugging port {unique_port} for session '{session_name}'", 1)
+
         if browser in ("android", "chrome", "chromeheadless"):
             from selenium.webdriver.chrome.service import Service
 
@@ -756,8 +960,25 @@ def Open_Browser(browser, browser_options: BrowserOptions):
             )
             return "zeuz_failed"
 
+        # If selenium_driver is of type Webdriver
+        from selenium.webdriver import Chrome, Firefox, Edge, Safari
+        if isinstance(selenium_driver, (Chrome, Firefox, Edge, Safari)):
+            # Create browser session
+            create_browser_session(
+                session_name=session_name,
+                selenium_driver=selenium_driver,
+                playwright_page=None,
+                playwright_browser=None,
+                playwright_context=None,
+                playwright_frame=None,
+                playwright_instance=None,
+                remote_debugging_port=unique_port,
+            )
+            CommonUtil.ExecLog(sModuleInfo, f"Created browser session: {session_name=}", 5)
+
         CommonUtil.ExecLog(sModuleInfo, f"Started {browser} browser", 1)
         Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+        Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
         CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
         return "passed"
 
@@ -782,7 +1003,7 @@ def Go_To_Link_V2(step_data):
     options = Options()
     page_load_strategy = "normal"
 
-    for left, _, right in step_data:
+    for left, mid, right in step_data:
         left = left.strip().lower()
         if "add argument" == left:
             options.add_argument(right.strip())
@@ -809,6 +1030,8 @@ def Go_To_Link_V2(step_data):
             url = right.strip() if right.strip() != "" else None
         elif "driver tag" == left:
             driver_tag = right.strip()
+        elif left == "session" and mid.strip().lower() == "optional parameter":
+            driver_tag = right.strip()
         elif "wait for element" == left:
             Shared_Resources.Set_Shared_Variables("element_wait", float(right.strip()))
         elif "page load timeout" == left:
@@ -817,7 +1040,10 @@ def Go_To_Link_V2(step_data):
             page_load_strategy = right.strip()
             options.page_load_strategy = page_load_strategy
 
-    if driver_tag in selenium_details.keys():
+    existing_session = get_browser_session(driver_tag)
+    if existing_session and _ensure_selenium_session(driver_tag, existing_session) not in failed_tag_list:
+        pass
+    elif driver_tag in selenium_details.keys():
         selenium_driver = selenium_details[driver_tag]["driver"]
     else:
         if Shared_Resources.Test_Shared_Variables("dependency"):
@@ -830,16 +1056,28 @@ def Go_To_Link_V2(step_data):
             options.add_argument("--headless")
             CommonUtil.ExecLog(sModuleInfo, "Added headless argument", 1)
 
+        debug_port = get_debug_port(driver_tag)
+        options.add_argument(f"--remote-debugging-port={debug_port}")
+        CommonUtil.ExecLog(sModuleInfo, f"Using remote debugging port {debug_port} for session '{driver_tag}'", 1)
+
         if "chrome" in dependency_browser:
             selenium_driver = webdriver.Chrome(options=options)
         elif "firefox" in dependency_browser:
             selenium_driver = webdriver.Firefox(options=options)
 
         selenium_driver.set_page_load_timeout(page_load_timeout_sec)
-        selenium_details[driver_tag] = dict()
-        selenium_details[driver_tag]["driver"] = selenium_driver
-        current_driver_id = selenium_driver
+        selenium_details[driver_tag] = {
+            "driver": selenium_driver,
+            "remote-debugging-port": debug_port,
+        }
+        create_browser_session(
+            session_name=driver_tag,
+            selenium_driver=selenium_driver,
+            remote_debugging_port=debug_port,
+        )
+        current_driver_id = driver_tag
         Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+        Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
 
         # Handle headless mode window maximize
         if (
@@ -853,6 +1091,8 @@ def Go_To_Link_V2(step_data):
 
     selenium_driver.maximize_window()
     Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+    current_driver_id = driver_tag
+    Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
     CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
     return "passed"
 
@@ -915,7 +1155,7 @@ def parse_and_verify_datatype(left: str, right: str, chrome_version=None):
 
 
 @logger
-def Go_To_Link(dataset: Dataset) -> ReturnType:
+async def Go_To_Link(dataset: Dataset) -> ReturnType:
     try:
         sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
         window_size_X = None
@@ -990,13 +1230,14 @@ def Go_To_Link(dataset: Dataset) -> ReturnType:
         chrome_version = None
         chrome_channel = None
         debug_port = False
+        session_name = "default"
 
         for left, mid, right in dataset:
             left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
             if left == "gotolink":
                 web_link = right.strip()
             elif left == "driverid":
-                driver_id = right.strip()
+                session_name = driver_id = right.strip()
             elif left in ("waittimetoappearelement", "waitforelement"):
                 Shared_Resources.Set_Shared_Variables(
                     "element_wait", float(right.strip())
@@ -1009,6 +1250,8 @@ def Go_To_Link(dataset: Dataset) -> ReturnType:
                 window_size_Y = int(resolution[1])
             elif left == "chrome:version":
                 chrome_version = right.strip()
+            elif left == "session":
+                session_name = driver_id = right.strip()
 
             # Capabilities are WebDriver attribute common across different browser
             elif mid.strip().lower() == "shared capability":
@@ -1095,6 +1338,11 @@ def Go_To_Link(dataset: Dataset) -> ReturnType:
                 driver_id = current_driver_id
             else:
                 driver_id = list(selenium_details.keys())[0]
+            session_name = driver_id
+
+        existing_session = get_browser_session(session_name)
+        if existing_session and _ensure_selenium_session(session_name, existing_session) not in failed_tag_list:
+            driver_id = session_name
 
         if (
             driver_id not in selenium_details
@@ -1117,9 +1365,12 @@ def Go_To_Link(dataset: Dataset) -> ReturnType:
                 sModuleInfo, "Browser not previously opened, doing so now", 1
             )
 
-            if Open_Browser(dependency["Browser"], browser_options) == "zeuz_failed":
+            if await Open_Browser(dependency["Browser"], browser_options, session_name) == "zeuz_failed":
                 return "zeuz_failed"
 
+            session_data = get_browser_session(session_name)
+            selenium_driver = session_data.get("selenium_driver", Shared_Resources.Get_Shared_Variables("selenium_driver"))
+
             if ConfigModule.get_config_value(
                 "RunDefinition", "window_size_x"
             ) and ConfigModule.get_config_value("RunDefinition", "window_size_y"):
@@ -1139,13 +1390,18 @@ def Go_To_Link(dataset: Dataset) -> ReturnType:
             else:
                 selenium_driver.set_window_size(window_size_X, window_size_Y)
 
+            if debug_port is None:
+                debug_port = session_data.get("remote_debugging_port") or get_debug_port(session_name)
+
             selenium_details[driver_id] = {
                 "driver": Shared_Resources.Get_Shared_Variables("selenium_driver"),
                 "remote-debugging-port": debug_port
             }
         else:
-            selenium_driver = selenium_details[driver_id]["driver"]
+            session_data = get_browser_session(session_name)
+            selenium_driver = session_data.get("selenium_driver") or selenium_details[driver_id]["driver"]
             Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+            Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
         current_driver_id = driver_id
     except Exception:
         ErrorMessage = "failed to open browser"
@@ -1191,7 +1447,7 @@ def Go_To_Link(dataset: Dataset) -> ReturnType:
             # If the browser is closed but selenium instance is on, relaunch selenium_driver
             if Shared_Resources.Test_Shared_Variables("dependency"):
                 dependency = Shared_Resources.Get_Shared_Variables("dependency")
-            result = Open_Browser(dependency["Browser"], browser_options)
+            result = await Open_Browser(dependency["Browser"], browser_options, session_name)
         else:
             result = "zeuz_failed"
 
@@ -1584,6 +1840,10 @@ def Enter_Text_In_Text_Box(step_data):
         use_js = False
         clear = True
         global selenium_driver
+        
+        # Handle session parameter
+        session_name, selenium_driver, current_driver_id = _handle_selenium_session(step_data)
+        
         Element = LocateElement.Get_Element(step_data, selenium_driver)
         if Element == "zeuz_failed":
             CommonUtil.ExecLog(
@@ -1593,7 +1853,10 @@ def Enter_Text_In_Text_Box(step_data):
         for left, mid, right in step_data:
             mid = mid.strip().lower()
             left = left.strip().lower()
-            if mid == "action":
+            # Skip session parameter - already handled above
+            if left == "session" and mid == "optional parameter":
+                continue
+            if "action" in mid:
                 text_value = right
             elif left == "delay":
                 delay = float(right.strip())
@@ -2027,8 +2290,14 @@ def Click_Element(data_set, retry=0):
     global selenium_driver
     use_js = False  # Use js to click on element?
     try:
+        # Handle session parameter
+        session_name, selenium_driver, current_driver_id = _handle_selenium_session(data_set)
+        
         location = ""
         for row in data_set:
+            # Skip session parameter - already handled above
+            if row[0].lower().replace(" ", "").replace("_", "").replace("-", "") == "session" and row[1].strip().lower() == "optional parameter":
+                continue
             if row[0] == "offset" and row[1] == "optional parameter":
                 location = row[
                     2
@@ -2974,6 +3243,9 @@ def Validate_Text(step_data):
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global selenium_driver
     try:
+        # Handle session parameter
+        session_name, selenium_driver, current_driver_id = _handle_selenium_session(step_data)
+        
         Element = LocateElement.Get_Element(step_data, selenium_driver)
         ignore_case = False
         zeuz_ai = None
@@ -2983,6 +3255,9 @@ def Validate_Text(step_data):
             )
             return "zeuz_failed"
         for each_step_data_item in step_data:
+            # Skip session parameter - already handled above
+            if each_step_data_item[0].lower().replace(" ", "").replace("_", "").replace("-", "") == "session" and each_step_data_item[1].strip().lower() == "optional parameter":
+                continue
             if each_step_data_item[1] == "action":
                 expected_text_data = each_step_data_item[2]
                 validation_type = each_step_data_item[0]
@@ -3088,6 +3363,9 @@ def Scroll(step_data):
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global selenium_driver
     try:
+        # Handle session parameter
+        session_name, selenium_driver, current_driver_id = _handle_selenium_session(step_data)
+        
         Element = None
         get_element = False
         scroll_direction = ""
@@ -3095,6 +3373,10 @@ def Scroll(step_data):
         pixel = 750
         for left, mid, right in step_data:
             mid = mid.strip().lower()
+            left_clean = left.replace(" ", "").replace("_", "").replace("-", "").lower()
+            # Skip session parameter - already handled above
+            if left_clean == "session" and mid == "optional parameter":
+                continue
             if "action" in mid:
                 scroll_direction = right.strip().lower()
             elif mid == "element parameter":
@@ -3371,15 +3653,76 @@ def Tear_Down_Selenium(step_data=[]):
     global current_driver_id
     try:
         driver_id = ""
+        session_name = None
+        
+        # Parse both driverid (legacy) and session (new) parameters
         for left, mid, right in step_data:
             left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
-            if left == "driverid":
+            if left == "session" and mid.strip().lower() == "optional parameter":
+                session_name = right.strip()
+                driver_id = session_name
+            elif left == "driverid":
                 driver_id = right.strip()
 
-        if not driver_id:
+        # Handle session-specific teardown
+        if session_name:
+            existing_session = get_browser_session(session_name)
+            
+            if existing_session and existing_session.get("selenium_driver"):
+                try:
+                    try:
+                        _close_maybe_async(existing_session.get("playwright_context"))
+                        _close_maybe_async(existing_session.get("playwright_browser"))
+                        _close_maybe_async(existing_session.get("playwright_instance"), "stop")
+                    except Exception:
+                        pass
+                    # Close the specific session's browser
+                    session_driver = existing_session["selenium_driver"]
+                    session_driver.quit()
+                    CommonUtil.ExecLog(sModuleInfo, f"Teared down session '{session_name}'", 1)
+                except Exception as e:
+                    errMsg = f"Unable to tear down session '{session_name}'. may already been killed"
+                    CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
+                    CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
+                
+                remove_browser_session(session_name)
+                
+                # Remove from selenium_details if present
+                if session_name in selenium_details:
+                    del selenium_details[session_name]
+                
+                # If this was the current driver, switch to another or clear
+                if current_driver_id == session_name:
+                    if selenium_details:
+                        for driver in selenium_details:
+                            selenium_driver = selenium_details[driver]["driver"]
+                            Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+                            CommonUtil.ExecLog(sModuleInfo, f"Current driver switched to driver_id='{driver}'", 1)
+                            current_driver_id = driver
+                            break
+                    else:
+                        Shared_Resources.Remove_From_Shared_Variables("selenium_driver")
+                        selenium_driver = None
+                        current_driver_id = None
+            else:
+                CommonUtil.ExecLog(sModuleInfo, f"Session '{session_name}' not found. Nothing to tear down.", 2)
+        
+        # Handle existing driver_id logic (backwards compatibility)
+        elif not driver_id:
             CommonUtil.Join_Thread_and_Return_Result(
                 "screenshot"
             )  # Let the capturing screenshot end in thread
+            for session_name, session in get_browser_sessions().items():
+                if not (isinstance(session, dict) and session.get("selenium_driver")):
+                    continue
+                if session.get("playwright_page") and session_name not in selenium_details:
+                    continue
+                try:
+                    _close_maybe_async(session.get("playwright_context"))
+                    _close_maybe_async(session.get("playwright_browser"))
+                    _close_maybe_async(session.get("playwright_instance"), "stop")
+                except Exception:
+                    pass
             for driver in selenium_details:
                 try:
                     selenium_details[driver]["driver"].quit()
@@ -3394,8 +3737,20 @@ def Tear_Down_Selenium(step_data=[]):
                     CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
                     CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
             Shared_Resources.Remove_From_Shared_Variables("selenium_driver")
+            sessions = get_browser_sessions()
+            sessions = {
+                name: session
+                for name, session in sessions.items()
+                if not (
+                    isinstance(session, dict)
+                    and session.get("selenium_driver")
+                    and (not session.get("playwright_page") or name in selenium_details)
+                )
+            }
+            Shared_Resources.Set_Shared_Variables("browser_sessions", sessions)
             selenium_details = {}
             selenium_driver = None
+            current_driver_id = None
 
         elif driver_id not in selenium_details:
             CommonUtil.ExecLog(
@@ -3418,6 +3773,7 @@ def Tear_Down_Selenium(step_data=[]):
                     2,
                 )
             del selenium_details[driver_id]
+            remove_browser_session(driver_id)
             if selenium_details:
                 for driver in selenium_details:
                     selenium_driver = selenium_details[driver]["driver"]
@@ -3459,13 +3815,19 @@ def Switch_Browser(step_data):
         driver_id = ""
         for left, mid, right in step_data:
             left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
-            if left == "driverid":
+            if left in ("driverid", "session"):
                 driver_id = right.strip()
 
         if not driver_id:
             driver_id = "default"
 
-        if driver_id not in selenium_details:
+        existing_session = get_browser_session(driver_id)
+        if existing_session and existing_session.get("selenium_driver"):
+            selenium_driver = existing_session["selenium_driver"]
+            selenium_details.setdefault(driver_id, {})["driver"] = selenium_driver
+            if existing_session.get("remote_debugging_port"):
+                selenium_details[driver_id]["remote-debugging-port"] = existing_session["remote_debugging_port"]
+        elif driver_id not in selenium_details:
             CommonUtil.ExecLog(
                 sModuleInfo,
                 "Driver_id='%s' not found. So could not Switch" % driver_id,
@@ -3474,11 +3836,13 @@ def Switch_Browser(step_data):
             return "zeuz_failed"
         else:
             selenium_driver = selenium_details[driver_id]["driver"]
-            Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
-            current_driver_id = driver_id
-            CommonUtil.ExecLog(
-                sModuleInfo, "Current driver is set to driver_id='%s'" % driver_id, 1
-            )
+        Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
+        current_driver_id = driver_id
+        Shared_Resources.Set_Shared_Variables("active_web_driver_type", "selenium")
+        CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
+        CommonUtil.ExecLog(
+            sModuleInfo, "Current driver is set to driver_id='%s'" % driver_id, 1
+        )
 
         return "passed"
     except Exception:
@@ -4608,16 +4972,23 @@ def drag_and_drop(dataset):
 def playwright(dataset):
     sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     global selenium_driver
+    global selenium_details
+    global current_driver_id
     try:
         from playwright.sync_api import sync_playwright
 
+        # Get the correct remote debugging port for current driver
+        debug_port = 9222  # fallback
+        if current_driver_id and current_driver_id in selenium_details:
+            debug_port = selenium_details[current_driver_id].get("remote-debugging-port") or 9222
+
         devtools_url = (
             selenium_driver.command_executor._url.replace("http://", "ws://")
             + "/devtools/browser"
         )
         with sync_playwright() as p:
             # browser = p.chromium.connect(browserURL=devtools_url)
-            browser = p.chromium.connect_over_cdp("http://localhost:9222")
+            browser = p.chromium.connect_over_cdp(f"http://localhost:{debug_port}")
             page = browser.contexts[0].pages[0]
 
             # source = page.locator("//div[contains(text(), 'abcd')]")
diff --git a/Framework/Built_In_Automation/Web/utils.py b/Framework/Built_In_Automation/Web/utils.py
new file mode 100644
index 000000000..25562f831
--- /dev/null
+++ b/Framework/Built_In_Automation/Web/utils.py
@@ -0,0 +1,365 @@
+import hashlib
+import inspect
+import socket
+import sys
+
+from Framework.Utilities import CommonUtil
+from Framework.Built_In_Automation.Shared_Resources import (
+    BuiltInFunctionSharedResources as sr,
+)
+from playwright.async_api import Browser, BrowserContext, Frame, Page
+from selenium.webdriver import Chrome, Firefox, Edge, Safari
+
+
+
+def initialize_browser_sessions():
+    """
+    Checks if `browser_sessions` shared variable is already initialized.
+    If not, initializes it as an empty dictionary.
+    """
+    
+    if sr.Test_Shared_Variables("browser_sessions") == False:
+        sr.Set_Shared_Variables("browser_sessions", {})
+
+
+def get_browser_sessions() -> dict:
+    """Return the browser session registry, initializing it when needed."""
+
+    if sr.Test_Shared_Variables("browser_sessions") == False:
+        initialize_browser_sessions()
+
+    browser_sessions = sr.Get_Shared_Variables("browser_sessions", log=False)
+    if not isinstance(browser_sessions, dict):
+        browser_sessions = {}
+        sr.Set_Shared_Variables("browser_sessions", browser_sessions)
+
+    return browser_sessions
+
+
+def extract_session_name(step_data) -> str | None:
+    """Return the optional browser session name from Zeuz step data."""
+
+    if not step_data:
+        return None
+
+    for left, mid, right in step_data:
+        left_l = left.replace(" ", "").replace("_", "").replace("-", "").lower()
+        if left_l == "session" and mid.strip().lower() == "optional parameter":
+            session_name = right.strip()
+            return session_name or None
+
+    return None
+
+
+def remove_browser_session(session_name: str) -> dict | None:
+    """Remove and return a browser session from the shared registry."""
+
+    browser_sessions = get_browser_sessions()
+    removed = browser_sessions.pop(session_name, None)
+    sr.Set_Shared_Variables("browser_sessions", browser_sessions)
+    return removed
+
+
+def is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(0.2)
+        return sock.connect_ex(("127.0.0.1", port)) == 0
+
+
+def get_debug_port(session_name: str, start: int = 9222, stop: int = 9322) -> int:
+    """Pick an available CDP port, preferring a stable session-name hash."""
+
+    used_ports = {
+        session.get("remote_debugging_port")
+        for session in get_browser_sessions().values()
+        if isinstance(session, dict) and session.get("remote_debugging_port")
+    }
+
+    port_range = stop - start + 1
+    port_hash = int(hashlib.md5(session_name.encode()).hexdigest(), 16)
+    first = start + (port_hash % port_range)
+    candidates = list(range(first, stop + 1)) + list(range(start, first))
+
+    for port in candidates:
+        if port not in used_ports and not is_port_in_use(port):
+            return port
+
+    raise RuntimeError(f"No available remote debugging port in range {start}-{stop}")
+
+
+def create_browser_session(
+    session_name: str = "default",
+    selenium_driver: Chrome | Firefox | Edge | Safari | None = None,
+    playwright_page: Page | None = None,
+    playwright_browser: Browser | None = None,
+    playwright_context: BrowserContext | None = None,
+    playwright_frame: Frame | None = None,
+    remote_debugging_port: int | None = None,
+    playwright_instance = None,
+) -> dict:
+    """
+    Creates a new browser session with the given parameters.
+    Replaces the session if it already exists with the given name.
+    
+    Args:
+        session_name (str): The name of the session.
+        selenium_driver (Chrome | Firefox | Edge | Safari): The Selenium WebDriver instance.
+        playwright_page (Page): The Playwright Page instance.
+        playwright_browser (Browser): The Playwright Browser instance.
+        playwright_context (BrowserContext): The Playwright BrowserContext instance.
+        playwright_frame (Frame): The Playwright Frame instance.
+    """
+    
+    browser_sessions = get_browser_sessions()
+    browser_sessions[session_name] = {
+        "selenium_driver": selenium_driver,
+        "playwright_page": playwright_page,
+        "playwright_browser": playwright_browser,
+        "playwright_context": playwright_context,
+        "playwright_frame": playwright_frame,
+        "playwright_instance": playwright_instance,
+        "remote_debugging_port": remote_debugging_port,
+    }
+    sr.Set_Shared_Variables("browser_sessions", browser_sessions)
+
+    return browser_sessions[session_name]
+
+
+def get_browser_session(session_name: str) -> dict:
+    """
+    Returns the browser session with the given name.
+    
+    Args:
+        session_name (str): The name of the session.
+    
+    Returns:
+        dict: The browser session with the given name.
+    """
+    
+    browser_sessions = get_browser_sessions()
+    return browser_sessions.get(session_name, {})
+
+
+def _find_session_name_by_object(key: str, value) -> str | None:
+    """Return the session name that owns the given browser object."""
+
+    if value is None:
+        return None
+
+    for name, session in get_browser_sessions().items():
+        if isinstance(session, dict) and session.get(key) is value:
+            return name
+
+    return None
+
+
+def _resolve_browser_session_name(step_data=None) -> str | None:
+    """Resolve the browser session to hydrate for custom Python code."""
+
+    session_name = extract_session_name(step_data)
+    if session_name:
+        return session_name
+
+    active_type = sr.shared_variables.get("active_web_driver_type")
+    if active_type == "playwright":
+        session_name = _find_session_name_by_object(
+            "playwright_page", sr.shared_variables.get("playwright_page")
+        )
+        if session_name:
+            return session_name
+    elif active_type == "selenium":
+        session_name = _find_session_name_by_object(
+            "selenium_driver", sr.shared_variables.get("selenium_driver")
+        )
+        if session_name:
+            return session_name
+
+    session_name = _find_session_name_by_object(
+        "playwright_page", sr.shared_variables.get("playwright_page")
+    )
+    if session_name:
+        return session_name
+
+    session_name = _find_session_name_by_object(
+        "selenium_driver", sr.shared_variables.get("selenium_driver")
+    )
+    if session_name:
+        return session_name
+
+    if "default" in get_browser_sessions():
+        return "default"
+
+    return None
+
+
+def _set_browser_shared_variables(session: dict):
+    """Hydrate canonical browser shared variables from a session."""
+
+    if session.get("selenium_driver") is not None:
+        sr.Set_Shared_Variables(
+            "selenium_driver", session["selenium_driver"], print_variable=False
+        )
+    if session.get("playwright_page") is not None:
+        sr.Set_Shared_Variables(
+            "playwright_page", session["playwright_page"], print_variable=False
+        )
+    if session.get("playwright_context") is not None:
+        sr.Set_Shared_Variables(
+            "playwright_context", session["playwright_context"], print_variable=False
+        )
+    if session.get("playwright_browser") is not None:
+        sr.Set_Shared_Variables(
+            "playwright_browser", session["playwright_browser"], print_variable=False
+        )
+    if session.get("playwright_frame") is not None:
+        sr.Set_Shared_Variables(
+            "playwright_frame", session["playwright_frame"], print_variable=False
+        )
+
+
+def _restore_active_web_driver_type(previous_active_type):
+    if previous_active_type:
+        sr.Set_Shared_Variables(
+            "active_web_driver_type",
+            previous_active_type,
+            print_variable=False,
+        )
+    else:
+        sr.Remove_From_Shared_Variables("active_web_driver_type")
+
+
+def _align_selenium_to_playwright_page(session: dict):
+    selenium_driver = session.get("selenium_driver")
+    playwright_page = session.get("playwright_page")
+    target_url = getattr(playwright_page, "url", None)
+
+    if not selenium_driver or not target_url:
+        return
+
+    try:
+        current_handle = selenium_driver.current_window_handle
+        for handle in selenium_driver.window_handles:
+            selenium_driver.switch_to.window(handle)
+            if selenium_driver.current_url == target_url:
+                return
+        selenium_driver.switch_to.window(current_handle)
+    except Exception:
+        pass
+
+
+async def _align_playwright_to_selenium_window(session_name: str, session: dict):
+    selenium_driver = session.get("selenium_driver")
+    playwright_context = session.get("playwright_context")
+
+    if not selenium_driver or not playwright_context:
+        return
+
+    try:
+        target_url = selenium_driver.current_url
+    except Exception:
+        return
+
+    if not target_url:
+        return
+
+    try:
+        for page in playwright_context.pages:
+            if page.url == target_url:
+                session["playwright_page"] = page
+                sessions = get_browser_sessions()
+                if session_name in sessions:
+                    sessions[session_name]["playwright_page"] = page
+                    sr.Set_Shared_Variables(
+                        "browser_sessions", sessions, print_variable=False
+                    )
+                return
+    except Exception:
+        pass
+
+
+async def hydrate_browser_compatibility_globals(step_data=None):
+    """
+    Populate canonical Selenium/Playwright shared variables for custom Python.
+
+    This uses the existing lazy CDP bridge in the Selenium and Playwright action
+    modules. It intentionally does not create user-facing convenience aliases.
+    """
+
+    sModuleInfo = "hydrate_browser_compatibility_globals : Web.utils"
+    session_name = _resolve_browser_session_name(step_data)
+    if not session_name:
+        return "passed"
+
+    session = get_browser_session(session_name)
+    if not isinstance(session, dict) or not session:
+        CommonUtil.ExecLog(
+            sModuleInfo, f"Browser session '{session_name}' not found", 2
+        )
+        return "zeuz_failed"
+
+    previous_active_type = sr.shared_variables.get("active_web_driver_type")
+
+    try:
+        if session.get("playwright_page") and not session.get("selenium_driver"):
+            if session.get("selenium_cdp_supported") is False:
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    f"Selenium compatibility is only supported for Chromium Playwright sessions: {session_name}",
+                    2,
+                )
+            else:
+                from Framework.Built_In_Automation.Web.Selenium import (
+                    BuiltInFunctions as SeleniumBuiltInFunctions,
+                )
+
+                result = SeleniumBuiltInFunctions._ensure_selenium_session(
+                    session_name, session
+                )
+                if inspect.isawaitable(result):
+                    result = await result
+                if result in ("zeuz_failed", "failed", False):
+                    CommonUtil.ExecLog(
+                        sModuleInfo,
+                        f"Could not hydrate Selenium globals for browser session '{session_name}'",
+                        2,
+                    )
+
+        session = get_browser_session(session_name)
+        if session.get("selenium_driver") and not session.get("playwright_page"):
+            if session.get("remote_debugging_port"):
+                from Framework.Built_In_Automation.Web.Playwright import (
+                    BuiltInFunctions as PlaywrightBuiltInFunctions,
+                )
+
+                result = await PlaywrightBuiltInFunctions._ensure_playwright_session(
+                    session_name, session
+                )
+                if result in ("zeuz_failed", "failed", False):
+                    CommonUtil.ExecLog(
+                        sModuleInfo,
+                        f"Could not hydrate Playwright globals for browser session '{session_name}'",
+                        2,
+                    )
+            else:
+                CommonUtil.ExecLog(
+                    sModuleInfo,
+                    f"Playwright compatibility requires a remote debugging port for session '{session_name}'",
+                    2,
+                )
+
+        session = get_browser_session(session_name)
+        if isinstance(session, dict):
+            _align_selenium_to_playwright_page(session)
+            await _align_playwright_to_selenium_window(session_name, session)
+
+        if isinstance(session, dict):
+            _set_browser_shared_variables(session)
+
+        _restore_active_web_driver_type(previous_active_type)
+
+        CommonUtil.set_screenshot_vars(sr.Shared_Variable_Export())
+        return "passed"
+    except Exception:
+        CommonUtil.Exception_Handler(sys.exc_info())
+        _restore_active_web_driver_type(previous_active_type)
+        return "zeuz_failed"
diff --git a/Framework/MainDriverApi.py b/Framework/MainDriverApi.py
index 35fd30652..b8472c75e 100644
--- a/Framework/MainDriverApi.py
+++ b/Framework/MainDriverApi.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # -*- coding: cp1252 -*-
+import asyncio
 import concurrent.futures
 import copy
 import json
@@ -307,7 +308,7 @@ def terminate_thread(thread):   # To kill running thread
         raise SystemError("PyThreadState_SetAsyncExc failed")
 
 # call the function of a test step that is in its driver file
-def call_driver_function_of_test_step(
+async def call_driver_function_of_test_step(
     sModuleInfo,
     all_step_info,
     StepSeq,
@@ -338,6 +339,7 @@ def call_driver_function_of_test_step(
             try:
                 # importing functions from driver
                 functionTocall = getattr(module_name, step_name)
+                print(functionTocall)
             except Exception as e:
                 CommonUtil.Exception_Handler(
                     sys.exc_info(),
@@ -353,14 +355,20 @@ def call_driver_function_of_test_step(
 
                 # run in thread
                 if ConfigModule.get_config_value("RunDefinition", "threading") in passed_tag_list:
+                    thread_args = (
+                        test_steps_data,
+                        test_action_info,
+                        simple_queue,
+                        debug_actions,
+                    )
+                    thread_target = functionTocall
+                    if inspect.iscoroutinefunction(functionTocall):
+                        def thread_target(*args):
+                            return asyncio.run(functionTocall(*args))
+
                     stepThread = threading.Thread(
-                        target=functionTocall,
-                        args=(
-                            test_steps_data,
-                            test_action_info,
-                            simple_queue,
-                            debug_actions,
-                        ),
+                        target=thread_target,
+                        args=thread_args,
                     )  # start step thread
 
 
@@ -405,12 +413,20 @@ def call_driver_function_of_test_step(
                                 CommonUtil.Exception_Handler(sys.exc_info())
                 else:
                     # run sequentially
-                    sStepResult = functionTocall(
-                        test_steps_data,
-                        test_action_info,
-                        simple_queue,
-                        debug_actions,
-                    )
+                    if inspect.iscoroutinefunction(functionTocall):
+                        sStepResult = await functionTocall(
+                            test_steps_data,
+                            test_action_info,
+                            simple_queue,
+                            debug_actions,
+                        )
+                    else:
+                        sStepResult = functionTocall(
+                            test_steps_data,
+                            test_action_info,
+                            simple_queue,
+                            debug_actions,
+                        )
             except:
                 CommonUtil.Exception_Handler(sys.exc_info())  # handle exceptions
                 sStepResult = "zeuz_failed"
@@ -437,7 +453,7 @@ def call_driver_function_of_test_step(
 
 
 # runs all test steps of a test case
-def run_all_test_steps_in_a_test_case(
+async def run_all_test_steps_in_a_test_case(
     testcase_info,
     test_case,
     sModuleInfo,
@@ -632,7 +648,7 @@ def run_all_test_steps_in_a_test_case(
                 CommonUtil.ExecLog(sModuleInfo, "STEP-%s is skipped" % StepSeq, 2)
                 sStepResult = "skipped"
             else:
-                sStepResult = call_driver_function_of_test_step(
+                sStepResult = await call_driver_function_of_test_step(
                     sModuleInfo,
                     all_step_info,
                     StepSeq,
@@ -797,13 +813,20 @@ def zip_and_delete_tc_folder(
     FL.DeleteFolder(path)
 
 
-def cleanup_driver_instances():  # cleans up driver(selenium, appium) instances
+async def cleanup_driver_instances():  # cleans up driver(selenium, playwright, appium) instances
     try:  # if error happens. we don't care, main driver should not stop, pass in exception
         import Framework.Built_In_Automation.Web.Selenium.BuiltInFunctions as Selenium
+        import Framework.Built_In_Automation.Web.Playwright.BuiltInFunctions as Playwright
+        try:
+            await Playwright.Tear_Down_Playwright()
+        except:
+            pass
+        
         try:
             Selenium.Tear_Down_Selenium()
         except:
             pass
+        
         if shared.Test_Shared_Variables("appium_details"):
             import Framework.Built_In_Automation.Mobile.CrossPlatform.Appium.BuiltInFunctions as Appium
             driver = shared.Remove_From_Shared_Variables("appium_details")
@@ -962,7 +985,7 @@ def check_test_skip(run_id, tc_num, skip_remaining=True) -> bool:
     return False
 
 
-def run_test_case(
+async def run_test_case(
     TestCaseID,
     sModuleInfo,
     run_id,
@@ -1020,7 +1043,7 @@ def run_test_case(
         if check_test_skip(run_id, tc_num):
             sTestStepResultList = ['SKIPPED' for i in range(len(testcase_info['steps']))]
         else:
-            sTestStepResultList = run_all_test_steps_in_a_test_case(
+            sTestStepResultList = await run_all_test_steps_in_a_test_case(
                 testcase_info,
                 test_case,
                 sModuleInfo,
@@ -1133,7 +1156,7 @@ def run_test_case(
         else:
             CommonUtil.Join_Thread_and_Return_Result("screenshot")
             if str(shared.Get_Shared_Variables("zeuz_auto_teardown")).strip().lower() not in ("off", "no", "false", "disable"):
-                cleanup_driver_instances()
+                await cleanup_driver_instances()
             shared.Clean_Up_Shared_Variables(run_id)
 
             if ConfigModule.get_config_value("RunDefinition", "local_run") == "False":
@@ -1832,7 +1855,7 @@ def download_or_copy(attachment):
 
 
 # main function
-def main(device_dict, all_run_id_info):
+async def main(device_dict, all_run_id_info):
     try:
         # get module info
         sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
@@ -1945,7 +1968,7 @@ def main(device_dict, all_run_id_info):
                 if "debug_step_actions" in run_id_info:
                     debug_info["debug_step_actions"] = run_id_info["debug_step_actions"]
                 if run_id_info["debug_clean"] == "YES":
-                    cleanup_driver_instances()
+                    await cleanup_driver_instances()
                     shared.Clean_Up_Shared_Variables(run_id)
             driver_list = ["Not needed currently"]
 
@@ -1966,7 +1989,7 @@ def main(device_dict, all_run_id_info):
                 shared.Set_Shared_Variables("zeuz_auto_teardown", "on")
 
             if not CommonUtil.debug_status and str(shared.Get_Shared_Variables("zeuz_auto_teardown")).strip().lower() not in ("off", "no", "false", "disable"):
-                cleanup_driver_instances()
+                await cleanup_driver_instances()
 
             if not shared.Test_Shared_Variables("zeuz_collect_browser_log"):
                 shared.Set_Shared_Variables("zeuz_collect_browser_log", "on")
@@ -2119,7 +2142,7 @@ def kill(process):
                             )
                         except Exception as e:
                             CommonUtil.ExecLog(sModuleInfo, str(e), 3)
-                            run_test_case(
+                            await run_test_case(
                                 test_case_no,
                                 sModuleInfo,
                                 run_id,
@@ -2137,7 +2160,7 @@ def kill(process):
 
 
                     else:
-                        run_test_case(
+                        await run_test_case(
                             test_case_no,
                             sModuleInfo,
                             run_id,
diff --git a/Framework/Utilities/CommonUtil.py b/Framework/Utilities/CommonUtil.py
index 28215917b..546a74216 100644
--- a/Framework/Utilities/CommonUtil.py
+++ b/Framework/Utilities/CommonUtil.py
@@ -166,6 +166,7 @@ def temp_config() -> Path:
 AUTO_SCREENSHOT_DEBUG_DELAY_SECONDS = 3
 AUTO_SCREENSHOT_DEBUG_DELAY_POLL_SECONDS = 0.25
 CANCELLED_RUN_STATUS = "Cancelled"
+PLAYWRIGHT_AUTO_SCREENSHOT_QUALITY = 70
 
 # Metrics variables
 browser_perf = {}
@@ -842,14 +843,18 @@ def set_screenshot_vars(shared_variables):
                 screen_capture_driver = appium_details[device_id][
                     "driver"
                 ]  # Driver for selected device
-        if screen_capture_type == "web":  # Selenium driver object
-            if "selenium_driver" in shared_variables:
+        if screen_capture_type == "web":  # Selenium or Playwright driver object
+            if shared_variables.get("active_web_driver_type") == "playwright" and "playwright_page" in shared_variables:
+                screen_capture_driver = shared_variables["playwright_page"]
+            elif "selenium_driver" in shared_variables:
                 screen_capture_driver = shared_variables["selenium_driver"]
+            elif "playwright_page" in shared_variables:
+                screen_capture_driver = shared_variables["playwright_page"]
     except:
         ExecLog(sModuleInfo, "Error setting screenshot variables", 3)
 
 
-def TakeScreenShot(function_name, local_run=False):
+async def TakeScreenShot(function_name, local_run=False):
     """ Puts TakeScreenShot into a thread, so it doesn't block test case execution """
     if not ws_ss_log or performance_testing: return
     try:
@@ -898,8 +903,7 @@ def TakeScreenShot(function_name, local_run=False):
                     break
             image_name = "Step#" + current_step_no + "_Action#" + current_action_no + "_" + filename
 
-        thread = executor.submit(Thread_ScreenShot, function_name, image_folder, Method, Driver, image_name)
-        SaveThread("screenshot", thread)
+        await Thread_ScreenShot(function_name, image_folder, Method, Driver, image_name)
 
     except:
         return Exception_Handler(sys.exc_info())
@@ -990,10 +994,11 @@ def _get_window_screenshot_bbox():
     return None
 
 
-def Thread_ScreenShot(function_name, image_folder, Method, Driver, image_name):
-    """ Capture screen of mobile or desktop """
-    if performance_testing: return
-    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
+def _is_playwright_page(driver):
+    return driver.__class__.__module__.startswith("playwright.") and hasattr(driver, "screenshot")
+
+
+def _screenshot_path(image_folder, image_name, extension="png"):
     chars_to_remove = [
         r"?",
         r"*",
@@ -1004,15 +1009,22 @@ def Thread_ScreenShot(function_name, image_folder, Method, Driver, image_name):
         r"\\",
         r"\/",
         r":",
-    ]  # Symbols that can't be used in filename
+    ]
+    trans_table = str.maketrans(dict.fromkeys("".join(chars_to_remove)))
+    safe_name = (image_name.translate(trans_table)).strip().replace(" ", "_")
+    return os.path.join(image_folder, safe_name + "." + extension.lstrip("."))
+
+
+async def Thread_ScreenShot(function_name, image_folder, Method, Driver, image_name):
+    """ Capture screen of mobile or desktop """
+    if performance_testing: return
+    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
     picture_quality = 100  # Quality of picture
     picture_size = 1920, 1080  # Size of image (for reduction in file size)
+    is_playwright_page = Method == "web" and Driver is not None and _is_playwright_page(Driver)
 
     # Adjust filename and create full path (remove invalid characters, convert spaces to underscore, remove leading and trailing spaces)
-    trans_table = str.maketrans(
-        dict.fromkeys("".join(chars_to_remove))
-    )  # python3 version of translate
-    ImageName = os.path.join(image_folder, (image_name.translate(trans_table)).strip().replace(" ", "_") + ".png")
+    ImageName = _screenshot_path(image_folder, image_name, "jpg" if is_playwright_page else "png")
     ExecLog(sModuleInfo, "Capturing screen on %s, with driver: %s, and saving to %s" % (str(Method), str(Driver), ImageName), 0)
     try:
         should_delay_before_capture = Method == "desktop" and sys.platform in ("linux2", "win32", "darwin")
@@ -1056,7 +1068,11 @@ def Thread_ScreenShot(function_name, image_folder, Method, Driver, image_name):
 
         # Capture screenshot of web browser
         elif Method == "web":
-            Driver.get_screenshot_as_file(ImageName)  # Must be .png, otherwise an exception occurs
+            # Check if it's a Playwright page or Selenium driver
+            if is_playwright_page:
+                await Driver.screenshot(path=ImageName, type="jpeg", quality=PLAYWRIGHT_AUTO_SCREENSHOT_QUALITY)
+            else:  # Selenium driver
+                Driver.get_screenshot_as_file(ImageName)  # Must be .png, otherwise an exception occurs
 
         # Capture screenshot of mobile
         elif Method == "mobile":
@@ -1070,14 +1086,15 @@ def Thread_ScreenShot(function_name, image_folder, Method, Driver, image_name):
             )
         # Lower the picture quality
         if os.path.exists(ImageName):  # Make sure image was saved
-            image = Image.open(ImageName)  # Re-open in standard format
-            image.thumbnail(picture_size, Image.LANCZOS)  # Resize picture to lower file size
-            image.save(ImageName, format="PNG", quality=picture_quality)  # Change quality to reduce file size
+            if not is_playwright_page:
+                image = Image.open(ImageName)  # Re-open in standard format
+                image.thumbnail(picture_size, Image.LANCZOS)  # Resize picture to lower file size
+                image.save(ImageName, format="PNG", quality=picture_quality)  # Change quality to reduce file size
 
             if debug_status:
                 # Convert image to bytearray and send it to live_log_service for streaming.
+                image = Image.open(ImageName)  # Re-open in standard format
                 image_byte_array = pil_image_to_bytearray(image)
-
                 live_log_service.binary(image_byte_array)
         else:
             ExecLog(
diff --git a/Framework/Utilities/decorators.py b/Framework/Utilities/decorators.py
index 3f2b23484..efb9052cd 100644
--- a/Framework/Utilities/decorators.py
+++ b/Framework/Utilities/decorators.py
@@ -1,36 +1,58 @@
 import time
 import functools
+import inspect
 from . import CommonUtil
 from Framework.Utilities.CommonUtil import failed_tag_list
 
 
+def _log_custom_fail_message(result, args):
+    custom_fail_message = ""
+    if isinstance(result, str) and result in failed_tag_list:
+        try:
+            for row in args[0]:
+                if row[1].replace(" ", "").lower() == "failmessage":
+                    custom_fail_message = row[2]
+            # Todo: print the custom_fail_message
+            if custom_fail_message:
+                CommonUtil.ExecLog(None, custom_fail_message, 3)
+        except:
+            pass
+
+
+def _log_function_exit(func_name, start_time):
+    end_time = time.perf_counter()
+    run_time = end_time - start_time
+
+    CommonUtil.ExecLog(
+        None,
+        f"Exited from function: {func_name!r}. Runtime: {run_time:.4f} secs.",
+        5,
+    )
+
+
 def logger(func):
     """Log the entry and exit of the decorated function"""
 
+    if inspect.iscoroutinefunction(func):
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            start_time = time.perf_counter()
+            CommonUtil.ExecLog(None, f"Entering into function: {func.__name__!r}.", 5)
+            result = await func(*args, **kwargs)
+            _log_custom_fail_message(result, args)
+            _log_function_exit(func.__name__, start_time)
+
+            return result
+
+        return async_wrapper
+
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         start_time = time.perf_counter()
         CommonUtil.ExecLog(None, f"Entering into function: {func.__name__!r}.", 5)
-        custom_fail_message = ""
         result = func(*args, **kwargs)
-        if isinstance(result, str) and result in failed_tag_list:
-            try:
-                for row in args[0]:
-                    if row[1].replace(" ", "").lower() == "failmessage":
-                        custom_fail_message = row[2]
-                # Todo: print the custom_fail_message
-                if custom_fail_message:
-                    CommonUtil.ExecLog(None, custom_fail_message, 3)
-            except:
-                pass
-        end_time = time.perf_counter()
-        run_time = end_time - start_time
-
-        CommonUtil.ExecLog(
-            None,
-            f"Exited from function: {func.__name__!r}. Runtime: {run_time:.4f} secs.",
-            5,
-        )
+        _log_custom_fail_message(result, args)
+        _log_function_exit(func.__name__, start_time)
 
         return result
 
diff --git a/node_cli.py b/node_cli.py
index 9e1d9dc25..810a6e531 100755
--- a/node_cli.py
+++ b/node_cli.py
@@ -173,11 +173,7 @@ def signal_handler(sig, frame):
     os._exit(0)
 
 
-async def destroy_session():
-    """
-    Destroy session file.
-    """
-
+def _destroy_session_file():
     # Remove session file if prompted for new authentication
     session_bin_path = Path(RequestFormatter.SESSION_FILE_NAME)
     if session_bin_path.exists():
@@ -187,11 +183,18 @@ async def destroy_session():
             print("[ERROR] failed to remove session file")
 
 
+async def destroy_session():
+    """
+    Destroy session file.
+    """
+    _destroy_session_file()
+
+
 def zeuz_authentication_prompts_for_cli():
     """
     Prompts user for inputting new credentials.
     """
-    destroy_session()
+    _destroy_session_file()
     prompts = ["server_address", "api-key"]
     values = []
     for prompt in prompts:
@@ -440,7 +443,7 @@ async def response_callback(response: str):
             # 3. Call MainDriver
             device_info = All_Device_Info.get_all_connected_device_info()
             await install_handler.cancel_run()
-            MainDriverApi.main(
+            await MainDriverApi.main(
                 device_dict=device_info,
                 all_run_id_info=node_json,
             )
diff --git a/server/installers.py b/server/installers.py
index bc421bc38..495ec7a23 100644
--- a/server/installers.py
+++ b/server/installers.py
@@ -329,7 +329,10 @@ async def _call_status_function(func):
 async def _maybe_await(func, *args, **kwargs):
     if inspect.iscoroutinefunction(func):
         return await func(*args, **kwargs)
-    return await asyncio.to_thread(func, *args, **kwargs)
+    result = await asyncio.to_thread(func, *args, **kwargs)
+    if inspect.isawaitable(result):
+        return await result
+    return result
 
 
 async def _run_job(job: Job) -> None:
diff --git a/tests/test_browser_sessions.py b/tests/test_browser_sessions.py
new file mode 100644
index 000000000..0cd1887bf
--- /dev/null
+++ b/tests/test_browser_sessions.py
@@ -0,0 +1,170 @@
+import asyncio
+from unittest.mock import AsyncMock, MagicMock
+
+from Framework.Built_In_Automation.Shared_Resources import (
+    BuiltInFunctionSharedResources as sr,
+)
+from Framework.Built_In_Automation.Web import utils as browser_utils
+from Framework.Built_In_Automation.Web.Playwright import BuiltInFunctions as playwright_bif
+
+sr.Set_Shared_Variables("dependency", {"Browser": "chrome"})
+from Framework.Built_In_Automation.Web.Selenium import BuiltInFunctions as selenium_bif  # noqa: E402
+
+
+def setup_function():
+    sr.shared_variables.clear()
+    selenium_bif.selenium_driver = None
+    selenium_bif.current_driver_id = None
+    selenium_bif.selenium_details = {}
+    playwright_bif.current_page = None
+    playwright_bif.current_page_id = None
+    playwright_bif.context = None
+    playwright_bif.browser = None
+    playwright_bif.playwright_details = {}
+
+
+def test_selenium_session_activation_selects_driver():
+    driver = MagicMock()
+    browser_utils.create_browser_session(
+        session_name="admin",
+        selenium_driver=driver,
+        remote_debugging_port=9231,
+    )
+
+    result = selenium_bif._activate_browser_session_for_action(
+        [("session", "optional parameter", "admin")],
+        "Click_Element",
+    )
+
+    assert result == "passed"
+    assert selenium_bif.selenium_driver is driver
+    assert selenium_bif.current_driver_id == "admin"
+    assert sr.Get_Shared_Variables("selenium_driver") is driver
+    assert sr.Get_Shared_Variables("active_web_driver_type") == "selenium"
+    assert selenium_bif.selenium_details["admin"]["remote-debugging-port"] == 9231
+
+
+def test_selenium_missing_explicit_session_fails_non_create_action():
+    result = selenium_bif._activate_browser_session_for_action(
+        [("session", "optional parameter", "missing")],
+        "Click_Element",
+    )
+
+    assert result == "zeuz_failed"
+
+
+def test_selenium_missing_explicit_session_allowed_for_browser_creation():
+    result = selenium_bif._activate_browser_session_for_action(
+        [("session", "optional parameter", "new_user")],
+        "Go_To_Link",
+    )
+
+    assert result == "passed"
+
+
+def test_playwright_session_activation_selects_page_and_frame():
+    page = MagicMock()
+    context = MagicMock()
+    browser = MagicMock()
+    frame = MagicMock()
+    selenium_driver = MagicMock()
+    browser_utils.create_browser_session(
+        session_name="buyer",
+        selenium_driver=selenium_driver,
+        playwright_page=page,
+        playwright_context=context,
+        playwright_browser=browser,
+        playwright_frame=frame,
+    )
+
+    result = asyncio.run(
+        playwright_bif._activate_browser_session_for_action(
+            [("session", "optional parameter", "buyer")],
+            "Hover_Over_Element",
+        )
+    )
+
+    assert result == "passed"
+    assert playwright_bif.current_page is page
+    assert playwright_bif.context is context
+    assert playwright_bif.browser is browser
+    assert playwright_bif.current_page_id == "buyer"
+    assert sr.Get_Shared_Variables("playwright_frame") is frame
+    assert sr.Get_Shared_Variables("active_web_driver_type") == "playwright"
+
+
+def test_playwright_missing_explicit_session_fails_non_create_action():
+    result = asyncio.run(
+        playwright_bif._activate_browser_session_for_action(
+            [("session", "optional parameter", "missing")],
+            "Validate_Text",
+        )
+    )
+
+    assert result == "zeuz_failed"
+
+
+def test_remove_browser_session_updates_registry():
+    browser_utils.create_browser_session("temp", selenium_driver=MagicMock())
+
+    removed = browser_utils.remove_browser_session("temp")
+
+    assert removed is not None
+    assert browser_utils.get_browser_session("temp") == {}
+
+
+def test_selenium_global_teardown_preserves_playwright_owned_sessions(monkeypatch):
+    selenium_driver = MagicMock()
+    context = MagicMock()
+    browser = MagicMock()
+    browser_utils.create_browser_session(
+        session_name="playwright_session",
+        selenium_driver=selenium_driver,
+        playwright_page=MagicMock(),
+        playwright_context=context,
+        playwright_browser=browser,
+    )
+    monkeypatch.setattr(
+        "Framework.Utilities.CommonUtil.Join_Thread_and_Return_Result",
+        lambda key: [],
+    )
+
+    result = selenium_bif.Tear_Down_Selenium([])
+
+    assert result == "passed"
+    assert browser_utils.get_browser_session("playwright_session")
+    context.close.assert_not_called()
+    browser.close.assert_not_called()
+
+
+def test_playwright_switch_iframe_uses_index_parameter_after_default_reset():
+    frame_locator = MagicMock()
+    indexed_frame_locator = MagicMock()
+    frame_locator.nth.return_value = indexed_frame_locator
+    page = MagicMock()
+    page.locator.return_value.count = AsyncMock(return_value=2)
+    page.frame_locator.return_value = frame_locator
+    playwright_bif.current_page = page
+    playwright_bif.current_page_id = "default"
+    browser_utils.create_browser_session(
+        session_name="default",
+        playwright_page=page,
+        playwright_context=MagicMock(),
+        playwright_browser=MagicMock(),
+    )
+
+    result = asyncio.run(
+        playwright_bif.switch_iframe(
+            [
+                ("index", "iframe parameter", "default content"),
+                ("index", "iframe parameter", "1"),
+                ("switch iframe", "playwright action", "switch iframe"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    page.frame_locator.assert_called_once_with("iframe")
+    frame_locator.nth.assert_called_once_with(1)
+    assert sr.Get_Shared_Variables("playwright_frame") is indexed_frame_locator
+    assert browser_utils.get_browser_session("default")["playwright_frame"] is indexed_frame_locator
diff --git a/tests/test_logger_decorator.py b/tests/test_logger_decorator.py
new file mode 100644
index 000000000..df6ef99dd
--- /dev/null
+++ b/tests/test_logger_decorator.py
@@ -0,0 +1,83 @@
+import asyncio
+import inspect
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from Framework.Utilities import decorators
+
+
+def test_logger_awaits_async_function_before_exit_log(monkeypatch):
+    logs = []
+
+    def fake_exec_log(module_info, message, level):
+        logs.append(message)
+
+    monkeypatch.setattr(decorators.CommonUtil, "ExecLog", fake_exec_log)
+
+    @decorators.logger
+    async def async_action(data_set):
+        decorators.CommonUtil.ExecLog(None, "Async action body log", 1)
+        await asyncio.sleep(0)
+        return "passed"
+
+    assert inspect.iscoroutinefunction(async_action)
+
+    result = asyncio.run(async_action([]))
+
+    assert result == "passed"
+    assert logs[0] == "Entering into function: 'async_action'."
+    assert logs[1] == "Async action body log"
+    assert logs[2].startswith("Exited from function: 'async_action'. Runtime:")
+
+
+def test_logger_preserves_sync_function_behavior(monkeypatch):
+    logs = []
+
+    def fake_exec_log(module_info, message, level):
+        logs.append(message)
+
+    monkeypatch.setattr(decorators.CommonUtil, "ExecLog", fake_exec_log)
+
+    @decorators.logger
+    def sync_action(data_set):
+        decorators.CommonUtil.ExecLog(None, "Sync action body log", 1)
+        return "passed"
+
+    assert not inspect.iscoroutinefunction(sync_action)
+
+    result = sync_action([])
+
+    assert result == "passed"
+    assert logs[0] == "Entering into function: 'sync_action'."
+    assert logs[1] == "Sync action body log"
+    assert logs[2].startswith("Exited from function: 'sync_action'. Runtime:")
+
+
+def test_logger_preserves_custom_fail_message_for_async_function(monkeypatch):
+    logs = []
+
+    def fake_exec_log(module_info, message, level):
+        logs.append((message, level))
+
+    monkeypatch.setattr(decorators.CommonUtil, "ExecLog", fake_exec_log)
+
+    @decorators.logger
+    async def async_action(data_set):
+        return "zeuz_failed"
+
+    result = asyncio.run(
+        async_action(
+            [
+                ("click", "playwright action", "click"),
+                ("fail message", "failmessage", "Custom failure"),
+            ]
+        )
+    )
+
+    assert result == "zeuz_failed"
+    assert logs[0] == ("Entering into function: 'async_action'.", 5)
+    assert logs[1] == ("Custom failure", 3)
+    assert logs[2][0].startswith("Exited from function: 'async_action'. Runtime:")
+    assert logs[2][1] == 5
diff --git a/tests/test_playwright_actions_parity.py b/tests/test_playwright_actions_parity.py
new file mode 100644
index 000000000..801972f30
--- /dev/null
+++ b/tests/test_playwright_actions_parity.py
@@ -0,0 +1,468 @@
+import asyncio
+
+from Framework.Built_In_Automation.Shared_Resources import (
+    BuiltInFunctionSharedResources as sr,
+)
+from Framework.Built_In_Automation.Sequential_Actions import sequential_actions as sa
+from Framework.Built_In_Automation.Web.Playwright import BuiltInFunctions as pw
+
+
+class FakePage:
+    def __init__(self):
+        self.url = "https://example.test/current"
+        self.viewport_size = {"width": 1000, "height": 800}
+        self.evaluated = []
+
+    async def evaluate(self, script, arg=None):
+        self.evaluated.append((script, arg))
+        return "page-result"
+
+    async def set_viewport_size(self, size):
+        self.viewport_size = size
+
+
+class FakeLocator:
+    def __init__(self, text=""):
+        self.text = text
+        self.evaluated = []
+        self.files = None
+        self.calls = []
+        self.wait_calls = []
+
+    async def inner_text(self):
+        return self.text
+
+    async def text_content(self):
+        return self.text
+
+    async def evaluate(self, script, arg=None, **kwargs):
+        self.evaluated.append((script, arg, kwargs))
+        return "locator-result"
+
+    async def set_input_files(self, file_path, **kwargs):
+        self.files = file_path
+        self.calls.append(("set_input_files", file_path, kwargs))
+
+    async def bounding_box(self, **kwargs):
+        self.calls.append(("bounding_box", kwargs))
+        return {"x": 10, "y": 20, "width": 200, "height": 30}
+
+    async def click(self, **kwargs):
+        self.calls.append(("click", kwargs))
+
+    async def fill(self, text, **kwargs):
+        self.calls.append(("fill", text, kwargs))
+
+    async def press(self, key, **kwargs):
+        self.calls.append(("press", key, kwargs))
+
+    async def type(self, text, **kwargs):
+        self.calls.append(("type", text, kwargs))
+
+    async def hover(self, **kwargs):
+        self.calls.append(("hover", kwargs))
+
+    async def wait_for(self, **kwargs):
+        self.wait_calls.append(kwargs)
+
+    async def count(self):
+        self.calls.append(("count",))
+        return 1
+
+
+def setup_function():
+    sr.shared_variables.clear()
+    pw.current_page = FakePage()
+    pw.context = None
+    pw.browser = None
+    pw.current_page_id = "default"
+
+
+def test_get_current_url_saves_to_selenium_action_row_value():
+    result = pw.Get_Current_URL(
+        [("get current url", "selenium action", "current_url")]
+    )
+
+    assert result == "passed"
+    assert sr.Get_Shared_Variables("current_url") == "https://example.test/current"
+
+
+def test_validate_full_text_uses_visible_line_matching(monkeypatch):
+    locator = FakeLocator("Header\nSuccess\nFooter")
+
+    async def fake_get_element(*args, **kwargs):
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.Validate_Text(
+            [
+                ("id", "element parameter", "message"),
+                ("validate full text", "selenium action", "Success"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+
+
+def test_upload_file_accepts_selenium_action_row_path(monkeypatch, tmp_path):
+    upload_file = tmp_path / "upload.txt"
+    upload_file.write_text("data")
+    locator = FakeLocator()
+
+    async def fake_get_element(*args, **kwargs):
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.upload_file(
+            [
+                ("id", "element parameter", "file-input"),
+                ("upload file", "selenium action", str(upload_file)),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert locator.files == str(upload_file)
+
+
+def test_execute_javascript_supports_variable_and_elem(monkeypatch):
+    locator = FakeLocator()
+
+    async def fake_get_element(*args, **kwargs):
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.execute_javascript(
+            [
+                ("id", "element parameter", "target"),
+                ("variable", "optional parameter", "js_result"),
+                ("execute javascript", "selenium action", "return $elem.textContent"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert sr.Get_Shared_Variables("js_result") == "locator-result"
+    assert "return el.textContent" in locator.evaluated[0][0]
+
+
+def test_click_uses_lazy_locator_and_wait_timeout(monkeypatch):
+    locator = FakeLocator()
+    calls = []
+
+    async def fake_get_element(*args, **kwargs):
+        calls.append(kwargs)
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.Click_Element(
+            [
+                ("id", "element parameter", "save"),
+                ("wait", "optional parameter", "2"),
+                ("click", "playwright action", "click"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls[0]["resolve"] is False
+    assert locator.calls[-1] == ("click", {"timeout": 2000})
+
+
+def test_enter_text_uses_lazy_locator_and_wait_timeout(monkeypatch):
+    locator = FakeLocator()
+    calls = []
+
+    async def fake_get_element(*args, **kwargs):
+        calls.append(kwargs)
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.Enter_Text_In_Text_Box(
+            [
+                ("id", "element parameter", "name"),
+                ("wait", "optional parameter", "3"),
+                ("clear", "optional parameter", "false"),
+                ("text", "playwright action", "Alice"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls[0]["resolve"] is False
+    assert ("type", "Alice", {"timeout": 3000}) in locator.calls
+
+
+def test_upload_file_passes_wait_timeout(monkeypatch, tmp_path):
+    upload_file = tmp_path / "upload.txt"
+    upload_file.write_text("data")
+    locator = FakeLocator()
+    calls = []
+
+    async def fake_get_element(*args, **kwargs):
+        calls.append(kwargs)
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.upload_file(
+            [
+                ("id", "element parameter", "file-input"),
+                ("wait", "optional parameter", "4"),
+                ("upload file", "selenium action", str(upload_file)),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls[0]["resolve"] is False
+    assert locator.calls[-1] == ("set_input_files", str(upload_file), {"timeout": 4000})
+
+
+def test_if_element_exists_uses_resolved_lookup(monkeypatch):
+    locator = FakeLocator()
+    calls = []
+
+    async def fake_get_element(*args, **kwargs):
+        calls.append(kwargs)
+        return locator
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "Get_Element", fake_get_element)
+
+    result = asyncio.run(
+        pw.if_element_exists(
+            [
+                ("id", "element parameter", "maybe"),
+                ("if element exists", "playwright action", "if element exists"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert "resolve" not in calls[0]
+    assert ("count",) in locator.calls
+
+
+def test_wait_for_element_uses_single_lazy_wait(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("state", "input parameter", "attached"),
+                ("wait for element", "playwright action", "5"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "attached", "timeout": 5000, "frame_locator": None}]
+
+
+def test_legacy_wait_with_playwright_driver_routes_to_playwright_wait():
+    sr.Set_Shared_Variables("BROWSER_DRIVER", "playwright")
+    data_set = [("wait", "selenium action", "150")]
+
+    action_subfield = sa.get_browser_driver_routing("selenium action", data_set)
+    action_name = sa.normalize_legacy_playwright_action_name("wait", action_subfield)
+    module, function, original_module, screenshot = sa.common.get_module_and_function(
+        action_name,
+        action_subfield,
+    )
+
+    assert (module, function, original_module, screenshot) == (
+        "playwright",
+        "Wait_For_Element",
+        "",
+        "web",
+    )
+
+
+def test_legacy_wait_with_selenium_driver_keeps_common_wait_route():
+    sr.Set_Shared_Variables("BROWSER_DRIVER", "selenium")
+    data_set = [("wait", "selenium action", "150")]
+
+    action_subfield = sa.get_browser_driver_routing("selenium action", data_set)
+    action_name = sa.normalize_legacy_playwright_action_name("wait", action_subfield)
+    module, function, original_module, screenshot = sa.common.get_module_and_function(
+        action_name,
+        action_subfield,
+    )
+
+    assert (module, function, original_module, screenshot) == (
+        "common",
+        "Wait_For_Element",
+        "selenium",
+        "none",
+    )
+
+
+def test_legacy_wait_defaults_to_visible_with_action_timeout(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("wait", "selenium action", "150"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "visible", "timeout": 150000, "frame_locator": None}]
+
+
+def test_legacy_wait_with_allow_hidden_waits_for_attached(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("allow hidden", "optional parameter", "yes"),
+                ("wait", "selenium action", "10"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "attached", "timeout": 10000, "frame_locator": None}]
+
+
+def test_legacy_wait_disable_defaults_to_hidden_with_action_timeout(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("wait disable", "playwright action", "7"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "hidden", "timeout": 7000, "frame_locator": None}]
+
+
+def test_legacy_wait_disable_with_allow_hidden_waits_for_detached(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("allow hidden", "optional parameter", "yes"),
+                ("wait disable", "selenium action", "3"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "detached", "timeout": 3000, "frame_locator": None}]
+
+
+def test_explicit_state_overrides_legacy_wait_default(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("state", "input parameter", "detached"),
+                ("wait disable", "selenium action", "3"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "detached", "timeout": 3000, "frame_locator": None}]
+
+
+def test_explicit_state_overrides_allow_hidden_state_mapping(monkeypatch):
+    calls = []
+
+    async def fake_wait_for_element(*args, **kwargs):
+        calls.append(kwargs)
+        return "passed"
+
+    monkeypatch.setattr(pw.PlaywrightLocator, "wait_for_element", fake_wait_for_element)
+
+    result = asyncio.run(
+        pw.Wait_For_Element(
+            [
+                ("id", "element parameter", "ready"),
+                ("allow hidden", "optional parameter", "yes"),
+                ("state", "input parameter", "visible"),
+                ("wait", "selenium action", "4"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert calls == [{"state": "visible", "timeout": 4000, "frame_locator": None}]
+
+
+def test_resize_window_accepts_selenium_element_parameter_rows():
+    result = asyncio.run(
+        pw.resize_window(
+            [
+                ("width", "element parameter", "50%"),
+                ("height", "element parameter", "25%"),
+                ("resize window", "selenium action", "resize window"),
+            ]
+        )
+    )
+
+    assert result == "passed"
+    assert pw.current_page.viewport_size == {"width": 500, "height": 200}
diff --git a/tests/test_playwright_locator.py b/tests/test_playwright_locator.py
new file mode 100644
index 000000000..8e768348e
--- /dev/null
+++ b/tests/test_playwright_locator.py
@@ -0,0 +1,439 @@
+import asyncio
+
+from Framework.Built_In_Automation.Shared_Resources import (
+    BuiltInFunctionSharedResources as sr,
+)
+from Framework.Built_In_Automation.Web.Playwright import locator as playwright_locator
+
+
+class FakeLocator:
+    def __init__(self, name="root", count=1, total_count=None, texts=None, text="", stats=None):
+        self.name = name
+        self._count = count
+        self._total_count = count if total_count is None else total_count
+        self.texts = texts
+        self.text = text
+        self.stats = stats if stats is not None else {"wait": 0, "count": 0, "evaluate": 0}
+        self.filtered = False
+        self.nth_index = None
+        self.wait_calls = []
+        self.queries = []
+
+    def locator(self, query):
+        self.queries.append(query)
+        return FakeLocator(f"{self.name}.locator({query})", self._count, self._total_count, self.texts, self.text, self.stats)
+
+    def filter(self, **kwargs):
+        filtered = FakeLocator(f"{self.name}.filter", self._count, self._total_count, self.texts, self.text, self.stats)
+        filtered.filtered = kwargs.get("visible") is True
+        return filtered
+
+    @property
+    def first(self):
+        text = self.texts[0] if self.texts else self.text
+        first = FakeLocator(f"{self.name}.first", min(self._count, 1), self._total_count, self.texts, text, self.stats)
+        first.filtered = self.filtered
+        return first
+
+    def nth(self, index):
+        text = self.texts[index] if self.texts and 0 <= index < len(self.texts) else self.text
+        nth = FakeLocator(f"{self.name}.nth({index})", 1, self._total_count, self.texts, text, self.stats)
+        nth.nth_index = index
+        nth.filtered = self.filtered
+        return nth
+
+    async def wait_for(self, state="visible", timeout=None):
+        self.stats["wait"] += 1
+        self.wait_calls.append((state, timeout))
+        if self._count == 0:
+            raise TimeoutError("not found")
+
+    async def count(self):
+        self.stats["count"] += 1
+        return self._count
+
+    async def all(self):
+        return [self.nth(i) for i in range(self._count)]
+
+    async def text_content(self):
+        return self.text
+
+    async def inner_text(self):
+        return self.text
+
+    async def evaluate(self, script):
+        self.stats["evaluate"] += 1
+        return '<button id="save">Save</button>'
+
+
+class FakePage:
+    def __init__(self, locator_result):
+        self.locator_result = locator_result
+        self.queries = []
+
+    def locator(self, query):
+        self.queries.append(query)
+        return self.locator_result
+
+
+def setup_function():
+    sr.shared_variables.clear()
+    sr.Set_Shared_Variables("element_wait", 1)
+
+
+def test_parser_preserves_numbered_relationship_and_shadow_rows():
+    params = playwright_locator._parse_element_params(
+        [
+            ("tag", "element parameter", "button"),
+            ("class", "parent 2 parameter", "panel"),
+            ("id", "sr 1 element parameter", "shadow-host"),
+            ("wait", "optional parameter", "3"),
+        ]
+    )
+
+    assert params["element_params"] == [("tag", "button")]
+    assert params["parent_params"] == [("class", "parent 2 parameter", "panel")]
+    assert params["shadow_root_params"] == [("id", "sr 1 element parameter", "shadow-host")]
+    assert ("id", "sr 1 element parameter", "shadow-host") not in params["locator_rows"]
+    assert params["wait"] == 3
+
+
+def test_legacy_query_matches_selenium_for_tag_and_text():
+    params = playwright_locator._parse_element_params(
+        [
+            ("tag", "element parameter", "button"),
+            ("text", "element parameter", "Save"),
+        ]
+    )
+
+    query, query_type = playwright_locator._build_legacy_query(params["locator_rows"])
+
+    assert query_type == "xpath"
+    assert query == '//button[text()="Save"]'
+
+
+def test_legacy_query_preserves_parent_child_sibling_rows():
+    params = playwright_locator._parse_element_params(
+        [
+            ("tag", "element parameter", "input"),
+            ("type", "element parameter", "password"),
+            ("id", "parent parameter", "login-form"),
+            ("text", "child parameter", "Required"),
+        ]
+    )
+
+    query, query_type = playwright_locator._build_legacy_query(params["locator_rows"])
+
+    assert query_type == "xpath"
+    assert "input" in query
+    assert '[@type="password"]' in query
+    assert 'ancestor::*[@id="login-form"]' in query
+    assert 'descendant::*[text()="Required"]' in query
+
+
+def test_resolve_single_returns_first_for_multiple_matches():
+    params = playwright_locator._parse_element_params(
+        [("tag", "element parameter", "button")]
+    )
+    root = FakeLocator(count=3)
+
+    result = asyncio.run(playwright_locator._resolve_single(root, params, 1000, "test"))
+
+    assert isinstance(result, FakeLocator)
+    assert result.name.endswith(".filter.first")
+    assert result.filtered is True
+
+
+def test_resolve_single_honors_index_after_visibility_filter():
+    params = playwright_locator._parse_element_params(
+        [
+            ("tag", "element parameter", "button"),
+            ("index", "element parameter", "2"),
+        ]
+    )
+    root = FakeLocator(count=4)
+
+    result = asyncio.run(playwright_locator._resolve_single(root, params, 1000, "test"))
+
+    assert isinstance(result, FakeLocator)
+    assert result.nth_index == 2
+    assert result.filtered is True
+
+
+def test_get_element_uses_legacy_xpath_and_saves_shared_variables():
+    fake_locator = FakeLocator(count=2)
+    page = FakePage(fake_locator)
+
+    result = asyncio.run(
+        playwright_locator.Get_Element(
+            [
+                ("tag", "element parameter", "button"),
+                ("text", "element parameter", "Save"),
+                ("saved_button", "save parameter", "yes"),
+            ],
+            page,
+        )
+    )
+
+    assert result.name.endswith(".filter.first")
+    assert page.queries == ['xpath=//button[text()="Save"]']
+    assert sr.Get_Shared_Variables("saved_button") is result
+    assert sr.Get_Shared_Variables("zeuz_element") is result
+
+
+def test_get_element_lazy_returns_locator_without_wait_count_or_evaluate():
+    fake_locator = FakeLocator(count=2)
+    page = FakePage(fake_locator)
+
+    result = asyncio.run(
+        playwright_locator.Get_Element(
+            [("tag", "element parameter", "button")],
+            page,
+            resolve=False,
+        )
+    )
+
+    assert result.name.endswith(".filter.first")
+    assert result.filtered is True
+    assert fake_locator.stats == {"wait": 0, "count": 0, "evaluate": 0}
+
+
+def test_get_element_lazy_respects_allow_hidden():
+    fake_locator = FakeLocator(count=2)
+    page = FakePage(fake_locator)
+
+    result = asyncio.run(
+        playwright_locator.Get_Element(
+            [
+                ("tag", "element parameter", "button"),
+                ("allow hidden", "optional parameter", "yes"),
+            ],
+            page,
+            resolve=False,
+        )
+    )
+
+    assert result.name.endswith(".first")
+    assert ".filter" not in result.name
+    assert result.filtered is False
+
+
+def test_get_timeout_parses_wait_optional_parameter():
+    timeout = playwright_locator.Get_Timeout(
+        [
+            ("tag", "element parameter", "button"),
+            ("wait", "optional parameter", "2.5"),
+        ]
+    )
+
+    assert timeout == 2500
+
+
+def test_get_element_lazy_falls_back_to_resolved_for_return_all_text_filter_and_index():
+    return_all_locator = FakeLocator(count=2)
+    return_all_result = asyncio.run(
+        playwright_locator.Get_Element(
+            [("tag", "element parameter", "button")],
+            FakePage(return_all_locator),
+            return_all=True,
+            resolve=False,
+        )
+    )
+    assert len(return_all_result) == 2
+    assert return_all_locator.stats["wait"] == 1
+    assert return_all_locator.stats["count"] >= 1
+
+    text_filter_locator = FakeLocator(count=1)
+    text_filter_result = asyncio.run(
+        playwright_locator.Get_Element(
+            [
+                ("tag", "element parameter", "button"),
+                ("text filter", "optional parameter", "true"),
+            ],
+            FakePage(text_filter_locator),
+            resolve=False,
+        )
+    )
+    assert isinstance(text_filter_result, FakeLocator)
+    assert text_filter_locator.stats["wait"] == 1
+    assert text_filter_locator.stats["count"] >= 1
+
+    indexed_locator = FakeLocator(count=2)
+    indexed_result = asyncio.run(
+        playwright_locator.Get_Element(
+            [
+                ("tag", "element parameter", "button"),
+                ("index", "element parameter", "1"),
+            ],
+            FakePage(indexed_locator),
+            resolve=False,
+        )
+    )
+    assert indexed_result.nth_index == 1
+    assert indexed_locator.stats["wait"] == 1
+    assert indexed_locator.stats["count"] >= 1
+
+
+def test_wait_for_element_builds_lazy_locator_and_waits_once():
+    fake_locator = FakeLocator(count=1)
+    page = FakePage(fake_locator)
+
+    result = asyncio.run(
+        playwright_locator.wait_for_element(
+            [
+                ("tag", "element parameter", "button"),
+                ("wait", "optional parameter", "2"),
+            ],
+            page,
+            state="visible",
+        )
+    )
+
+    assert result == "passed"
+    assert fake_locator.stats == {"wait": 1, "count": 0, "evaluate": 0}
+
+
+def test_get_element_accepts_selenium_return_all_elements_keyword():
+    fake_locator = FakeLocator(count=2)
+    page = FakePage(fake_locator)
+
+    result = asyncio.run(
+        playwright_locator.Get_Element(
+            [("tag", "element parameter", "button")],
+            page,
+            return_all_elements=True,
+        )
+    )
+
+    assert len(result) == 2
+    assert page.queries == ["xpath=//button"]
+
+
+def test_unique_parameter_takes_precedence_over_raw_xpath_like_selenium():
+    fake_locator = FakeLocator(count=1)
+    page = FakePage(fake_locator)
+
+    result = playwright_locator._build_locator(
+        page,
+        [
+            ("id", "unique parameter", "primary"),
+            ("xpath", "element parameter", "//button[@id='secondary']"),
+        ],
+        playwright_locator._parse_element_params(
+            [
+                ("id", "unique parameter", "primary"),
+                ("xpath", "element parameter", "//button[@id='secondary']"),
+            ]
+        ),
+    )
+
+    assert result.query_type == "unique"
+    assert page.queries == ['xpath=//*[@id="primary"]']
+
+
+def test_shadow_dom_builder_uses_sr_rows_and_css_query_chain():
+    params = playwright_locator._parse_element_params(
+        [
+            ("id", "sr 1 element parameter", "host"),
+            ("tag", "element parameter", "button"),
+            ("data-action", "element parameter", "save"),
+        ]
+    )
+    page = FakePage(FakeLocator())
+
+    result = playwright_locator._build_shadow_dom_locator(page, params)
+
+    assert result.query_type == "shadow css"
+    assert result.query == 'xpath=//*[@id="host"] >> button[data-action="save"]'
+
+
+def test_raw_xpath_ignores_additional_constraints_like_selenium():
+    fake_locator = FakeLocator(count=1)
+    page = FakePage(fake_locator)
+    params = playwright_locator._parse_element_params(
+        [
+            ("xpath", "element parameter", "//button[@id='save']"),
+            ("text", "element parameter", "Ignored"),
+        ]
+    )
+
+    result = playwright_locator._build_locator(page, params["all_rows"], params)
+
+    assert result.query_type == "xpath"
+    assert page.queries == ["xpath=//button[@id='save']"]
+
+
+def test_allow_hidden_does_not_apply_visible_filter():
+    params = playwright_locator._parse_element_params(
+        [
+            ("tag", "element parameter", "button"),
+            ("allow hidden", "optional parameter", "yes"),
+        ]
+    )
+    root = FakeLocator(count=2)
+
+    result = asyncio.run(playwright_locator._resolve_single(root, params, 1000, "test"))
+
+    assert isinstance(result, FakeLocator)
+    assert result.filtered is False
+
+
+def test_resolve_single_negative_index():
+    params = playwright_locator._parse_element_params(
+        [
+            ("tag", "element parameter", "button"),
+            ("index", "element parameter", "-1"),
+        ]
+    )
+    root = FakeLocator(count=4)
+
+    result = asyncio.run(playwright_locator._resolve_single(root, params, 1000, "test"))
+
+    assert isinstance(result, FakeLocator)
+    assert result.nth_index == 3
+
+
+def test_shadow_dom_rejects_duplicate_sr_indices():
+    params = playwright_locator._parse_element_params(
+        [
+            ("id", "sr 1 element parameter", "host-a"),
+            ("class", "sr 1 element parameter", "host-b"),
+            ("tag", "element parameter", "button"),
+        ]
+    )
+    page = FakePage(FakeLocator())
+
+    assert playwright_locator._build_shadow_dom_locator(page, params) is None
+
+
+def test_shadow_dom_rejects_text_selector():
+    params = playwright_locator._parse_element_params(
+        [
+            ("text", "sr 1 element parameter", "Host"),
+            ("tag", "element parameter", "button"),
+        ]
+    )
+    page = FakePage(FakeLocator())
+
+    assert playwright_locator._build_shadow_dom_locator(page, params) is None
+
+
+def test_text_filter_matches_normalized_nbsp_text():
+    page = FakePage(FakeLocator(count=2, texts=["Hello\xa0World", "Other"]))
+
+    result = asyncio.run(
+        playwright_locator._text_filter(
+            [
+                ("tag", "element parameter", "div"),
+                ("text", "element parameter", "Hello World"),
+            ],
+            page,
+            None,
+            {"allow_hidden": False, "index": None, "sibling_params": []},
+            1000,
+            False,
+        )
+    )
+
+    assert isinstance(result, FakeLocator)
+    assert result.text == "Hello\xa0World"
diff --git a/uv.lock b/uv.lock
index f448fba4a..cd801351a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -3093,21 +3093,21 @@ wheels = [
 
 [[package]]
 name = "playwright"
-version = "1.56.0"
+version = "1.60.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "greenlet" },
     { name = "pyee" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/31/a5362cee43f844509f1f10d8a27c9cc0e2f7bdce5353d304d93b2151c1b1/playwright-1.56.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:b33eb89c516cbc6723f2e3523bada4a4eb0984a9c411325c02d7016a5d625e9c", size = 40611424, upload-time = "2025-11-11T18:39:10.175Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/95/347eef596d8778fb53590dc326c344d427fa19ba3d42b646fce2a4572eb3/playwright-1.56.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b228b3395212b9472a4ee5f1afe40d376eef9568eb039fcb3e563de8f4f4657b", size = 39400228, upload-time = "2025-11-11T18:39:13.915Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/54/6ad97b08b2ca1dfcb4fbde4536c4f45c0d9d8b1857a2d20e7bbfdf43bf15/playwright-1.56.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:0ef7e6fd653267798a8a968ff7aa2dcac14398b7dd7440ef57524e01e0fbbd65", size = 40611424, upload-time = "2025-11-11T18:39:17.093Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/76/6d409e37e82cdd5dda3df1ab958130ae32b46e42458bd4fc93d7eb8749cb/playwright-1.56.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:404be089b49d94bc4c1fe0dfb07664bda5ffe87789034a03bffb884489bdfb5c", size = 46263122, upload-time = "2025-11-11T18:39:20.619Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/84/fb292cc5d45f3252e255ea39066cd1d2385c61c6c1596548dfbf59c88605/playwright-1.56.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64cda7cf4e51c0d35dab55190841bfcdfb5871685ec22cb722cd0ad2df183e34", size = 46110645, upload-time = "2025-11-11T18:39:24.005Z" },
-    { url = "https://files.pythonhosted.org/packages/61/bd/8c02c3388ae14edc374ac9f22cbe4e14826c6a51b2d8eaf86e89fabee264/playwright-1.56.0-py3-none-win32.whl", hash = "sha256:d87b79bcb082092d916a332c27ec9732e0418c319755d235d93cc6be13bdd721", size = 35639837, upload-time = "2025-11-11T18:39:27.174Z" },
-    { url = "https://files.pythonhosted.org/packages/64/27/f13b538fbc6b7a00152f4379054a49f6abc0bf55ac86f677ae54bc49fb82/playwright-1.56.0-py3-none-win_amd64.whl", hash = "sha256:3c7fc49bb9e673489bf2622855f9486d41c5101bbed964638552b864c4591f94", size = 35639843, upload-time = "2025-11-11T18:39:30.851Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/c7/3ee8b556107995846576b4fe42a08ed49b8677619421f2afacf6ee421138/playwright-1.56.0-py3-none-win_arm64.whl", hash = "sha256:2745490ae8dd58d27e5ea4d9aa28402e8e2991eb84fb4b2fd5fbde2106716f6f", size = 31248959, upload-time = "2025-11-11T18:39:33.998Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f0/832bd9677194908da118064eef20082f2791e3d18215cc6d9391ee2c5a67/playwright-1.60.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:6a8cd0fec171fb3089e95e898c8bc8a6f35dea0b78b399e12fcc19427e91b1d7", size = 43474635, upload-time = "2026-05-18T12:00:31.969Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7b/e1d32ae8a3ed937ec2be3721c5f728b13d731a0b7c6442e0b3bec5094ac0/playwright-1.60.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:39b5420ba6145045b69ced4c5c47d4d9fe5bddfc8ff816c518913afcb25ec7a5", size = 42261327, upload-time = "2026-05-18T12:00:35.638Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/bc/23de499ded6411c188a20c5a0dea6f0cd4ed5d2b3cc6042a5dbd3ed609aa/playwright-1.60.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:2581d0e6a3392c71f91b27460c7fd093356818dc430f48153896c8aeeaef7705", size = 43474636, upload-time = "2026-05-18T12:00:39.294Z" },
+    { url = "https://files.pythonhosted.org/packages/22/7b/1d679f4fced4ea94efadd17103856d8c565384f68382a1681264e46f5925/playwright-1.60.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:1c2bfae7884fb3fb05b853290eab8f343d524e5016f2f1def702acbbdf14c93e", size = 47467220, upload-time = "2026-05-18T12:00:43.179Z" },
+    { url = "https://files.pythonhosted.org/packages/84/c2/1528d267d4442bd2c6b8eaeab819dd52c2030bf80e89293f0ba1f687473b/playwright-1.60.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43e66564125ee31b07a58cefb21e256d62d67d8d1713e6858df7a3019d8ed353", size = 47154856, upload-time = "2026-05-18T12:00:46.715Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/4e/b008b6440a7a1624378041da94829956d4b8f7ab9ef5aad22d0dc3f2e26d/playwright-1.60.0-py3-none-win32.whl", hash = "sha256:ec94e416ea320711e0ad4bf185dcbf41833672961e90773e1885255d7db7b7e7", size = 37902157, upload-time = "2026-05-18T12:00:50.374Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f0/0541524133104f9cc20bf900870ff4a736b76a23483f3a55295ddfa58409/playwright-1.60.0-py3-none-win_amd64.whl", hash = "sha256:9566821ce6030a1f9e7146a24e19355ab0d98805fd0f9be50bb3d8fef1750c02", size = 37902159, upload-time = "2026-05-18T12:00:53.728Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c8/210f282d278e4709cdd71b12a31af45a30a22ab3207b387e29b37e478713/playwright-1.60.0-py3-none-win_arm64.whl", hash = "sha256:6e4f6700a4c2250efff8e690a81d66e3855754fb587b6b87cf5c784014f91537", size = 34037981, upload-time = "2026-05-18T12:00:57.584Z" },
 ]
 
 [[package]]