cdp-skill 1.0.8 → 1.0.14

package/src/runner/context-helpers.js

@@ -6,30 +6,18 @@
  * - buildActionContext(action, params, context) → string - Describes what action was taken
  * - buildCommandContext(steps) → string - Summarizes multi-step commands
  * - captureFailureContext(deps) → Object - Gathers debug info on failure
- * - STEP_TYPES - Array of valid step type names
- * - VISUAL_ACTIONS - Actions that trigger auto-screenshot
+ * - STEP_TYPES - Array of valid step type names (from registry)
+ * - VISUAL_ACTIONS - Actions that trigger auto-screenshot (from registry)
  *
- * DEPENDENCIES: None (pure functions)
+ * DEPENDENCIES:
+ * - ./step-registry.js: getAllStepTypes, getVisualActions
  */
 
-export const STEP_TYPES = [
-  'goto', 'wait', 'click', 'fill', 'fillForm', 'press', 'query', 'queryAll',
-  'inspect', 'scroll', 'console', 'pdf', 'eval', 'snapshot', 'snapshotSearch',
-  'hover', 'viewport', 'cookies', 'back', 'forward', 'waitForNavigation', 'listTabs',
-  'closeTab', 'openTab', 'type', 'select', 'selectOption', 'validate', 'submit',
-  'assert', 'switchToFrame', 'switchToMainFrame', 'listFrames', 'drag', 'formState',
-  'extract', 'getDom', 'getBox', 'fillActive', 'refAt', 'elementsAt', 'elementsNear',
-  'reload', 'pageFunction', 'poll', 'pipeline', 'writeSiteProfile', 'readSiteProfile'
-];
+import { getAllStepTypes, getVisualActions } from './step-registry.js';
 
-// Visual actions that trigger auto-screenshot
-// Actions that should capture a screenshot - anything that interacts with or queries the visible page
-export const VISUAL_ACTIONS = [
-  'goto', 'reload', 'click', 'fill', 'fillForm', 'type', 'hover', 'press', 'scroll', 'wait',  // interactions
-  'snapshot', 'snapshotSearch', 'query', 'queryAll', 'inspect', 'eval', 'extract', 'formState',  // queries
-  'drag', 'select', 'selectOption', 'validate', 'submit', 'assert',  // other page interactions
-  'openTab'  // navigation actions - behave like goto for auto-snapshot
-];
+// Re-export from registry for backwards compatibility
+export const STEP_TYPES = getAllStepTypes();
+export const VISUAL_ACTIONS = getVisualActions();
 
 /**
  * Build action context string for diff summary
@@ -59,8 +47,19 @@ export function buildActionContext(action, params, context) {
     case 'hover': {
       if (typeof params === 'string') return `Hovered over ${params}`;
       if (params?.selector) return `Hovered over ${params.selector}`;
+      if (params?.ref) return `Hovered over [ref=${params.ref}]`;
+      if (params?.text) return `Hovered over "${params.text}"`;
+      if (typeof params?.x === 'number' && typeof params?.y === 'number') return `Hovered over (${params.x}, ${params.y})`;
       return 'Hovered over element';
     }
+    case 'frame': {
+      if (params === 'top') return 'Switched to main frame';
+      if (typeof params === 'string') return `Switched to frame ${params}`;
+      if (typeof params === 'number') return `Switched to frame index ${params}`;
+      if (params?.list) return 'Listed frames';
+      if (params?.name) return `Switched to frame "${params.name}"`;
+      return 'Frame operation';
+    }
     case 'fill':
     case 'type': {
       if (params?.selector) return `Typed in ${params.selector}`;
@@ -93,8 +92,8 @@ export function buildCommandContext(steps) {
   if (actions.includes('hover')) return 'Hovered';
   if (actions.includes('fill') || actions.includes('type')) return 'Typed';
   if (actions.includes('press')) return 'Pressed key';
-  if (actions.includes('goto') || actions.includes('openTab')) return 'Navigated';
-  if (actions.includes('select')) return 'Selected';
+  if (actions.includes('goto') || actions.includes('newTab')) return 'Navigated';
+  if (actions.includes('selectText')) return 'Selected';
   if (actions.includes('drag')) return 'Dragged';
 
   // Default: list the actions
@@ -120,10 +119,7 @@ export async function captureFailureContext(deps, options = {}) {
 
   try {
     // Get page title
-    const titleResult = await pageController.session.send('Runtime.evaluate', {
-      expression: 'document.title',
-      returnByValue: true
-    });
+    const titleResult = await pageController.evaluateInFrame('document.title');
     context.title = titleResult.result.value || '';
   } catch {
     context.title = null;
@@ -131,10 +127,7 @@ export async function captureFailureContext(deps, options = {}) {
 
   try {
     // Get current URL
-    const urlResult = await pageController.session.send('Runtime.evaluate', {
-      expression: 'window.location.href',
-      returnByValue: true
-    });
+    const urlResult = await pageController.evaluateInFrame('window.location.href');
     context.url = urlResult.result.value || '';
   } catch {
     context.url = null;
@@ -142,14 +135,11 @@ export async function captureFailureContext(deps, options = {}) {
 
   try {
     // Get scroll position
-    const scrollResult = await pageController.session.send('Runtime.evaluate', {
-      expression: `({
+    const scrollResult = await pageController.evaluateInFrame(`({
         x: window.scrollX || document.documentElement.scrollLeft,
         y: window.scrollY || document.documentElement.scrollTop,
         maxY: Math.max(document.body.scrollHeight, document.documentElement.scrollHeight) - window.innerHeight
-      })`,
-      returnByValue: true
-    });
+      })`);
     const scroll = scrollResult.result.value;
     context.scrollPosition = {
       x: scroll.x,
@@ -163,8 +153,7 @@ export async function captureFailureContext(deps, options = {}) {
 
   try {
     // Get visible buttons with refs (limit 8)
-    const buttonsResult = await pageController.session.send('Runtime.evaluate', {
-      expression: `
+    const buttonsResult = await pageController.evaluateInFrame(`
         (function() {
           const buttons = Array.from(document.querySelectorAll('button, input[type="button"], input[type="submit"], [role="button"]'));
           return buttons
@@ -193,9 +182,7 @@ export async function captureFailureContext(deps, options = {}) {
               return { text, selector, ref };
             });
         })()
-      `,
-      returnByValue: true
-    });
+      `);
     context.visibleButtons = buttonsResult.result.value || [];
   } catch {
     context.visibleButtons = [];
@@ -203,8 +190,7 @@ export async function captureFailureContext(deps, options = {}) {
 
   try {
     // Get visible links (limit 5)
-    const linksResult = await pageController.session.send('Runtime.evaluate', {
-      expression: `
+    const linksResult = await pageController.evaluateInFrame(`
         (function() {
           const links = Array.from(document.querySelectorAll('a[href]'));
           return links
@@ -219,9 +205,7 @@ export async function captureFailureContext(deps, options = {}) {
               href: a.href ? a.href.substring(0, 100) : ''
             }));
         })()
-      `,
-      returnByValue: true
-    });
+      `);
     context.visibleLinks = linksResult.result.value || [];
   } catch {
     context.visibleLinks = [];
@@ -229,8 +213,7 @@ export async function captureFailureContext(deps, options = {}) {
 
   try {
     // Get any visible error messages or alerts
-    const errorsResult = await pageController.session.send('Runtime.evaluate', {
-      expression: `
+    const errorsResult = await pageController.evaluateInFrame(`
         (function() {
           const errorSelectors = [
             '.error', '.alert', '.warning', '.message',
@@ -252,9 +235,7 @@ export async function captureFailureContext(deps, options = {}) {
           }
           return errors.slice(0, 3);
         })()
-      `,
-      returnByValue: true
-    });
+      `);
     context.visibleErrors = errorsResult.result.value || [];
   } catch {
     context.visibleErrors = [];
@@ -264,8 +245,7 @@ export async function captureFailureContext(deps, options = {}) {
   if (failedSelector || failedText) {
     try {
       const searchTerm = failedText || failedSelector;
-      const nearMatchesResult = await pageController.session.send('Runtime.evaluate', {
-        expression: `
+      const nearMatchesResult = await pageController.evaluateInFrame(`
           (function() {
             const searchTerm = ${JSON.stringify(searchTerm)}.toLowerCase();
             const candidates = [];
@@ -322,9 +302,7 @@ export async function captureFailureContext(deps, options = {}) {
             candidates.sort((a, b) => b.score - a.score);
             return candidates.slice(0, 5);
           })()
-        `,
-        returnByValue: true
-      });
+        `);
       context.nearMatches = nearMatchesResult.result.value || [];
     } catch {
       context.nearMatches = [];

package/src/runner/execute-dynamic.js

@@ -53,7 +53,7 @@ function processSerializedResult(raw) {
  * @returns {Promise<Object>} serialized return value
  */
 export async function executePageFunction(pageController, params) {
-  const fn = typeof params === 'string' ? params : params.fn;
+  const fn = typeof params === 'string' ? params : (params.fn || params.expression);
   const useRefs = typeof params === 'object' && params.refs === true;
   const timeout = typeof params === 'object' && typeof params.timeout === 'number'
     ? params.timeout : null;
@@ -150,11 +150,11 @@ export async function executePoll(pageController, params) {
     const rawVal = result.result.value;
     const isTruthy = rawVal !== null && rawVal !== undefined &&
       rawVal !== false && rawVal !== 0 && rawVal !== '' &&
-      !(typeof rawVal === 'object' && rawVal.type === 'null') &&
-      !(typeof rawVal === 'object' && rawVal.type === 'undefined') &&
-      !(typeof rawVal === 'object' && rawVal.type === 'boolean' && rawVal.value === false) &&
-      !(typeof rawVal === 'object' && rawVal.type === 'number' && rawVal.value === 0) &&
-      !(typeof rawVal === 'object' && rawVal.type === 'string' && rawVal.value === '');
+      !(typeof rawVal === 'object' && rawVal !== null && rawVal.type === 'null') &&
+      !(typeof rawVal === 'object' && rawVal !== null && rawVal.type === 'undefined') &&
+      !(typeof rawVal === 'object' && rawVal !== null && rawVal.type === 'boolean' && rawVal.value === false) &&
+      !(typeof rawVal === 'object' && rawVal !== null && rawVal.type === 'number' && rawVal.value === 0) &&
+      !(typeof rawVal === 'object' && rawVal !== null && rawVal.type === 'string' && rawVal.value === '');
 
     if (isTruthy) {
       return { resolved: true, value: processed, elapsed: Date.now() - start };
@@ -393,7 +393,8 @@ export async function loadSiteProfile(domain) {
  */
 export async function executeWriteSiteProfile(params) {
   if (!params || !params.domain || !params.content) {
-    throw new Error('writeSiteProfile requires domain and content');
+    const providedKeys = params ? Object.keys(params).join(', ') : 'none';
+    throw new Error(`writeSiteProfile requires domain and content (got keys: ${providedKeys})`);
   }
 
   const clean = sanitizeDomain(params.domain);

package/src/runner/execute-form.js

@@ -47,8 +47,7 @@ export async function executeExtract(deps, params) {
     throw new Error('extract requires a selector');
   }
 
-  const result = await session.send('Runtime.evaluate', {
-    expression: `
+  const extractExpr = `
       (function() {
         const selector = ${JSON.stringify(selector)};
         const typeHint = ${JSON.stringify(type)};
@@ -160,11 +159,15 @@ export async function executeExtract(deps, params) {
           };
         }
 
-        return { error: 'Could not detect data type. Use type: "table" or "list" option.', detectedType };
+        // Fallback: extract text content when element is not a table or list
+        const text = (el.textContent || '').trim();
+        return { type: 'text', text, tagName };
       })()
-    `,
-    returnByValue: true
-  });
+    `;
+  const extractArgs = { expression: extractExpr, returnByValue: true };
+  const contextId = pageController.getFrameContext();
+  if (contextId) extractArgs.contextId = contextId;
+  const result = await session.send('Runtime.evaluate', extractArgs);
 
   if (result.exceptionDetails) {
     throw new Error('Extract error: ' + result.exceptionDetails.text);
@@ -254,15 +257,12 @@ export async function executeAssert(pageController, elementLocator, params) {
 
     try {
       // Get the text content of the target element
-      const textResult = await pageController.session.send('Runtime.evaluate', {
-        expression: `
+      const textResult = await pageController.evaluateInFrame(`
           (function() {
             const el = document.querySelector(${JSON.stringify(selector)});
             return el ? el.textContent : null;
           })()
-        `,
-        returnByValue: true
-      });
+        `);
 
       const actualText = textResult.result.value;
       textAssertion.found = actualText !== null;

package/src/runner/execute-input.js

@@ -229,8 +229,8 @@ export async function executeFillActive(pageController, inputEmulator, params) {
   const session = pageController.session;
 
   // Parse params
-  const value = typeof params === 'string' ? params : params.value;
-  const clear = typeof params === 'object' ? params.clear !== false : true;
+  const value = typeof params === 'string' ? params : (params && params.value);
+  const clear = typeof params === 'object' && params !== null ? params.clear !== false : true;
 
   // Check if there's an active element and if it's editable
   const checkResult = await session.send('Runtime.evaluate', {

package/src/runner/execute-interaction.js

@@ -70,8 +70,9 @@ export async function clickWithVerification(elementLocator, inputEmulator, x, y,
  * Feature 13: Supports captureResult to detect new visible elements after hover
  */
 export async function executeHover(elementLocator, inputEmulator, ariaSnapshot, params) {
-  const selector = typeof params === 'string' ? params : params.selector;
+  const selector = typeof params === 'string' ? params : (params.selector || null);
   let ref = typeof params === 'object' ? params.ref : null;
+  const text = typeof params === 'object' ? params.text : null;
   const duration = typeof params === 'object' ? (params.duration || 0) : 0;
 
   // Detect if string selector looks like a ref (e.g., "s1e1", "s2e12")
@@ -80,9 +81,35 @@ export async function executeHover(elementLocator, inputEmulator, ariaSnapshot,
     ref = selector;
   }
   const force = typeof params === 'object' && params.force === true;
-  const timeout = typeof params === 'object' ? (params.timeout || 10000) : 10000; // Reduced from 30s to 10s
+  const timeout = typeof params === 'object' ? (params.timeout || 10000) : 10000;
   const captureResult = typeof params === 'object' && params.captureResult === true;
 
+  // Handle coordinate-based hover
+  if (typeof params === 'object' && typeof params.x === 'number' && typeof params.y === 'number' && !ref && !selector && !text) {
+    await inputEmulator.hover(params.x, params.y, { duration });
+    if (captureResult) {
+      await sleep(100);
+      return await captureHoverResult(elementLocator.session, []);
+    }
+    return { hovered: true };
+  }
+
+  // Handle text-based hover
+  if (text && ariaSnapshot) {
+    const refInfo = await ariaSnapshot.findByText(text);
+    if (!refInfo) {
+      throw elementNotFoundError(`text:${text}`, 0);
+    }
+    const x = refInfo.box.x + refInfo.box.width / 2;
+    const y = refInfo.box.y + refInfo.box.height / 2;
+    await inputEmulator.hover(x, y, { duration });
+    if (captureResult) {
+      await sleep(100);
+      return await captureHoverResult(elementLocator.session, []);
+    }
+    return { hovered: true };
+  }
+
   const session = elementLocator.session;
   let visibleElementsBefore = [];
 
@@ -285,7 +312,7 @@ export async function captureHoverResult(session, visibleBefore) {
  * @returns {Promise<Object>} Drag result
  */
 export async function executeDrag(elementLocator, inputEmulator, pageController, ariaSnapshot, params) {
-  const { source, target, steps = 10, delay = 0 } = params;
+  const { source, target, steps = 10, delay = 0, method = 'auto' } = params;
   const session = elementLocator.session;
 
   // Helper to get element bounding box by ref
@@ -305,8 +332,6 @@ export async function executeDrag(elementLocator, inputEmulator, pageController,
 
   // Helper to get element bounding box in current frame context
   async function getElementBox(selector) {
-    // Use page controller's frame context if available
-    const contextId = pageController.currentExecutionContextId;
     const evalParams = {
       expression: `
         (function() {
@@ -319,10 +344,8 @@ export async function executeDrag(elementLocator, inputEmulator, pageController,
       returnByValue: true
     };
 
-    // Add context ID if we're in a non-main frame
-    if (contextId && pageController.currentFrameId !== pageController.mainFrameId) {
-      evalParams.contextId = contextId;
-    }
+    const contextId = pageController.getFrameContext();
+    if (contextId) evalParams.contextId = contextId;
 
     const result = await session.send('Runtime.evaluate', evalParams);
     if (result.exceptionDetails) {
@@ -415,10 +438,10 @@ export async function executeDrag(elementLocator, inputEmulator, pageController,
         const targetX = ${targetX};
         const targetY = ${targetY};
         const steps = ${steps};
+        const method = ${JSON.stringify(method)};
 
         // Check if source is an input[type=range] (slider)
         if (sourceEl && sourceEl.tagName === 'INPUT' && sourceEl.type === 'range') {
-          // For range inputs, calculate the value based on target position
           const rect = sourceEl.getBoundingClientRect();
           const percent = Math.max(0, Math.min(1, (targetX - rect.left) / rect.width));
           const min = parseFloat(sourceEl.min) || 0;
@@ -430,130 +453,86 @@ export async function executeDrag(elementLocator, inputEmulator, pageController,
           return { success: true, method: 'range-input', value: newValue };
         }
 
-        // Try HTML5 Drag and Drop API first
-        if (sourceEl && targetEl) {
+        function doMouseDrag() {
+          const sourceElAtPoint = sourceEl || document.elementFromPoint(sourceX, sourceY);
+          if (!sourceElAtPoint) {
+            return { success: false, error: 'No element at source coordinates' };
+          }
+
+          sourceElAtPoint.dispatchEvent(new MouseEvent('mousedown', {
+            bubbles: true, cancelable: true,
+            clientX: sourceX, clientY: sourceY, button: 0, buttons: 1
+          }));
+
+          const deltaX = (targetX - sourceX) / steps;
+          const deltaY = (targetY - sourceY) / steps;
+
+          for (let i = 1; i <= steps; i++) {
+            const currentX = sourceX + deltaX * i;
+            const currentY = sourceY + deltaY * i;
+            const elAtPoint = document.elementFromPoint(currentX, currentY) || sourceElAtPoint;
+            elAtPoint.dispatchEvent(new MouseEvent('mousemove', {
+              bubbles: true, cancelable: true,
+              clientX: currentX, clientY: currentY, button: 0, buttons: 1
+            }));
+          }
+
+          const targetElAtPoint = document.elementFromPoint(targetX, targetY) || sourceElAtPoint;
+          targetElAtPoint.dispatchEvent(new MouseEvent('mouseup', {
+            bubbles: true, cancelable: true,
+            clientX: targetX, clientY: targetY, button: 0, buttons: 0
+          }));
+
+          return { success: true, method: 'mouse-events' };
+        }
+
+        function doHtml5Drag() {
+          if (!sourceEl || !targetEl) {
+            return { success: false, error: 'HTML5 DnD requires both source and target elements' };
+          }
           try {
-            // Create DataTransfer object
             const dataTransfer = new DataTransfer();
             dataTransfer.effectAllowed = 'all';
             dataTransfer.dropEffect = 'move';
 
-            // Dispatch dragstart on source
-            const dragStartEvent = new DragEvent('dragstart', {
-              bubbles: true,
-              cancelable: true,
-              dataTransfer: dataTransfer,
-              clientX: sourceX,
-              clientY: sourceY
-            });
-            sourceEl.dispatchEvent(dragStartEvent);
-
-            // Dispatch drag on source
-            const dragEvent = new DragEvent('drag', {
-              bubbles: true,
-              cancelable: true,
-              dataTransfer: dataTransfer,
-              clientX: sourceX,
-              clientY: sourceY
-            });
-            sourceEl.dispatchEvent(dragEvent);
-
-            // Dispatch dragenter on target
-            const dragEnterEvent = new DragEvent('dragenter', {
-              bubbles: true,
-              cancelable: true,
-              dataTransfer: dataTransfer,
-              clientX: targetX,
-              clientY: targetY
-            });
-            targetEl.dispatchEvent(dragEnterEvent);
-
-            // Dispatch dragover on target
-            const dragOverEvent = new DragEvent('dragover', {
-              bubbles: true,
-              cancelable: true,
-              dataTransfer: dataTransfer,
-              clientX: targetX,
-              clientY: targetY
-            });
-            targetEl.dispatchEvent(dragOverEvent);
-
-            // Dispatch drop on target
-            const dropEvent = new DragEvent('drop', {
-              bubbles: true,
-              cancelable: true,
-              dataTransfer: dataTransfer,
-              clientX: targetX,
-              clientY: targetY
-            });
-            targetEl.dispatchEvent(dropEvent);
-
-            // Dispatch dragend on source
-            const dragEndEvent = new DragEvent('dragend', {
-              bubbles: true,
-              cancelable: true,
-              dataTransfer: dataTransfer,
-              clientX: targetX,
-              clientY: targetY
-            });
-            sourceEl.dispatchEvent(dragEndEvent);
+            sourceEl.dispatchEvent(new DragEvent('dragstart', {
+              bubbles: true, cancelable: true, dataTransfer, clientX: sourceX, clientY: sourceY
+            }));
+            sourceEl.dispatchEvent(new DragEvent('drag', {
+              bubbles: true, cancelable: true, dataTransfer, clientX: sourceX, clientY: sourceY
+            }));
+            targetEl.dispatchEvent(new DragEvent('dragenter', {
+              bubbles: true, cancelable: true, dataTransfer, clientX: targetX, clientY: targetY
+            }));
+            targetEl.dispatchEvent(new DragEvent('dragover', {
+              bubbles: true, cancelable: true, dataTransfer, clientX: targetX, clientY: targetY
+            }));
+            targetEl.dispatchEvent(new DragEvent('drop', {
+              bubbles: true, cancelable: true, dataTransfer, clientX: targetX, clientY: targetY
+            }));
+            sourceEl.dispatchEvent(new DragEvent('dragend', {
+              bubbles: true, cancelable: true, dataTransfer, clientX: targetX, clientY: targetY
+            }));
 
             return { success: true, method: 'html5-dnd' };
           } catch (e) {
-            // Fall through to mouse events
+            return { success: false, error: e.message };
           }
         }
 
-        // Fallback: Mouse event simulation for non-DnD dragging (e.g., sortable lists, custom drag)
-        const sourceElAtPoint = sourceEl || document.elementFromPoint(sourceX, sourceY);
-        if (!sourceElAtPoint) {
-          return { success: false, error: 'No element at source coordinates' };
-        }
+        if (method === 'mouse') return doMouseDrag();
+        if (method === 'html5') return doHtml5Drag();
+
+        // auto: try mouse first (works for jQuery UI, sortable lists), then HTML5 DnD
+        const mouseResult = doMouseDrag();
+        if (mouseResult.success) return mouseResult;
 
-        // Dispatch mouse events
-        const mouseDown = new MouseEvent('mousedown', {
-          bubbles: true,
-          cancelable: true,
-          clientX: sourceX,
-          clientY: sourceY,
-          button: 0,
-          buttons: 1
-        });
-        sourceElAtPoint.dispatchEvent(mouseDown);
-
-        // Move in steps
-        const deltaX = (targetX - sourceX) / steps;
-        const deltaY = (targetY - sourceY) / steps;
-
-        for (let i = 1; i <= steps; i++) {
-          const currentX = sourceX + deltaX * i;
-          const currentY = sourceY + deltaY * i;
-          const elAtPoint = document.elementFromPoint(currentX, currentY) || sourceElAtPoint;
-
-          const mouseMove = new MouseEvent('mousemove', {
-            bubbles: true,
-            cancelable: true,
-            clientX: currentX,
-            clientY: currentY,
-            button: 0,
-            buttons: 1
-          });
-          elAtPoint.dispatchEvent(mouseMove);
+        if (sourceEl && targetEl) {
+          const html5Result = doHtml5Drag();
+          if (html5Result.success) return html5Result;
         }
 
-        // Release at target
-        const targetElAtPoint = document.elementFromPoint(targetX, targetY) || sourceElAtPoint;
-        const mouseUp = new MouseEvent('mouseup', {
-          bubbles: true,
-          cancelable: true,
-          clientX: targetX,
-          clientY: targetY,
-          button: 0,
-          buttons: 0
-        });
-        targetElAtPoint.dispatchEvent(mouseUp);
-
-        return { success: true, method: 'mouse-events' };
+        return mouseResult;
       })()
     `,
     returnByValue: true,

package/src/runner/execute-navigation.js

@@ -95,40 +95,30 @@ export async function executeScroll(elementLocator, inputEmulator, pageControlle
       throw new Error(`Element ref:${ref} is no longer attached to the DOM. Run 'snapshot' again to get fresh refs.`);
     }
     // Scroll to element using its coordinates
-    await pageController.session.send('Runtime.evaluate', {
-      expression: `
+    await pageController.evaluateInFrame(`
         (function() {
           const el = window.__ariaRefs && window.__ariaRefs.get(${JSON.stringify(ref)});
           if (el && el.scrollIntoView) {
             el.scrollIntoView({ block: 'center', behavior: 'smooth' });
           }
         })()
-      `
-    });
+      `);
   }
 
   if (typeof params === 'string') {
     // Direction-based scroll
     switch (params) {
       case 'top':
-        await pageController.session.send('Runtime.evaluate', {
-          expression: 'window.scrollTo(0, 0)'
-        });
+        await pageController.evaluateInFrame('window.scrollTo(0, 0)');
         break;
       case 'bottom':
-        await pageController.session.send('Runtime.evaluate', {
-          expression: 'window.scrollTo(0, document.body.scrollHeight)'
-        });
+        await pageController.evaluateInFrame('window.scrollTo(0, document.body.scrollHeight)');
         break;
       case 'up':
-        await pageController.session.send('Runtime.evaluate', {
-          expression: 'window.scrollBy(0, -300)'
-        });
+        await pageController.evaluateInFrame('window.scrollBy(0, -300)');
         break;
       case 'down':
-        await pageController.session.send('Runtime.evaluate', {
-          expression: 'window.scrollBy(0, 300)'
-        });
+        await pageController.evaluateInFrame('window.scrollBy(0, 300)');
         break;
       default:
         // Check if it looks like a ref (e.g., "s1e1", "s2e12")
@@ -159,22 +149,17 @@ export async function executeScroll(elementLocator, inputEmulator, pageControlle
       await el.dispose();
     } else if (params.deltaY !== undefined || params.deltaX !== undefined) {
       // Scroll by delta using JavaScript (more reliable than CDP mouse wheel events)
-      await pageController.session.send('Runtime.evaluate', {
-        expression: `window.scrollBy(${params.deltaX || 0}, ${params.deltaY || 0})`
-      });
+      await pageController.evaluateInFrame(`window.scrollBy(${params.deltaX || 0}, ${params.deltaY || 0})`);
     } else if (params.y !== undefined) {
       // Scroll to position
-      await pageController.session.send('Runtime.evaluate', {
-        expression: `window.scrollTo(${params.x || 0}, ${params.y})`
-      });
+      await pageController.evaluateInFrame(`window.scrollTo(${params.x || 0}, ${params.y})`);
     }
   }
 
   // Return current scroll position
-  const posResult = await pageController.session.send('Runtime.evaluate', {
-    expression: '({ scrollX: window.scrollX, scrollY: window.scrollY })',
-    returnByValue: true
-  });
+  const posResult = await pageController.evaluateInFrame(
+    '({ scrollX: window.scrollX, scrollY: window.scrollY })'
+  );
 
   return posResult.result.value;
 }